NVIDIA Scene Graph Software Development Kit (NVSGSDK)

Version:
NVSGSDK v4.0.5.0

About NVSGSDK

The NVIDIA Scene Graph Software Development Kit (NVSGSDK) is an object-oriented programming library for creating scenegraph-based applications. The NVSGSDK provides a comprehensive set of classes that developers can easily combine and extend to create fast and reliable graphics applications.

About This Documentation

The documentation for the NVSGSDK is an on-line help file. This format provides easy hypertext linking between related topics. The on-line format also allows developers to copy source code from the documentation to paste into plug-ins. This is especially handy in the Reference sections.

What's New

The new NVSGSDK adds a lot of enhancements to support the visual simulator area. One of the key-enhancements, in terms of simulator support, is the direct support of the OpenFlight file format.

Support of the Collada(TM) file format has been added to improve the workflow of 3D digital content developers. Also the compatibility to FX Composer 2 and mental mill Artist Edition has been improved regarding the interchangeability of CgFX effects.

As a new feature, the new NVSGSDK introduces generic vertex attributes to provide a more generic and more flexible per-vertex computation through vertex programs.

Through full support of OpenGL 2.1 the NVSGSDK exploits the most recent 3D graphics features provided by the newest generation of 3D graphics boards.

The animation support inside the NVSGSDK has undergone significant improvements. Not only the Animation API has been improved but also the animation of vertex attributes has been introduced. Additional enhancements are the introduction of flipbook animations and the support of asynchronous animations.

Contents

Getting Started

  • NVSG SDK 3.2 Migration Guide
  • Frequently Asked Questions - FAQ
  • Understanding the Contents Pane
  • What You Need to Get Started
  • Using the NVSGSDK
  • How to Use the Sample Viewer
  • Creating a New NVSG Project
  • Building the Sample Files
  • Recommended Reading

Fundamental Concepts

  • Fundamental Concepts of the NVSGSDK
  • Important Concepts - Must Read for All Developers
  • Separation of Data from Their Operations
  • Overview of the Principal Classes
  • Working With NVSG Classes
  • Working with Texture Maps
  • NVSG Core Objects
  • Working with Lights
  • Working with State Attributes
  • Traversers
  • Working with Traversers

Advanced

  • Working with Multitexturing
  • Hit Testing
  • Defining the View Frustum
  • How to Derive an NVSG Object
  • How to Derive a Traverser
  • Creating a New Plug-in Project
  • Writing a Loader/Saver Plug-In
  • How to Use Volumes and the Volume Bricker

Legal

  • NVSG License Agreement
  • Legal Notice

Copyright (c) 2007 NVIDIA Corporation. All rights reserved.

Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


File Index

Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

NVSGSDK File List

Here is a list of all documented files with brief descriptions:
Allocator.h [code]
AlphaTestAttribute.h [code]
AnalyzeTraverser.h [code]
AnimatedTransform.h [code]
AnimatedVertexAttributeSet.h [code]
Animation.h [code]
AnimationManipulator.h [code]
AppTraverser.h [code]
Assert.h [code]
BalanceTraverser.h [code]
BaseRenderElement.h [code]
Billboard.h [code]
BitMask.h [code]
BlendAttribute.h [code]
Boxnt.h [code]
CallBackServer.h [code]
Camera.h [code]
CgDecomposer.h [code]
CgFx.h [code]
CgFxLoader.h [code]
ChangeCallBack.h [code]
ClipPlanesElement.h [code]
CombineTraverser.h [code]
Conditioners.h [code]
Console.h [code]
Conversion.h [code]
CoreTypes.h [code]
CPUSkinningProcessor.h [code]
CubeMapViewer.h [code]
CullData.h [code]
CullTraverser.h [code]
DAELoader.h [code]
DAL.h [code]
DbgNew.h [code]
DefaultCullTraverser.h [code]
DepthAttribute.h [code]
DestrippingTraverser.h [code]
DirectedLight.h [code]
Drawable.h [code]
EliminateTraverser.h [code]
ErrorHandler.h [code]
ErrorHandling.h [code]
ExtractGeometryTraverser.h [code]
Face.h [code]
FaceAttribute.h [code]
FBO.h [code]
FileMapping.h [code]
FlightCameraManipulator.h [code]
FlipbookAnimation.h [code]
FLTLoader.h [code]
FLTTextureAttribute.h [code]
FramedAnimation.h [code]
FrustumCullTraverser.h [code]
GeoNode.h [code]
GLCgGLStateCallbacks.h [code]
GLContext.h [code]
GLDALData.h [code]
GLEvalVertexAttrib.h [code]
GLFunctions.h [code]
GLMFCRAWnd.h [code]
GLObjects.h [code]
GLStatistics.h [code]
GLTraverser.h [code]
GLUploadTraverser.h [code]
GLWinRenderArea.h [code]
GLWinRenderAreaUtil.h [code]
glxtypes.h [code]
GPUSkinningProcessor.h [code]
Group.h [code]
Handle.h [code]
HighlightBox.h [code]
HighlightEdges.h [code]
HighLightElement.h [code]
HighlightObject.h [code]
IdentityToGroupTraverser.h [code]
ILTexLoader.h [code]
ILTexSaver.h [code]
Incarnation.h [code]
IndependentPrimitiveSet.h [code]
IOLayer.h [code]
KeyFramedAnimation.h [code]
KeyInput.h [code]
LightingAttribute.h [code]
LightsElement.h [code]
LightSource.h [code]
LinearInterpolatedAnimation.h [code]
LineAttribute.h [code]
Lines.h [code]
LineStrips.h [code]
LinuxTypes.h [code]
LOD.h [code]
Log.h [code]
Manipulator.h [code]
Map.h [code]
MapArray.h [code]
MapElement.h [code]
MapList.h [code]
MapMatrix.h [code]
MapObject.h [code]
Material.h [code]
Matnnt.h [code]
MemFunTbl.h [code]
MeshedPrimitiveSet.h [code]
ModelViewTraverser.h [code]
MouseInput.h [code]
NBF.h [code]
NBFLoader.h [code]
NBFSaver.h [code]
Node.h [code]
NodeHintsCullTraverser.h [code]
NormalizeTraverser.h [code]
NvApiError.h [code]
NVBLoader.h [code]
NVBLoadTraverser.h [code]
nvgl.h [code]
NvGvoApi.h [code]
nvmath.h [code]
NVNVB.h [code]
NVNVB2.h [code]
nvsg.h [code]
nvsgapi.h [code]
nvsgcommon.h [code]
nvsggnudefs.h [code]
NVSGLight.cg
NVSGLoader.h [code]
NVSGMaterial.cg
NVSGSaver.h [code]
NVSGScene.cg
NVSGVersion.h [code]
nvsgwindefs.h [code]
nvtraverser.h [code]
nvui.h [code]
nvutil.h [code]
Object.h [code]
OBJLoader.h [code]
OBJSaver.h [code]
OptimizeTraverser.h [code]
OwnedObject.h [code]
ParallelCamera.h [code]
Path.h [code]
PBuffer.h [code]
PerspectiveCamera.h [code]
Planent.h [code]
PlugIn.h [code]
PlugInCallback.h [code]
PlugInterface.h [code]
PlugInterfaceID.h [code]
PLYLoader.h [code]
PointAttribute.h [code]
PointLight.h [code]
Points.h [code]
PrimitiveAttribute.h [code]
PrimitiveSet.h [code]
ProblemLog.h [code]
QuadMeshes.h [code]
Quads.h [code]
QuadStrips.h [code]
Quatt.h [code]
RayIntersectTraverser.h [code]
RCObject.h [code]
ReadObj.h [code]
Registry.h [code]
RenderArea.h [code]
RenderElement.h [code]
RenderElementPool.h [code]
Renderer.h [code]
RenderTraverser.h [code]
resource.h [code]
Scene.h [code]
SearchTraverser.h [code]
ShaderBuilder.h [code]
Shape.h [code]
SimpleTesselator.h [code]
Singleton.h [code]
Skin.h [code]
SkinnedTriangles.h [code]
SmoothTraverser.h [code]
Spherent.h [code]
SpotLight.h [code]
StackedAtlas.h [code]
StateAttribute.h [code]
StatePass.h [code]
StateSet.h [code]
StateVariant.h [code]
Loader/ILTexLoader/stdafx.h [code]
Loader/NBFLoader/stdafx.h [code]
Loader/VolLoader/stdafx.h [code]
Saver/ILTexSaver/stdafx.h [code]
Saver/NBFSaver/stdafx.h [code]
Saver/VolSaver/stdafx.h [code]
StrippedPrimitiveSet.h [code]
StrippingTraverser.h [code]
Switch.h [code]
SWMRSync.h [code]
TaiManager.h [code]
TextureAttribute.h [code]
TextureImage.h [code]
Tools.h [code]
Trace.h [code]
Trackball.h [code]
TrackballCameraManipulator.h [code]
TrackballTransformManipulator.h [code]
Trafo.h [code]
Transform.h [code]
TransformElement.h [code]
TransformManipulator.h [code]
TransformStack.h [code]
Traverser.h [code]
Triangles.h [code]
TriangulateTraverser.h [code]
TriFans.h [code]
TriStrips.h [code]
Types.h [code]
UnifyTraverser.h [code]
UnlitColorAttribute.h [code]
Validated.h [code]
Vecnt.h [code]
VertexAttribute.h [code]
VertexAttributeSet.h [code]
VertexUnifyTraverser.h [code]
ViewState.h [code]
VNVector.h [code]
VolLoader.h [code]
VolSaver.h [code]
VolumeBrick.h [code]
VolumeNode.h [code]
VolumeTexture.h [code]
VRMLTypes.h [code]
WalkCameraManipulator.h [code]
WRLLoader.h [code]
WRLLoadTraverser.h [code]
XMLLoader.h [code]
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


Allocator.h File Reference

#include "nvsgcommon.h"
#include <algorithm>
#include <vector>
#include "nvutil/Assert.h"
#include "nvutil/Singleton.h"
#include "nvutil/SWMRSync.h"
#include "nvutil/Trace.h"

Include dependency graph for Allocator.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:27:29 2008 for NVSGSDK by NVIDIA


Allocator.h Source File

Allocator.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 //#define ALLOCATION_COUNTER
00018
00019 // placement operator new does not have a matching delete operator!
00020 //
00021 // objects of type T that are constructed at explicit specified memory
00022 // locations by using the placement operator new() (i.g. new((void*)p) T())
00023 // should be destructed by explicitely calling their destructor (p->~T())
00024 #pragma warning(disable:4291)
00025
00026 #include <algorithm>
00027 #include <vector>
00028 #if defined( ALLOCATION_COUNTER )
00029 #include <map>
00030 #endif
00031 #include "nvutil/Assert.h"
00032 #include "nvutil/Singleton.h"
00033 #include "nvutil/SWMRSync.h"
00034 #include "nvutil/Trace.h"
00035
00036 namespace nvutil
00037 {
00039   class Chunk
00040   {
00041     public:
00043       Chunk(size_t blockSize);
00044
00046       bool operator==(const Chunk& rhs) const;
00047       bool operator!=(const Chunk& rhs) const;
00048
00050       void * alloc();
00051       void dealloc(void * p);
00053       void freeMemory();
00054
00056       unsigned char blocksAvailable() const;
00058       bool isUnused() const;
00060       bool isInsideBounds(void * p) const;
00061
00062     private:
00064       enum { numBlocks = 255 };
00065
00067       void init();
00068
00070       void * lowerBound() const;
00071       void * upperBound() const;
00072
00073       unsigned char * m_rawMem; // raw memory
00074
00076       size_t m_blockSize;
00077       size_t m_chunkSize;
00078
00079       unsigned char m_firstAvailableBlock;  // addresses first memory block available
00080       unsigned char m_blocksAvailable;      // total amount of blocks available
00081   };
00082
00084   class FixedAllocator
00085   {
00086     public:
00088       FixedAllocator();
00089
00091       ~FixedAllocator();
00092
00094       void * alloc();
00095
00097       void dealloc(void * p);
00098
00100       void init ( size_t blockSize );
00101
00102     private:
00103       size_t m_blockSize;   // fixed block size
00104
00105       typedef std::vector< Chunk > Chunks;
00106       Chunks m_chunks; // array of chunks
00107
00108       Chunk  * m_lastAlloc;   // last chunk taken for allocation
00109       Chunk  * m_lastDealloc; // last chunk taken for deallocation
00110   };
00111
00112 //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
00114
00118   class Allocator
00119   {
00120     public:
00122
00123       Allocator();
00124
00126
00127       ~Allocator();
00128
00130
00131       void * alloc( size_t size
00132                   );
00133
00134 #if !defined(NDEBUG)
00135
00136
00138       void * alloc( size_t size
00139                   , const char * src
00140                   , unsigned int ln
00141                   );
00142 #endif
00143
00145
00147       void dealloc( void * p
00148                   , size_t size
00149                   );
00150
00151     private:
00153       void * palloc(size_t size);
00154
00155     private:
00156       // forward to default new/delete operators if block size
00157       // exceeds the threshold given by maxBlockSize
00158       enum { maxBlockSize = 256 };
00159
00160       // provide one allocator for each single size <= maxBlockSize
00161       FixedAllocator m_allocTbl[maxBlockSize];
00162
00163       SWMRSync m_lock; // for synchronizing concurrent access
00164
00165       // leak detection in debug mode
00166 #if !defined(NDEBUG)
00167       struct DbgAllocInfo
00168       {
00169         void  * p;            //  memory location
00170         std::string  source;  //  source file of allocation
00171         unsigned int ln;      //  line of allocation
00172
00173         // with this we can simply use a vector for our alloc infos
00174         bool operator==(void * _p) const { return p==_p; }
00175         bool operator!=(void * _p) const { return p!=_p; }
00176       };
00177
00178       std::vector<DbgAllocInfo> m_dbgAllocInfos;   //  vector of allocation infos
00179
00180       //  helper functor to put out a memory leak warning
00181       struct LeakWarning
00182       {
00183         void operator()(const DbgAllocInfo& allocInfo) const
00184         {
00185           std::string str;
00186           char cPtr[sizeof(void*)*2+1];
00187           sprintf(cPtr, "%p", allocInfo.p); // cast to a hex-string for pointers
00188           char cLine[20];  // enough for 64-bit integers even
00189           sprintf(cLine, "%d", allocInfo.ln);
00190
00191           str = "****Memory Leak Detected*** Source: ";
00192           str += allocInfo.source;
00193           str += ", Line: ";
00194           str += cLine;
00195           str += ", Ptr: 0x";
00196           str += cPtr;
00197           str += "\n";
00198           traceDebugOutput()(str.c_str());
00199         }
00200       };
00201 #endif
00202 #if defined( ALLOCATION_COUNTER )
00203       std::map<size_t,size_t> m_allocSizeMap;
00204 #endif
00205   };
00206
00207   inline void * Allocator::alloc(size_t size)
00208   {
00209     NVSG_ASSERT(!"WARNING: Bypassing leak detection in debug mode!\n");
00210     AutoLock lock(m_lock);
00211     return palloc(size);
00212   }
00213
00214 #if !defined(NDEBUG)
00215   inline void * Allocator::alloc(size_t size, const char* src, unsigned int ln)
00216   {
00217     AutoLock lock(m_lock);
00218     DbgAllocInfo allocInfo;
00219     // collect allocation info for memory leak detection
00220     allocInfo.p = palloc(size);
00221     allocInfo.source = src;
00222     allocInfo.ln = ln;
00223     m_dbgAllocInfos.push_back(allocInfo);
00224     return allocInfo.p;
00225   }
00226 #endif
00227
00228   inline void Allocator::dealloc(void *p, size_t size)
00229   {
00230     AutoLock lock(m_lock);
00231 #if !defined(NDEBUG)
00232     m_dbgAllocInfos.erase(std::remove(m_dbgAllocInfos.begin(), m_dbgAllocInfos.end(), p), m_dbgAllocInfos.end());
00233 #endif
00234     if ( size <= maxBlockSize )
00235     {
00236       m_allocTbl[size-1].dealloc(p);
00237     }
00238     else
00239     {
00240       ::operator delete(p);
00241     }
00242   }
00243
00244   inline void * Allocator::palloc(size_t size)
00245   {
00246 #if defined( ALLOCATION_COUNTER )
00247     m_allocSizeMap[size]++;
00248 #endif
00249     // use suitable allocation for given size
00250     return (size<=maxBlockSize) ? m_allocTbl[size-1].alloc() : ::operator new(size);
00251   }
00252 //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
00253
00255
00261   class IAllocator
00262   {
00263     public:
00265       typedef Singleton<Allocator> theAllocator;
00266
00268
00270       IAllocator() {}
00272       virtual ~IAllocator() {}
00273
00275
00277       NVSG_API void * operator new( size_t size // Size in bytes of demanded memory block.
00278                                   );
00279 #if !defined(NDEBUG)
00280
00281
00284       NVSG_API void * operator new( size_t size       // Size in bytes of demanded memory block.
00285                                   , const char * src  // Source file where allocation takes place.
00286                                   , unsigned int ln   // Line number within the source file where allocation takes place.
00287                                   );
00288 #endif
00289
00290
00296       NVSG_API void * operator new( size_t size // Size in bytes of demanded memory block.
00297                                   , void * p    // Start address of a valid memory block where the object will be created.
00298                                   );
00300
00301       NVSG_API void operator delete( void * p    // Start address of memory block to be freed.
00302                                   , size_t size // Size of memory block to be freed.
00303                                   );
00304   };
00305
00306
00307   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00308   // implementation following
00309   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00310
00316   inline void Chunk::init()
00317   {
00318     m_rawMem = ::new unsigned char[m_chunkSize];
00319
00320     m_firstAvailableBlock = 0;
00321     m_blocksAvailable = numBlocks;
00322
00323     unsigned char * p = m_rawMem;
00324     for ( unsigned char i=0; i!=numBlocks; p+=m_blockSize )
00325     {
00326       // code indices of next available blocks in first byte of each block
00327       *p = ++i;
00328     }
00329   }
00330
00336   inline void Chunk::freeMemory()
00337   {
00338     // should not attempt to free memory of a chunk in use
00339     NVSG_ASSERT(isUnused());
00340     ::delete[] m_rawMem;
00341   }
00342
00348   inline void * Chunk::alloc()
00349   {
00350     if ( !m_blocksAvailable )
00351     {
00352       // this needs to be handled in superior layers
00353       return NULL;
00354     }
00355
00356     unsigned char * p = &m_rawMem[m_firstAvailableBlock*m_blockSize];
00357     // index of next block available is coded in first byte
00358     m_firstAvailableBlock = *p;
00359     // one block less available in this chunk
00360     --m_blocksAvailable;
00361
00362     return (void *)p;
00363   }
00364
00370   inline void Chunk::dealloc(void * p)
00371   {
00372     unsigned char * ptr = (unsigned char*)p;
00373
00374     // range check
00375     NVSG_ASSERT(ptr>=m_rawMem);
00376     NVSG_ASSERT(ptr<&m_rawMem[m_chunkSize]);
00377     // alignment check
00378     NVSG_ASSERT(!((ptr-m_rawMem)%m_blockSize));
00379
00380     *ptr = m_firstAvailableBlock;
00381     m_firstAvailableBlock = (unsigned char)((ptr - m_rawMem) / m_blockSize);
00382
00383     // truncation check
00384     NVSG_ASSERT(m_firstAvailableBlock==((ptr-m_rawMem)/m_blockSize));
00385     ++m_blocksAvailable;
00386   }
00387
00393   inline bool Chunk::operator==(const Chunk& rhs) const
00394   {
00395     // consider chunks to be equal if they point to same raw memory location
00396     NVSG_ASSERT(    ( m_rawMem != rhs.m_rawMem )
00397                 ||  (     ( m_blockSize           == rhs.m_blockSize )
00398                       &&  ( m_firstAvailableBlock == rhs.m_firstAvailableBlock )
00399                       &&  ( m_blocksAvailable     == rhs.m_blocksAvailable ) ) );
00400     return (  m_rawMem==rhs.m_rawMem );
00401   }
00402
00408   inline bool Chunk::operator!=(const Chunk& rhs) const
00409   {
00410     return !operator==(rhs);
00411   }
00412
00418   inline unsigned char Chunk::blocksAvailable() const
00419   {
00420     return m_blocksAvailable;
00421   }
00422
00428   inline bool Chunk::isInsideBounds(void * p) const
00429   {
00430     return p>=lowerBound() && p<upperBound();
00431   }
00432
00438   inline bool Chunk::isUnused() const
00439   {
00440     return m_blocksAvailable==numBlocks;
00441   }
00442
00448   inline void * Chunk::lowerBound() const
00449   {
00450     return (void*)m_rawMem;
00451   }
00452
00458   inline void * Chunk::upperBound() const
00459   {
00460     return (void*)&m_rawMem[m_chunkSize];
00461   }
00462
00468   inline void FixedAllocator::init(size_t blockSize)
00469   {
00470     m_blockSize = blockSize;
00471   }
00472
00478   inline void * IAllocator::operator new(size_t size)
00479   {
00480     return theAllocator::instance()->alloc(size);
00481   }
00482
00483 #if !defined(NDEBUG)
00484   // provide memory leak detection in debug mode
00485   inline void * IAllocator::operator new(size_t size, const char * src, unsigned int ln)
00486   {
00487     return theAllocator::instance()->alloc(size, src, ln);
00488   }
00489 #endif
00490
00496   inline void * IAllocator::operator new(size_t size, void * p)
00497   {
00498     // as this is used when constructing an object at a explicit
00499     // specified memory location, that location shoud be a valid
00500     // one - assert this!
00501     NVSG_ASSERT(p);
00502     return p;
00503   }
00504
00510   inline void IAllocator::operator delete(void * p, size_t size)
00511   {
00512     theAllocator::instance()->dealloc(p, size);
00513   }
00514
00515 } // namespace nvutil
00516
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


AlphaTestAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/StateAttribute.h"

Include dependency graph for AlphaTestAttribute.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:29 2008 for NVSGSDK by NVIDIA


AlphaTestAttribute.h Source File

AlphaTestAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/StateAttribute.h"
00017
00018
00019 namespace nvsg
00020 {
00028   typedef enum
00029   {
00030     AF_NEVER = 0,
00031     AF_LESS,
00032     AF_EQUAL,
00033     AF_LEQUAL,
00034     AF_GREATER,
00035     AF_NOTEQUAL,
00036     AF_GEQUAL,
00037     AF_ALWAYS
00038   } AlphaFunction;
00039
00048   class AlphaTestAttribute : public StateAttribute
00049   {
00050     public:
00055       NVSG_API AlphaTestAttribute();
00056
00061       NVSG_API explicit AlphaTestAttribute( const StateAttribute &rhs );
00062
00065       NVSG_API AlphaTestAttribute( const AlphaTestAttribute &rhs );
00066
00068       NVSG_API virtual ~AlphaTestAttribute();
00069
00077       NVSG_API void setAlphaFunction( AlphaFunction func );
00078
00082       NVSG_API AlphaFunction getAlphaFunction() const;
00083
00088       NVSG_API void setThreshold( float threshold );
00089
00093       NVSG_API float getThreshold() const;
00094
00099       NVSG_API bool getEnabledDuringMultiSampleAlpha() const;
00100
00108       NVSG_API void setEnabledDuringMultiSampleAlpha( bool state );
00109
00116       NVSG_API virtual bool isTransparent() const;
00117
00127       NVSG_API virtual bool isEquivalent( const Object *p
00128                                         , bool ignoreNames
00129                                         , bool deepCompare ) const;
00130
00137       NVSG_API AlphaTestAttribute & operator=(const AlphaTestAttribute & rhs);
00138
00139     private:
00140       AlphaFunction  m_alphaFunction;
00141       float          m_threshold;
00142       bool           m_enabledDuringMultiSampleAlpha;
00143   };
00144
00145   inline AlphaFunction AlphaTestAttribute::getAlphaFunction() const
00146   {
00147     return( m_alphaFunction );
00148   }
00149
00150   inline float AlphaTestAttribute::getThreshold() const
00151   {
00152     return( m_threshold );
00153   }
00154
00155   inline bool AlphaTestAttribute::getEnabledDuringMultiSampleAlpha() const
00156   {
00157     return( m_enabledDuringMultiSampleAlpha );
00158   }
00159
00160 } // namespace nvsg
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


AnalyzeTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvsg/IndependentPrimitiveSet.h"
#include "nvsg/StrippedPrimitiveSet.h"
#include "nvtraverser/Traverser.h"
#include <map>
#include <set>

Include dependency graph for AnalyzeTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:30 2008 for NVSGSDK by NVIDIA


AnalyzeTraverser.h Source File

AnalyzeTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/IndependentPrimitiveSet.h"
00017 #include "nvsg/StrippedPrimitiveSet.h"
00018 #include "nvtraverser/Traverser.h"
00019
00020 #include <map>
00021 #include <set>
00022
00023 namespace nvtraverser
00024 {
00032   class AnalyzeResult
00033   {
00034     public:
00036       virtual ~AnalyzeResult() {};
00037
00038     public:
00039       unsigned int  objectCode;
00040       unsigned int  objectCount;
00041   };
00042
00051   class CombinableResult : public AnalyzeResult
00052   {
00053     public:
00054       virtual ~CombinableResult() {};
00055
00056     public:
00057       unsigned int  combinableCount;
00058       unsigned int  reducedCount;
00059   };
00060
00065   class DenormalizedNormalsResult : public AnalyzeResult
00066   {
00067     public:
00068       virtual ~DenormalizedNormalsResult() {}
00069
00070     public:
00071       unsigned int  denormalizedNormalsCount;
00072       unsigned int  denormalizedNormalsNumber;
00073   };
00074
00080   class EmptyResult : public AnalyzeResult
00081   {
00082     public:
00084       virtual ~EmptyResult() {}
00085
00086     public:
00087       unsigned int  emptyCount;
00088   };
00089
00095   class EquivalenceResult : public AnalyzeResult
00096   {
00097     public:
00099       virtual ~EquivalenceResult() {}
00100
00101     public:
00102       unsigned int  equivalentCount;
00103       unsigned int  reducedCount;
00104   };
00105
00111   class IdentityResult : public AnalyzeResult
00112   {
00113     public:
00115       virtual ~IdentityResult() {}
00116
00117     public:
00118       unsigned int  identityCount;
00119   };
00120
00126   class MissingResult : public AnalyzeResult
00127   {
00128     public:
00130       virtual ~MissingResult()  {}
00131
00132     public:
00133       unsigned int  missingCount;
00134   };
00135
00140   class NullNormalsResult : public AnalyzeResult
00141   {
00142     public:
00144       virtual ~NullNormalsResult() {}
00145
00146     public:
00147       unsigned int  nullNormalsCount;
00148       unsigned int  nullNormalsNumber;
00149   };
00150
00155   class RedundantLODRangesResult : public AnalyzeResult
00156   {
00157     public:
00159       virtual ~RedundantLODRangesResult() {}
00160
00161     public:
00162       unsigned int  lodRanges;
00163       unsigned int  redundantLODs;
00164       unsigned int  redundantLODRanges;
00165   };
00166
00172   class SingleChildResult : public AnalyzeResult
00173   {
00174     public:
00176       virtual ~SingleChildResult()  {}
00177
00178     public:
00179       unsigned int  singleChildCount;
00180   };
00181
00187   class ShortStrippedResult : public AnalyzeResult
00188   {
00189     public:
00190       virtual ~ShortStrippedResult() {}
00191
00192     public:
00193       unsigned int  shortStrippedCount;
00194       unsigned int  shortStrippedNumber;
00195   };
00196
00234   class AnalyzeTraverser : public SharedTraverser
00235   {
00236     public:
00238       NVSG_API AnalyzeTraverser( void );
00239
00248       NVSG_API unsigned int getAnalysis( std::vector<AnalyzeResult*> &results ) const;
00249
00250     protected:
00254       NVSG_API virtual ~AnalyzeTraverser( void );
00255
00261       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00262
00268       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p );
00269
00277       NVSG_API virtual void handleAnimatedVertexAttributeSet( const nvsg::AnimatedVertexAttributeSet * p );
00278
00284       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p );
00285
00291       NVSG_API virtual void handleBlendAttribute( const nvsg::BlendAttribute * p );
00292
00297       NVSG_API virtual void handleCgFx( const nvsg::CgFx * p );
00298
00304       NVSG_API virtual void handleDepthAttribute( const nvsg::DepthAttribute * p );
00305
00311       NVSG_API virtual void handleDirectedLight( const nvsg::DirectedLight * p );
00312
00318       NVSG_API virtual void handleFaceAttribute( const nvsg::FaceAttribute * p );
00319
00325       NVSG_API virtual void handleFlipbookAnimation( const nvsg::FlipbookAnimation *p );
00326
00333       NVSG_API virtual void handleFramedIndexAnimation( const nvsg::FramedAnimation<unsigned int> * p );
00334
00341       NVSG_API virtual void handleFramedTrafoAnimation( const nvsg::FramedAnimation<nvmath::Trafo> * p );
00342
00350       NVSG_API virtual void handleFramedVertexAttributeAnimation( const nvsg::FramedAnimation<nvsg::VertexAttribute> * p );
00351
00357       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * p );
00358
00364       NVSG_API virtual void handleGroup( const nvsg::Group * p );
00365
00373       NVSG_API virtual void handleLinearInterpolatedTrafoAnimation( const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> * p );
00374
00382       NVSG_API virtual void handleLinearInterpolatedVertexAttributeAnimation( const nvsg::LinearInterpolatedAnimation<nvsg::VertexAttribute> * p );
00383
00389       NVSG_API virtual void handleLineAttribute( const nvsg::LineAttribute * p );
00390
00396       NVSG_API virtual void handleLines( const nvsg::Lines * p );
00397
00403       NVSG_API virtual void handleLineStrips( const nvsg::LineStrips * p );
00404
00410       NVSG_API virtual void handleLOD( const nvsg::LOD * p );
00411
00417       NVSG_API virtual void handleMaterial( const nvsg::Material * p );
00418
00424       NVSG_API virtual void handlePointAttribute( const nvsg::PointAttribute * p );
00425
00431       NVSG_API virtual void handlePointLight( const nvsg::PointLight * p );
00432
00438       NVSG_API virtual void handlePoints( const nvsg::Points * p );
00439
00445       NVSG_API virtual void handleQuadMeshes( const nvsg::QuadMeshes * p );
00446
00452       NVSG_API virtual void handleQuads( const nvsg::Quads * p );
00453
00459       NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips * p );
00460
00466       NVSG_API virtual void handleShape( const nvsg::Shape * p );
00467
00473       NVSG_API virtual void handleSkin( const nvsg::Skin * p );
00474
00480       NVSG_API virtual void handleSkinnedTriangles( const nvsg::SkinnedTriangles * p );
00481
00487       NVSG_API virtual void handleSpotLight( const nvsg::SpotLight * p );
00488
00494       NVSG_API virtual void handleStatePass( const nvsg::StatePass * p );
00495
00501       NVSG_API virtual void handleStateSet( const nvsg::StateSet * p );
00502
00508       NVSG_API virtual void handleStateVariant( const nvsg::StateVariant * p );
00509
00515       NVSG_API virtual void handleSwitch( const nvsg::Switch * p );
00516
00522       NVSG_API virtual void handleTextureAttribute( const nvsg::TextureAttribute * p );
00523
00530       NVSG_API virtual void handleTextureAttributeItem( const nvsg::TextureAttributeItem * p
00531                                                       , unsigned int tu );
00532
00538       NVSG_API virtual void handleTransform( const nvsg::Transform * p );
00539
00545       NVSG_API virtual void handleTriangles( const nvsg::Triangles * p );
00546
00552       NVSG_API virtual void handleTriFans( const nvsg::TriFans * p );
00553
00559       NVSG_API virtual void handleTriStrips( const nvsg::TriStrips * p );
00560
00568       NVSG_API virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet * p );
00569
00570     private:
00571       template<typename T>
00572         void analyzeCombinable( const T *p
00573                               , std::map<const nvsg::StateSet*,std::vector<std::pair<const T*,unsigned int> > > &mvpT );
00574       void analyzeCombinable( const nvsg::Group * p );
00575       void analyzeEmpty( const nvsg::Object * p, unsigned int numberOfElements );
00576       void analyzeEquivalent( const nvsg::Object *p );
00577       void analyzeNormalsNormalized( const nvmath::Vec3f * normals, unsigned int non
00578                                    , unsigned int &nullNormals, unsigned int &denormalizedNormals );
00579       void analyzeMissing( const nvsg::Object * p, const void * ptr );
00580       void analyzeRedundantLODRanges( const nvsg::LOD * p );
00581       void analyzeShortStripped( const nvsg::StrippedPrimitiveSet * p, unsigned int minCount );
00582       void analyzeSingleChild( const nvsg::Group * p );
00583       template<typename T>
00584         void extractCombinableInfo( unsigned int oc
00585                                   , std::map<const nvsg::StateSet*,std::vector<std::pair<const T*,unsigned int> > > &mvpT );
00586       bool isChildOfCurrentLOD( const nvsg::Object * p );
00587       bool isToBeHandled( const nvsg::Object *p );
00588       void testVertexAttributeSet( const nvsg::VertexAttributeSet * p );
00589
00590     private:
00591       class EquivalenceInfo
00592       {
00593         public :
00594           std::vector<nvsg::ObjectHandle *> uniqueObjects;
00595           std::set<nvsg::ObjectHandle *>    equivalentObjects;
00596       };
00597
00598       std::map<unsigned int,unsigned int>                                                             m_countMap;
00599       std::stack<std::vector<const nvsg::GeoNode*> >                                                  m_combinableGeoNodes;
00600       std::map<unsigned int,std::pair<unsigned int,unsigned int> >                                    m_combinableInfo;
00601       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::Lines*,unsigned int> > >       m_combinableLines;
00602       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::LineStrips*,unsigned int> > >  m_combinableLineStrips;
00603       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::Points*,unsigned int> > >      m_combinablePoints;
00604       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::QuadMeshes*,unsigned int> > >  m_combinableQuadMeshes;
00605       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::Quads*,unsigned int> > >       m_combinableQuads;
00606       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::QuadStrips*,unsigned int> > >  m_combinableQuadStrips;
00607       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::Triangles*,unsigned int> > >   m_combinableTriangles;
00608       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::TriFans*,unsigned int> > >     m_combinableTriFans;
00609       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::TriStrips*,unsigned int> > >   m_combinableTriStrips;
00610       const nvsg::LOD *                                                                               m_currentLOD;
00611       const nvsg::StateSet *                                                                          m_currentStateSet;
00612       std::pair<unsigned int,unsigned int>                                                            m_denormalizedNormalsLIVAA;
00613       std::pair<unsigned int,unsigned int>                                                            m_denormalizedNormalsVAS;
00614       std::map<unsigned int, unsigned int>                                                            m_emptyMap;
00615       std::map<unsigned int, EquivalenceInfo>                                                         m_equivalenceMap;
00616       unsigned int                                                                                    m_identityCount;
00617       unsigned int                                                                                    m_lodRanges;
00618       std::map<unsigned int, unsigned int>                                                            m_missingMap;
00619       std::pair<unsigned int,unsigned int>                                                            m_nullNormalsLIVAA;
00620       std::pair<unsigned int,unsigned int>                                                            m_nullNormalsVAS;
00621       unsigned int                                                                                    m_redundantLODs;
00622       unsigned int                                                                                    m_redundantLODRanges;
00623       std::set<const nvsg::Object *>                                                                  m_sharedObjects;
00624       std::map<unsigned int, unsigned int>                                                            m_singleChildMap;
00625       std::map<unsigned int, std::pair<unsigned int,unsigned int> >                                   m_shortStripped;
00626   };
00627 }
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


AnimatedTransform.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Animation.h"
#include "nvsg/Transform.h"

Include dependency graph for AnimatedTransform.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:30 2008 for NVSGSDK by NVIDIA


AnimatedTransform.h Source File

AnimatedTransform.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h" // commonly used stuff
00016 #include "nvsg/Animation.h"
00017 #include "nvsg/Transform.h" // base class definition
00018
00019 namespace nvsg
00020 {
00026   class AnimatedTransform : public Transform
00027   {
00028     public:
00031       NVSG_API AnimatedTransform();
00032
00035       NVSG_API AnimatedTransform(const AnimatedTransform& rhs);
00036
00039       NVSG_API virtual ~AnimatedTransform();
00040
00044       NVSG_API virtual const nvmath::Trafo & getTrafo( void ) const;
00045
00050       NVSG_API virtual void setTrafo( const nvmath::Trafo & trafo );
00051
00055       NVSG_API TrafoAnimationHandle * getAnimation() const;
00056
00066       NVSG_API void setAnimation( TrafoAnimationHandle *animation );
00067
00071       NVSG_API virtual bool determineAnimationContainment() const;
00072
00080       NVSG_API AnimatedTransform & operator=( const AnimatedTransform & rhs );
00081
00097       NVSG_API virtual bool isEquivalent( const Object *p
00098                                         , bool ignoreNames
00099                                         , bool deepCompare ) const;
00100
00106       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00107
00111       NVSG_API virtual bool invalidateIncarnation();
00112
00113     private:
00114       TrafoAnimationHandle  * m_animation;
00115   };
00116
00117   // - - - - - - - - - - - - - - - - - - - - - - - - -
00118   // inlines
00119   // - - - - - - - - - - - - - - - - - - - - - - - - -
00120
00121   inline const nvmath::Trafo & AnimatedTransform::getTrafo() const
00122   {
00123     NVSG_TRACE();
00124     NVSG_ASSERT( m_animation );
00125     return( nvutil::ReadableObject<Animation<nvmath::Trafo> >(m_animation)->getCurrentValue() );
00126   }
00127
00128   inline void AnimatedTransform::setTrafo( const nvmath::Trafo & trafo )
00129   {
00130     NVSG_TRACE();
00131     NVSG_ASSERT( m_animation );
00132     nvutil::WritableObject<Animation<nvmath::Trafo> > anim(m_animation);
00133     anim->replaceStep( anim->getCurrentStep(), trafo );
00134   }
00135
00136   inline TrafoAnimationHandle * AnimatedTransform::getAnimation() const
00137   {
00138     NVSG_TRACE();
00139     return( m_animation );
00140   }
00141
00142   inline bool AnimatedTransform::determineAnimationContainment() const
00143   {
00144     NVSG_TRACE();
00145     NVSG_ASSERT( m_animation );
00146     return( true );
00147   }
00148
00149 } //  namespace nvsg
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


AnimatedVertexAttributeSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/VertexAttributeSet.h"

Include dependency graph for AnimatedVertexAttributeSet.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:30 2008 for NVSGSDK by NVIDIA


AnimatedVertexAttributeSet.h Source File

AnimatedVertexAttributeSet.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/VertexAttributeSet.h"
00017
00018 namespace nvsg
00019 {
00028   class AnimatedVertexAttributeSet : public VertexAttributeSet
00029   {
00030     public:
00033       NVSG_API AnimatedVertexAttributeSet();
00034
00039       NVSG_API AnimatedVertexAttributeSet( const VertexAttributeSet & rhs );
00040
00045       NVSG_API AnimatedVertexAttributeSet( const AnimatedVertexAttributeSet & rhs );
00046
00050       NVSG_API virtual ~AnimatedVertexAttributeSet();
00051
00057       NVSG_API AnimatedVertexAttributeSet & operator=( const AnimatedVertexAttributeSet & rhs );
00058
00065       NVSG_API virtual bool isCompatible( const VertexAttributeSet * p ) const;
00066
00078       NVSG_API virtual bool isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const;
00079
00093       NVSG_API virtual void setVertexData( unsigned int attrib, unsigned int size, unsigned int type
00094                                          , const void * data, unsigned int count );
00095
00112       NVSG_API virtual void setVertexData( unsigned int attrib, unsigned int pos, unsigned int size
00113                                          , unsigned int type, const void * data, unsigned int count );
00114
00133       NVSG_API virtual void setVertexData( unsigned int attrib, const unsigned int * to
00134                                          , const unsigned int * from, unsigned int size
00135                                          , unsigned int type, const void * data, unsigned int count );
00136
00143       NVSG_API virtual void removeVertexData( unsigned int attrib );
00144
00153       NVSG_API virtual const void * getVertexData( unsigned int attrib ) const;
00154
00163       NVSG_API virtual unsigned int getSizeOfVertexData( unsigned int attrib ) const;
00164
00177       NVSG_API virtual unsigned int getTypeOfVertexData( unsigned int attrib ) const;
00178
00186       NVSG_API virtual unsigned int getNumberOfVertexData( unsigned int attrib ) const;
00187
00193       NVSG_API virtual bool validateIncarnation() const;
00194
00200       NVSG_API VertexAttributeAnimationHandle * getAnimation( unsigned int attrib ) const;
00201
00212       NVSG_API void setAnimation( unsigned int attrib, VertexAttributeAnimationHandle * animation );
00213
00221       NVSG_API void setNormalize( unsigned int attrib, bool normalize );
00222
00228       NVSG_API bool getNormalize( unsigned int attrib ) const;
00229
00233       NVSG_API unsigned int getNormalizeFlags() const;
00234
00237       NVSG_API virtual bool containsAnimation() const;
00238
00243       NVSG_API virtual bool invalidateIncarnation();
00244
00245     private:
00246       VertexAttributeAnimationHandle *  m_animations[NVSG_VERTEX_ATTRIB_COUNT];
00247       unsigned int                      m_normalizeFlags;
00248   };
00249
00250   inline VertexAttributeAnimationHandle *AnimatedVertexAttributeSet::getAnimation( unsigned int attrib ) const
00251   {
00252     NVSG_TRACE();
00253     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00254     NVSG_ASSERT(attrib>=NVSG_POSITION && attrib<=NVSG_ATTR15); // undefined behavior on invalid attrib
00255
00256     return( m_animations[attribIndex(attrib)] );
00257   }
00258
00259   inline bool AnimatedVertexAttributeSet::getNormalize( unsigned int attrib ) const
00260   {
00261     NVSG_TRACE();
00262     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00263     NVSG_ASSERT(attrib>=NVSG_POSITION && attrib<=NVSG_ATTR15); // undefined behavior on invalid attrib
00264
00265     return( !!(m_normalizeFlags & (1 << attribIndex(attrib))) );
00266   }
00267
00268   inline unsigned int AnimatedVertexAttributeSet::getNormalizeFlags() const
00269   {
00270     NVSG_TRACE();
00271     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00272     return( m_normalizeFlags );
00273   }
00274
00275 } //  namespace nvsg
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


Animation.h File Reference

#include "nvsgcommon.h"
#include "nvsg/OwnedObject.h"

Include dependency graph for Animation.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:31 2008 for NVSGSDK by NVIDIA


Animation.h Source File

Animation.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/OwnedObject.h"
00017
00018 namespace nvsg
00019 {
00020   class AnimationBase : public OwnedObject<ObjectHandle>
00021   {
00022     friend class Object;
00023
00024     public:
00025       NVSG_API virtual ~AnimationBase();
00026
00030       NVSG_API void start();
00031
00035       NVSG_API void stop();
00036
00040       NVSG_API bool isRunning() const;
00041
00050       NVSG_API bool advance( unsigned int tick, int delta = 1 );
00051
00057       NVSG_API void setSpeed( unsigned int stepsOnAdvance );
00058
00064       NVSG_API unsigned int getSpeed() const;
00065
00070       NVSG_API unsigned int getNumberOfSteps() const;
00071
00078       NVSG_API unsigned int getNumberOfFrames() const;
00079
00085       NVSG_API unsigned int getCurrentFrame() const;
00086
00090       NVSG_API bool setCurrentFrame( unsigned int frame );
00091
00097       NVSG_API unsigned int getCurrentStep() const;
00098
00102       NVSG_API virtual void removeStep( unsigned int step ) = 0;
00103
00111       NVSG_API void setLoopCount( unsigned int count );
00112
00120       NVSG_API int getLoopCount() const;
00121
00126       NVSG_API void setForwardAnimation( bool forward = true );
00127
00132       NVSG_API bool isForwardAnimation() const;
00133
00140       NVSG_API void setSwingingAnimation( bool swing = true );
00141
00148       NVSG_API bool isSwingingAnimation() const;
00149
00157       NVSG_API virtual bool isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const;
00158
00159     protected:
00164       NVSG_API AnimationBase( void );
00165
00171       NVSG_API AnimationBase & operator=( const AnimationBase & rhs );
00172
00176       NVSG_API virtual void setCurrentStep( unsigned int step );
00177
00185       NVSG_API unsigned int frameToStep( unsigned int frame ) const;
00186
00192       NVSG_API void setNumberOfSteps( unsigned int steps );
00193
00194     private:
00195       //  defining values
00196       bool          m_forward;      // true: animate from step 0 to n-1; false; animate from step n-1 to 0
00197       bool          m_swinging;     // true: swing (or ping-pong); false: loop
00198       unsigned int  m_loopCount;    // 0: forever, other: number of sings/loops
00199       unsigned int  m_speed;        // steps per advance
00200
00201       //  derived values; determined by derived classes
00202       unsigned int  m_frameCount;   // number of frames, like m_stepCount * m_loopCount
00203       unsigned int  m_stepCount;    // number of "different" steps in the animation
00204
00205       //  "temporary" values
00206       bool          m_running;      // true: animation is started; false: animation stopped
00207       unsigned int  m_currentFrame;
00208       unsigned int  m_currentTick;
00209       unsigned int  m_currentStep;
00210   };
00211
00212   inline AnimationBase::AnimationBase()
00213     : m_loopCount(0)    // infinite
00214     , m_speed(1)        // single step
00215     , m_forward(true)   // forward
00216     , m_swinging(false) // looping
00217     , m_stepCount(0)    // no steps
00218     , m_frameCount(0)   // no frames
00219     , m_running(false)  // not running
00220     , m_currentStep(0)  // start of animation
00221     , m_currentFrame(0) // start of animation
00222     , m_currentTick(~0) // not defined
00223   {
00224     NVSG_TRACE();
00225   }
00226
00227   inline AnimationBase::~AnimationBase()
00228   {
00229     NVSG_TRACE();
00230   }
00231
00232   inline void AnimationBase::start()
00233   {
00234     NVSG_TRACE();
00235     m_running = true;
00236   }
00237
00238   inline void AnimationBase::stop()
00239   {
00240     NVSG_TRACE();
00241     m_running = false;
00242   }
00243
00244   inline bool AnimationBase::isRunning() const
00245   {
00246     NVSG_TRACE();
00247     return( m_running );
00248   }
00249
00250   inline bool AnimationBase::advance( unsigned int tick, int delta )
00251   {
00252     NVSG_TRACE();
00253     bool ok = ( m_running && ( m_currentTick != tick ) );
00254     if ( ok )
00255     {
00256       m_currentTick = tick;
00257       setCurrentFrame( m_currentFrame + delta * m_speed );
00258     }
00259     return( ok );
00260   }
00261
00262   inline void AnimationBase::setSpeed( unsigned int stepsOnAdvance )
00263   {
00264     NVSG_TRACE();
00265     NVSG_ASSERT( 0 < stepsOnAdvance );
00266     m_speed = stepsOnAdvance;
00267   }
00268
00269   inline unsigned int AnimationBase::getSpeed() const
00270   {
00271     NVSG_TRACE();
00272     return( m_speed );
00273   }
00274
00275   inline unsigned int AnimationBase::getNumberOfSteps() const
00276   {
00277     NVSG_TRACE();
00278     return( m_stepCount );
00279   }
00280
00281   inline unsigned int AnimationBase::getNumberOfFrames() const
00282   {
00283     NVSG_TRACE();
00284     return( m_loopCount == 0
00285           ? UINT_MAX
00286           : ( m_swinging ? m_loopCount * 2 * ( m_stepCount - 1 ) : m_loopCount * m_stepCount ) );
00287   }
00288
00289   inline unsigned int AnimationBase::getCurrentFrame() const
00290   {
00291     NVSG_TRACE();
00292     return( m_currentFrame );
00293   }
00294
00295   inline bool AnimationBase::setCurrentFrame( unsigned int frame )
00296   {
00297     NVSG_TRACE();
00298     bool ok = ( m_currentFrame != frame );
00299     if ( ok )
00300     {
00301       m_currentFrame = frame;
00302       unsigned int step = frameToStep( m_currentFrame );
00303       if ( step != m_currentStep )
00304       {
00305         setCurrentStep( step );
00306       }
00307     }
00308     return( ok );
00309   }
00310
00311   inline void AnimationBase::setCurrentStep( unsigned int step )
00312   {
00313     NVSG_TRACE();
00314     m_currentStep = step;
00315     invalidateIncarnation();
00316   }
00317
00318   inline unsigned int AnimationBase::getCurrentStep() const
00319   {
00320     NVSG_TRACE();
00321     return( m_currentStep );
00322   }
00323
00324   inline void AnimationBase::setLoopCount( unsigned int count )
00325   {
00326     NVSG_TRACE();
00327     m_loopCount = count;
00328   }
00329
00330   inline int AnimationBase::getLoopCount() const
00331   {
00332     NVSG_TRACE();
00333     return( m_loopCount );
00334   }
00335
00336   inline void AnimationBase::setForwardAnimation( bool forward )
00337   {
00338     NVSG_TRACE();
00339     m_forward = forward;
00340   }
00341
00342   inline bool AnimationBase::isForwardAnimation() const
00343   {
00344     NVSG_TRACE();
00345     return( m_forward );
00346   }
00347
00348   inline void AnimationBase::setSwingingAnimation( bool swinging )
00349   {
00350     NVSG_TRACE();
00351     m_swinging = swinging;
00352   }
00353
00354   inline bool AnimationBase::isSwingingAnimation() const
00355   {
00356     NVSG_TRACE();
00357     return( m_swinging );
00358   }
00359
00360   inline AnimationBase & AnimationBase::operator=( const AnimationBase & rhs )
00361   {
00362     NVSG_TRACE();
00363     if (&rhs != this)
00364     {
00365       Object::operator=(rhs);
00366       m_loopCount     = rhs.m_loopCount;
00367       m_speed         = rhs.m_speed;
00368       m_forward       = rhs.m_forward;
00369       m_swinging      = rhs.m_swinging;
00370       m_running       = rhs.m_running;
00371       m_stepCount     = rhs.m_stepCount;
00372       m_frameCount    = rhs.m_frameCount;
00373       m_currentFrame  = rhs.m_currentFrame;
00374       m_currentStep   = rhs.m_currentStep;
00375       m_currentTick   = rhs.m_currentTick;
00376     }
00377     return *this;
00378   }
00379
00380   inline bool AnimationBase::isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const
00381   {
00382     NVSG_TRACE();
00383     bool equi =   ( dynamic_cast<const AnimationBase*>(p) != NULL )
00384               &&  Object::isEquivalent( p, ignoreNames, deepCompare );
00385     if ( equi )
00386     {
00387       const AnimationBase * ab = dynamic_cast<const AnimationBase*>(p);
00388       equi =    ( m_loopCount == ab->m_loopCount  )
00389             &&  ( m_speed     == ab->m_speed      )
00390             &&  ( m_forward   == ab->m_forward    )
00391             &&  ( m_swinging  == ab->m_swinging   )
00392             &&  ( m_running   == ab->m_running    )
00393             &&  ( m_stepCount == ab->m_stepCount  );
00394       NVSG_ASSERT( !equi || ( m_frameCount == ab->m_frameCount ) );
00395     }
00396     return( equi );
00397   }
00398
00399   inline unsigned int AnimationBase::frameToStep( unsigned int frame ) const
00400   {
00401     NVSG_TRACE();
00402
00403     if ( frame < getNumberOfFrames() )
00404     {
00405       //  step is in animation range
00406       if ( m_swinging )
00407       {
00408         //  ping-pong animation -> map step into interval 0 ... 2*(m_stepCount-1)
00409         frame %= 2 * ( m_stepCount - 1 );
00410         if ( m_stepCount <= frame )
00411         {
00412           //  on reverse part of animation -> map step into interval m_stepCount-2 ... 0
00413           frame = 2 * ( m_stepCount - 1 ) - frame;
00414         }
00415       }
00416       else
00417       {
00418         //  loop animation -> map step into interval 0 ... m_stepCount-1
00419         frame %= m_stepCount;
00420       }
00421       if ( ! m_forward )
00422       {
00423         //  animation's running backwards -> invert step on m_stepCount-1
00424         frame = m_stepCount - 1 - frame;
00425       }
00426     }
00427     else
00428     {
00429       //  step is out of animation range -> use step 0 or m_stepCount-1
00430       frame = ( m_forward == m_swinging ) ? 0 : ( m_stepCount - 1 );
00431     }
00432     return( frame );
00433   }
00434
00435   inline void AnimationBase::setNumberOfSteps( unsigned int steps )
00436   {
00437     NVSG_TRACE();
00438     if ( m_stepCount != steps )
00439     {
00440       m_stepCount = steps;
00441       invalidateIncarnation();
00442     }
00443   }
00444
00450   template<typename T> class Animation : public AnimationBase
00451   {
00452     public:
00455       virtual ~Animation();
00456
00461       virtual const T & getCurrentValue() const = 0;
00462
00467       virtual T getStepValue( unsigned int step ) const = 0;
00468
00473       virtual void replaceStep( unsigned int step, const T & value ) = 0;
00474
00479       T getFrameValue( unsigned int frame ) const;
00480
00484       virtual bool isCompatible( const Animation<T> * p ) const = 0;
00485
00493       virtual bool isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const;
00494
00495     protected:
00500       Animation( void );
00501
00507       Animation<T> & operator=( const Animation<T> & rhs );
00508   };
00509
00510   template<typename T>
00511   inline Animation<T>::Animation( void )
00512   {
00513     NVSG_TRACE();
00514   }
00515
00516   template<typename T>
00517   inline Animation<T>::~Animation( void )
00518   {
00519     NVSG_TRACE();
00520   }
00521
00522   template<typename T>
00523   inline T Animation<T>::getFrameValue( unsigned int frame ) const
00524   {
00525     NVSG_TRACE();
00526     return( getStepValue( frameToStep(frame) ) );
00527   }
00528
00529   template<typename T>
00530   inline Animation<T> & Animation<T>::operator=(const Animation<T> & rhs)
00531   {
00532     NVSG_TRACE();
00533     if (&rhs != this)
00534     {
00535       AnimationBase::operator=(rhs);
00536     }
00537     return *this;
00538   }
00539
00540   template<typename T>
00541   inline bool Animation<T>::isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const
00542   {
00543     NVSG_TRACE();
00544     return(   ( dynamic_cast<const Animation<T>*>(p) != NULL )
00545           &&  AnimationBase::isEquivalent( p, ignoreNames, deepCompare ) );
00546   }
00547 } //  namespace nvsg
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


AnimationManipulator.h File Reference

#include "nvsgcommon.h"
#include "nvui/Manipulator.h"
#include "nvsg/CoreTypes.h"

Include dependency graph for AnimationManipulator.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:27:31 2008 for NVSGSDK by NVIDIA


AnimationManipulator.h Source File

AnimationManipulator.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include "nvui/Manipulator.h"
00018 #include "nvsg/CoreTypes.h"
00019
00020 namespace nvui
00021 {
00035   class AnimationManipulator : public Manipulator
00036   {
00037     public:
00040       NVSG_API AnimationManipulator();
00041
00045       NVSG_API virtual ~AnimationManipulator();
00046
00071       NVSG_API virtual bool updateFrame();
00072
00078       NVSG_API virtual bool isActive() { return false; };
00079
00089       NVSG_API void setCameraAnimation( nvsg::TrafoAnimationHandle * animation );
00090
00097       NVSG_API void nextFrame();
00098
00105       NVSG_API void previousFrame();
00106
00107     protected:
00108       // we have different kinds of animations: camera animation,
00109       // skin / bone animation transformation animation ...
00110       nvsg::TrafoAnimationHandle  * m_cameraAnimation;
00111       unsigned int                  m_currentTick;
00112       int                           m_delta;
00113   };
00114
00115   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00116   // inlines
00117   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00118   inline void AnimationManipulator::nextFrame()
00119   {
00120     NVSG_TRACE();
00121     m_currentTick++;
00122     m_delta++;
00123   }
00124
00125   inline void AnimationManipulator::previousFrame()
00126   {
00127     NVSG_TRACE();
00128     m_currentTick++;
00129     m_delta--;
00130   }
00131
00132 } // namespace nvui
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


AppTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvsg/ViewState.h"
#include "nvutil/Handle.h"
#include "nvutil/RCObject.h"
#include "nvtraverser/ModelViewTraverser.h"
#include "nvsg/Skin.h"
#include "nvsg/Transform.h"

Include dependency graph for AppTraverser.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:32 2008 for NVSGSDK by NVIDIA


AppTraverser.h Source File

AppTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/ViewState.h"
00017 #include "nvutil/Handle.h"
00018 #include "nvutil/RCObject.h"
00019 #include "nvtraverser/ModelViewTraverser.h"
00020 #include "nvsg/Skin.h"
00021 #include "nvsg/Transform.h"
00022
00023 namespace nvtraverser {
00024
00026
00034 class AppTraverser : public ExclusiveModelViewTraverser
00035 {
00036 public:
00038   NVSG_API AppTraverser();
00039
00040   enum SkinningProcessorType
00041   {
00042     SKINNING_PROCESSOR_NONE,     // no skinning processor
00043     SKINNING_PROCESSOR_CPU,      // should be supported on all platforms
00044     SKINNING_PROCESSOR_GPUG80GL, // G80 skinning with geometry programs OGL
00045     SKINNING_PROCESSOR_CUDA,     // skinning with CUDA
00046     SKINNING_PROCESSOR_USER      // a user-defined skinning processor
00047   };
00048
00049   //
00050   // A "skinning processor" class to implement skinning for the App Traverser.
00051   //
00052   class SkinningProcessor : public nvutil::RCObject
00053   {
00054     public:
00056       NVSG_API SkinningProcessor();
00057
00058       // must be implemented
00059       NVSG_API virtual void process( bool requireProcessing ) = 0;
00060       NVSG_API virtual SkinningProcessorType getType() = 0;
00061
00062       // note: only called if processor is being switched at runtime
00063       NVSG_API virtual void shutdown( void ) {}
00064
00065       NVSG_API virtual void preTraverseScene();
00066       NVSG_API virtual void postTraverseScene();
00067       NVSG_API virtual void addJoint( const nvmath::Mat44f & modelToWorld
00068                                     , const nvmath::Mat44f & worldToModel
00069                                     , const nvsg::Transform * p );
00070       NVSG_API virtual void addSkin( nvsg::PrimitiveSetHandle * skinnedPrimitiveSet );
00071
00072       NVSG_API void calculateJointMatrices( nvsg::SkinHandle * skin
00073                                           , std::vector<std::pair<nvmath::Mat44f,nvmath::Mat44f> > & jointMatrices );
00074
00075     protected:
00076       // avoid stack creation since we inherit from RCObject
00077       NVSG_API virtual ~SkinningProcessor();
00078
00079     protected:
00080       std::vector<nvsg::PrimitiveSetHandle*>                                      m_skinnedPrimitiveSets;
00081       std::map<nvsg::TransformHandle*,std::pair<nvmath::Mat44f,nvmath::Mat44f> >  m_transformToJointMatrices;
00082   };
00083
00084 protected:
00086   NVSG_API virtual ~AppTraverser();
00087
00089
00092   NVSG_API virtual bool needsTraversal( nvsg::NodeHandle * root ) const;
00093
00095   NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00096
00097   // handler routine overrides
00098   NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransform * at );
00099   NVSG_API virtual void handleCgFx( nvsg::CgFx *cgfx );
00100   NVSG_API virtual void handleFramedIndexAnimation( nvsg::FramedAnimation<unsigned int> * anim );
00101   NVSG_API virtual void handleFramedTrafoAnimation( nvsg::FramedAnimation<nvmath::Trafo> * trafo );
00102   NVSG_API virtual void handleFramedVertexAttributeAnimation( nvsg::FramedAnimation<nvsg::VertexAttribute> * p );
00103   NVSG_API virtual void handleGeoNode( nvsg::GeoNode *gnode );
00104   NVSG_API virtual void handleLinearInterpolatedTrafoAnimation( nvsg::LinearInterpolatedAnimation<nvmath::Trafo> * trafo );
00105   NVSG_API virtual void handleLinearInterpolatedVertexAttributeAnimation( nvsg::LinearInterpolatedAnimation<nvsg::VertexAttribute> * p );
00106   NVSG_API virtual void handleSkinnedTriangles( nvsg::SkinnedTriangles * triangles );
00107   NVSG_API virtual void handleTransform( nvsg::Transform * p );
00108   NVSG_API virtual void handleVolumeNode( nvsg::VolumeNode * vnode );
00109
00111
00113   NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00114                                             );
00115
00117
00119   NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00120                                              );
00121
00128   NVSG_API virtual void traversePrimitiveSet( nvsg::PrimitiveSet * pset );
00129
00130   // data accessible for derived classes
00131   bool          m_bApplyingCgFx;
00132   unsigned int  m_animationFrame;
00133
00134 public:
00135
00137
00147   NVSG_API bool isSkinningProcessorSupported( SkinningProcessorType type );
00148
00150
00153   NVSG_API bool setSkinningProcessor( SkinningProcessorType type );
00154
00156   NVSG_API SkinningProcessor * getSkinningProcessor();
00157
00159
00165   NVSG_API void setSkinningProcessor( SkinningProcessor * a );
00166
00171   NVSG_API void forceTraversal();
00172
00174
00175 private:
00176
00177   // Some data to cache so we can decide if we really have to apply the animation data.
00178   // This does not help to prevent from unneeded traversal steps since we can't
00179   // decide for derived classes.
00180   nvsg::ViewStateHandle     * m_pLastViewState;
00181   nvsg::NodeHandle          * m_pLastRoot;
00182   unsigned int                m_animationTick;
00183   int                         m_animationDelta;
00184   unsigned int                m_lastAnimationTick;
00185   int                         m_lastAnimationDelta;
00186   bool                        m_bApplyAnimationKey;
00187   std::stack<nvmath::Vec3f>   m_currentScaling;
00188   SkinningProcessor         * m_skinningProcessor;
00189   bool                        m_forcedTraversal;
00190
00191   nvsg::Transform           * m_currentTransform;
00192 };
00193
00194 inline void AppTraverser::forceTraversal()
00195 {
00196   m_forcedTraversal = true;
00197 }
00198
00199 } // namespace nvtraverser
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


BalanceTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvtraverser/ModelViewTraverser.h"

Include dependency graph for BalanceTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:32 2008 for NVSGSDK by NVIDIA


BalanceTraverser.h Source File

BalanceTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"                     // common used stuff
00016 #include "nvtraverser/ModelViewTraverser.h" // base class definition
00017
00018 namespace nvtraverser
00019 {
00032   class BalanceTraverser : public ExclusiveModelViewTraverser
00033   {
00034     public:
00035       enum
00036       {
00037         BT_CHILDREN         = BIT0,
00038         BT_VERTICES         = BIT1,
00039         BT_ALL_TARGETS_MASK = ( BT_CHILDREN | BT_VERTICES )
00040       };
00041
00042     public:
00044       NVSG_API BalanceTraverser( void );
00045
00048       NVSG_API unsigned int getBalanceTargets() const;
00049
00052       NVSG_API void setBalanceTargets( unsigned int mask );
00053
00056       NVSG_API unsigned int getMaximalNumberOfChildren() const;
00057
00060       NVSG_API void setMaximalNumberOfChildren( unsigned int mnoc );
00061
00064       NVSG_API unsigned int getMaximalNumberOfVertices() const;
00065
00068       NVSG_API void setMaximalNumberOfVertices(unsigned int mnov );
00069
00070     protected:
00072       NVSG_API virtual ~BalanceTraverser( void );
00073
00075       NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransform * p );
00076
00078       NVSG_API virtual void handleBillboard( nvsg::Billboard * p );
00079
00081       NVSG_API virtual void handleFlipbookAnimation( nvsg::FlipbookAnimation * p );
00082
00084       NVSG_API virtual void handleGeoNode( nvsg::GeoNode * p );
00085
00087       NVSG_API virtual void handleGroup( nvsg::Group * p );
00088
00090       NVSG_API virtual void handleLines( nvsg::Lines * p );
00091
00093       NVSG_API virtual void handleLineStrips( nvsg::LineStrips * p );
00094
00096       NVSG_API virtual void handleLOD( nvsg::LOD * p );
00097
00099       NVSG_API virtual void handlePoints( nvsg::Points * p );
00100
00102       NVSG_API virtual void handleQuadMeshes( nvsg::QuadMeshes * p );
00103
00105       NVSG_API virtual void handleQuadStrips( nvsg::QuadStrips * p );
00106
00108       NVSG_API virtual void handleQuads( nvsg::Quads *p );
00109
00111       NVSG_API virtual void handleSwitch( nvsg::Switch * p );
00112
00114       NVSG_API virtual void handleTransform( nvsg::Transform * p );
00115
00117       NVSG_API virtual void handleTriangles( nvsg::Triangles * p );
00118
00120       NVSG_API virtual void handleTriFans( nvsg::TriFans * p );
00121
00123       NVSG_API virtual void handleTriStrips( nvsg::TriStrips * p );
00124
00125     private:
00126       void balanceGroup( nvsg::Group * p );
00127       template<typename T, typename TH>
00128         void balanceIndependentPrimitiveSet( T * p, unsigned int indicesPerPrimitive
00129                                            , std::vector<nvsg::PrimitiveSetHandle*> & replacements );
00130       template<typename T, typename TH>
00131         void balanceMeshedPrimitiveSet( T * p, std::vector<nvsg::PrimitiveSetHandle*> & replacements );
00132       template<typename T, typename TH>
00133         void balanceStrippedPrimitiveSet( T * p, std::vector<nvsg::PrimitiveSetHandle*> & replacements );
00134       void cutMesh( const nvsg::IndexMesh & mesh, std::vector<nvsg::IndexMesh> & newMeshes );
00135       void cutStrip( const nvsg::LineStrips * p, const nvsg::IndexSet & strip
00136                    , std::vector<nvsg::IndexSet> & newStrips );
00137       void cutStrip( const nvsg::QuadStrips * p, const nvsg::IndexSet & strip
00138                    , std::vector<nvsg::IndexSet> & newStrips );
00139       void cutStrip( const nvsg::TriFans * p, const nvsg::IndexSet & strip
00140                    , std::vector<nvsg::IndexSet> & newStrips );
00141       void cutStrip( const nvsg::TriStrips * p, const nvsg::IndexSet & strip
00142                    , std::vector<nvsg::IndexSet> & newStrips );
00143       void getSubMesh( const nvsg::IndexMesh & mesh, unsigned int x, unsigned int y
00144                      , unsigned int w, unsigned int h, std::vector<nvsg::IndexMesh> & newMeshes );
00145       template<typename StripType>
00146         void getSubStrip( StripType * p, const nvsg::IndexSet & strip, unsigned int x
00147                         , unsigned int w, std::vector<nvsg::IndexSet> & newStrips );
00148
00149     private:
00150       unsigned int  m_balanceTargets;
00151       unsigned int  m_maximalNumberOfChildren;
00152       unsigned int  m_maximalNumberOfVertices;
00153
00154       std::map<nvsg::PrimitiveSetHandle*,std::vector<nvsg::PrimitiveSetHandle*> > m_replacementMap;
00155   };
00156
00157   inline unsigned int BalanceTraverser::getBalanceTargets() const
00158   {
00159     return( m_balanceTargets );
00160   }
00161
00162   inline void BalanceTraverser::setBalanceTargets( unsigned int mask )
00163   {
00164     m_balanceTargets = mask;
00165   }
00166
00167   inline unsigned int BalanceTraverser::getMaximalNumberOfChildren() const
00168   {
00169     return( m_maximalNumberOfChildren );
00170   }
00171
00172   inline void BalanceTraverser::setMaximalNumberOfChildren( unsigned int mnoc )
00173   {
00174     m_maximalNumberOfChildren = mnoc;
00175   }
00176
00177   inline unsigned int BalanceTraverser::getMaximalNumberOfVertices() const
00178   {
00179     return( m_maximalNumberOfVertices );
00180   }
00181
00182   inline void BalanceTraverser::setMaximalNumberOfVertices( unsigned int mnov )
00183   {
00184     m_maximalNumberOfVertices = mnov;
00185   }
00186 }
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


Billboard.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Trafo.h"
#include "nvsg/Group.h"

Include dependency graph for Billboard.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:32 2008 for NVSGSDK by NVIDIA


Billboard.h Source File

Billboard.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Trafo.h"
00017 #include "nvsg/Group.h"
00018
00019 namespace nvsg
00020 {
00027   class Billboard : public Group
00028   {
00029     public:
00031       enum Alignment
00032       {
00033         BA_AXIS,
00034         BA_VIEWER,
00035         BA_SCREEN
00036       };
00037
00038     public:
00042       NVSG_API Billboard();
00043
00048       NVSG_API explicit Billboard( const Group &rhs );
00049
00052       NVSG_API Billboard( const Billboard &rhs );
00053
00055       NVSG_API virtual ~Billboard();
00056
00063       NVSG_API nvmath::Trafo getTrafo( const Camera & cam, const nvmath::Mat44f & worldToModel ) const;
00064
00068       NVSG_API Alignment getAlignment() const;
00069
00073       NVSG_API void setAlignment( Alignment ba );
00074
00082       NVSG_API const nvmath::Vec3f & getRotationAxis() const;
00083
00091       NVSG_API void setRotationAxis( const nvmath::Vec3f &axis );
00092
00099       NVSG_API Billboard & operator=( const Billboard & rhs );
00100
00111       NVSG_API virtual bool isEquivalent( const Object *p
00112                                         , bool ignoreNames
00113                                         , bool deepCompare ) const;
00114
00115     private:
00116       void getTrafoAxisAligned( const Camera & camera, const nvmath::Mat44f & worldToModel, nvmath::Trafo & trafo ) const;
00117       void getTrafoScreenAligned( const Camera & camera, const nvmath::Mat44f & worldToModel, nvmath::Trafo & trafo ) const;
00118       void getTrafoViewerAligned( const Camera & camera, const nvmath::Mat44f & worldToModel, nvmath::Trafo & trafo ) const;
00119
00120     private:
00121       Alignment     m_alignment;
00122       nvmath::Vec3f m_rotationAxis;
00123       bool          m_viewerAligned;
00124   };
00125
00126   inline const nvmath::Vec3f & Billboard::getRotationAxis() const
00127   {
00128     NVSG_TRACE();
00129     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00130     return( m_rotationAxis );
00131   }
00132
00133   inline Billboard::Alignment Billboard::getAlignment() const
00134   {
00135     NVSG_TRACE();
00136     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00137     return( m_alignment );
00138   }
00139
00140   inline void Billboard::setRotationAxis( const nvmath::Vec3f &rotationAxis )
00141   {
00142     NVSG_TRACE();
00143     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00144     if ( m_rotationAxis != rotationAxis )
00145     {
00146       m_rotationAxis = rotationAxis;
00147       invalidateIncarnation();
00148     }
00149   }
00150
00151   inline void Billboard::setAlignment( Alignment ba )
00152   {
00153     NVSG_TRACE();
00154     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00155     if ( m_alignment != ba )
00156     {
00157       m_alignment = ba;
00158       invalidateIncarnation();
00159     }
00160   }
00161 }
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


BitMask.h File Reference

#include "nvsgcommon.h"

Include dependency graph for BitMask.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:27:33 2008 for NVSGSDK by NVIDIA


BitMask.h Source File

BitMask.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 namespace nvutil
00018 {
00019
00020   inline unsigned int bit( unsigned int index, size_t value )
00021   {
00022     NVSG_ASSERT( index < 8*sizeof(size_t) );
00023     return( !!( value & ( (size_t)1 << index ) ) );
00024   }
00025
00026 typedef unsigned long bitset32;
00027 typedef unsigned long long bitset64;
00028
00030 template <int n>
00031 class Bit
00032 {
00033 public:
00034   enum { mask = 1<<n };
00035 };
00036
00037 //  Don't need to document these tiny little helper defines !!!
00038 #if ! defined( DOXYGEN_IGNORE )
00039
00040 #define BIT(n) nvutil::Bit<n>::mask
00041 #define BIT64(n) ((nvutil::bitset64)nvutil::Bit<0>::mask << (n))
00042
00043 #define BIT0  BIT(0)
00044 #define BIT1  BIT(1)
00045 #define BIT2  BIT(2)
00046 #define BIT3  BIT(3)
00047 #define BIT4  BIT(4)
00048 #define BIT5  BIT(5)
00049 #define BIT6  BIT(6)
00050 #define BIT7  BIT(7)
00051 #define BIT8  BIT(8)
00052 #define BIT9  BIT(9)
00053 #define BIT10 BIT(10)
00054 #define BIT11 BIT(11)
00055 #define BIT12 BIT(12)
00056 #define BIT13 BIT(13)
00057 #define BIT14 BIT(14)
00058 #define BIT15 BIT(15)
00059 #define BIT16 BIT(16)
00060 #define BIT17 BIT(17)
00061 #define BIT18 BIT(18)
00062 #define BIT19 BIT(19)
00063 #define BIT20 BIT(20)
00064 #define BIT21 BIT(21)
00065 #define BIT22 BIT(22)
00066 #define BIT23 BIT(23)
00067 #define BIT24 BIT(24)
00068 #define BIT25 BIT(25)
00069 #define BIT26 BIT(26)
00070 #define BIT27 BIT(27)
00071 #define BIT28 BIT(28)
00072 #define BIT29 BIT(29)
00073 #define BIT30 BIT(30)
00074 #define BIT31 BIT(31)
00075
00076 #define BIT32 BIT64(32)
00077 #define BIT33 BIT64(33)
00078 #define BIT34 BIT64(34)
00079 #define BIT35 BIT64(35)
00080 #define BIT36 BIT64(36)
00081 #define BIT37 BIT64(37)
00082 #define BIT38 BIT64(38)
00083 #define BIT39 BIT64(39)
00084 #define BIT40 BIT64(40)
00085 #define BIT41 BIT64(41)
00086 #define BIT42 BIT64(42)
00087 #define BIT43 BIT64(43)
00088 #define BIT44 BIT64(44)
00089 #define BIT45 BIT64(45)
00090 #define BIT46 BIT64(46)
00091 #define BIT47 BIT64(47)
00092 #define BIT48 BIT64(48)
00093 #define BIT49 BIT64(49)
00094 #define BIT50 BIT64(50)
00095 #define BIT51 BIT64(51)
00096 #define BIT52 BIT64(52)
00097 #define BIT53 BIT64(53)
00098 #define BIT54 BIT64(54)
00099 #define BIT55 BIT64(55)
00100 #define BIT56 BIT64(56)
00101 #define BIT57 BIT64(57)
00102 #define BIT58 BIT64(58)
00103 #define BIT59 BIT64(59)
00104 #define BIT60 BIT64(60)
00105 #define BIT61 BIT64(61)
00106 #define BIT62 BIT64(62)
00107 #define BIT63 BIT64(63)
00108
00109 #endif  //  DOXYGEN_IGNORE
00110
00111 } // namespace nvutil
00112
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


BlendAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/StateAttribute.h"

Include dependency graph for BlendAttribute.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:33 2008 for NVSGSDK by NVIDIA


BlendAttribute.h Source File

BlendAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/StateAttribute.h"
00017
00018
00019 namespace nvsg
00020 {
00027   typedef enum
00028   {
00029     BF_ZERO
00030   , BF_ONE
00031   , BF_DESTINATION_COLOR
00032   , BF_SOURCE_COLOR
00033   , BF_ONE_MINUS_DESTINATION_COLOR
00034   , BF_ONE_MINUS_SOURCE_COLOR
00035   , BF_SOURCE_ALPHA
00036   , BF_ONE_MINUS_SOURCE_ALPHA
00037   , BF_DESTINATION_ALPHA
00038   , BF_ONE_MINUS_DESTINATION_ALPHA
00039   , BF_SOURCE_ALPHA_SATURATE
00040   } BlendFunction;
00041
00049   class BlendAttribute : public StateAttribute
00050   {
00051     public:
00055       NVSG_API BlendAttribute();
00056
00061       NVSG_API explicit BlendAttribute( const StateAttribute &rhs );
00062
00065       NVSG_API BlendAttribute( const BlendAttribute &rhs );
00066
00068       NVSG_API virtual ~BlendAttribute();
00069
00078       NVSG_API void setBlendFunctions( BlendFunction sourceFunction
00079                                      , BlendFunction destinationFunction
00080                                      );
00081
00085       NVSG_API BlendFunction getSourceFunction() const;
00086
00090       NVSG_API BlendFunction getDestinationFunction() const;
00091
00099       NVSG_API virtual bool isTransparent() const;
00100
00110       NVSG_API virtual bool isEquivalent( const Object *p
00111                                         , bool ignoreNames
00112                                         , bool deepCompare ) const;
00113
00120       NVSG_API BlendAttribute & operator=(const BlendAttribute & rhs);
00121
00122     private:
00123       BlendFunction  m_sourceFunction;
00124       BlendFunction  m_destinationFunction;
00125   };
00126
00127   inline BlendFunction BlendAttribute::getSourceFunction() const
00128   {
00129     return( m_sourceFunction );
00130   }
00131
00132   inline BlendFunction BlendAttribute::getDestinationFunction() const
00133   {
00134     return( m_destinationFunction );
00135   }
00136
00137 } // namespace nvsg
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


Boxnt.h File Reference

#include "Vecnt.h"
#include <limits>

Include dependency graph for Boxnt.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvmath

Detailed Description

Generated on Tue Jan 15 10:27:33 2008 for NVSGSDK by NVIDIA


Boxnt.h Source File

Boxnt.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "Vecnt.h"
00016 #include <limits>
00017
00018 namespace nvmath
00019 {
00026   template<unsigned int n, typename T>
00027   class Boxnt
00028   {
00029   public:
00032     Boxnt();
00033
00037     Boxnt(const Boxnt& rhs);
00038
00042     Boxnt(const Vecnt<n,T>& p0, const Vecnt<n,T>& p1);
00043
00046     const Vecnt<n,T>& getLower() const;
00047
00050     const Vecnt<n,T>& getUpper() const;
00051
00056     void update(const Vecnt<n,T>& point);
00057
00058   private:
00059
00060     void init(); // initially empties the box
00061
00062     Vecnt<n,T>    m_lower; // lower edge of the box
00063     Vecnt<n,T>    m_upper; // upper edge of the box
00064   };
00065
00066   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00067   // non-member functions
00068   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00073   template<unsigned int n, typename T>
00074   Boxnt<n,T> boundingBox(const Vecnt<n,T> * points, unsigned int numberOfPoints);
00075
00082   template<unsigned int n, typename T>
00083   Boxnt<n,T> boundingBox(const Vecnt<n,T> * points, const unsigned int * indices,
00084                          unsigned int numberOfIndices);
00085
00090   template<unsigned int n, typename T>
00091   Boxnt<n,T> boundingBox(const Boxnt<n, T>& b0, const Boxnt<n, T>& b1);
00092
00098   template<unsigned int n, typename T>
00099   bool isEmpty(const Boxnt<n, T>& bbox);
00100
00105   template<unsigned int n, typename T>
00106   bool operator==(const Boxnt<n,T>& lhs, const Boxnt<n,T>& rhs);
00107
00112   template<unsigned int n, typename T>
00113   bool operator!=(const Boxnt<n,T>& lhs, const Boxnt<n,T>& rhs);
00114
00115   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00116   // Convenience type definitions
00117   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00118   typedef Boxnt<3,float>      Box3f;
00119   typedef Boxnt<3,double>     Box3d;
00120
00121   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00122   // Implementation
00123   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00124   template<unsigned int n, typename T>
00125   inline Boxnt<n,T>::Boxnt()
00126   {
00127     init();
00128   }
00129
00130   template<unsigned int n, typename T>
00131   inline Boxnt<n,T>::Boxnt(const Boxnt<n,T>& rhs)
00132   : m_lower(rhs.m_lower)
00133   , m_upper(rhs.m_upper)
00134   {
00135   }
00136
00137   template<unsigned int n, typename T>
00138   inline Boxnt<n,T>::Boxnt(const Vecnt<n,T>& p0, const Vecnt<n,T>& p1)
00139   {
00140     init(); // empty
00141     update(p0);
00142     update(p1);
00143   }
00144
00145   template<unsigned int n, typename T>
00146   inline void Boxnt<n,T>::init()
00147   {
00148     for ( unsigned int i=0; i<n; ++i )
00149     {
00150       m_lower[i] = std::numeric_limits<T>::max();
00151       m_upper[i] = -std::numeric_limits<T>::max();
00152     }
00153   }
00154
00155   template<unsigned int n, typename T>
00156   inline void Boxnt<n,T>::update(const Vecnt<n,T>& point)
00157   {
00158     for ( unsigned int i=0; i<n; ++i )
00159     {
00160       if ( m_lower[i] > point[i] )
00161       {
00162         m_lower[i] = point[i];
00163       }
00164       else if ( m_upper[i] < point[i] )
00165       {
00166         m_upper[i] = point[i];
00167       }
00168     }
00169   }
00170
00171   template<unsigned int n, typename T>
00172   inline const Vecnt<n,T>& Boxnt<n,T>::getLower() const
00173   {
00174     return m_lower;
00175   }
00176
00177   template<unsigned int n, typename T>
00178   inline const Vecnt<n,T>& Boxnt<n,T>::getUpper() const
00179   {
00180     return m_upper;
00181   }
00182
00183   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00184   // inlined non-member functions
00185   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00186   template<unsigned int n, typename T>
00187   inline Boxnt<n,T> boundingBox(const Vecnt<n,T> * points, unsigned int numberOfPoints)
00188   {
00189     NVSG_ASSERT(numberOfPoints>1); // requires at least two points
00190     Boxnt<n,T> bbox(points[0], points[0]); // initialize with first point
00191     for ( unsigned int i=1; i<numberOfPoints; ++i )
00192     {
00193       bbox.update(points[i]);
00194     }
00195     return bbox;
00196   }
00197
00198   template<unsigned int n, typename T>
00199   inline Boxnt<n,T> boundingBox(const Vecnt<n,T> * points, const unsigned int * indices,
00200                                 unsigned int numberOfIndices)
00201   {
00202     NVSG_ASSERT(numberOfIndices>1); // requires at least two points
00203     Boxnt<n,T> bbox(points[indices[0]], points[indices[0]]); // initialize with first point
00204     for ( unsigned int i=1; i<numberOfIndices; ++i )
00205     {
00206       bbox.update(points[indices[i]]);
00207     }
00208     return bbox;
00209   }
00210
00211   template<unsigned int n, typename T>
00212   inline Boxnt<n,T> boundingBox(const Vecnt<n,T> * points, const std::vector<unsigned int> * strips,
00213                                 unsigned int numberOfStrips)
00214   {
00215     NVSG_ASSERT(numberOfStrips>0); // requires at least one strip
00216     NVSG_ASSERT(strips[0].size()>1); // requires at least two points
00217     Boxnt<n,T> bbox(points[strips[0][0]], points[strips[0][0]]); // initialize with first point
00218     for( unsigned int i=0; i<numberOfStrips; ++i )
00219     {
00220       // neglect re-processing of first point -> start with j=0
00221       for ( size_t j=0; j<strips[i].size(); ++j )
00222       {
00223         bbox.update(points[strips[i][j]]);
00224       }
00225     }
00226     return bbox;
00227   }
00228
00229   template<unsigned int n, typename T>
00230   inline Boxnt<n,T> boundingBox(const Boxnt<n, T>& b0, const Boxnt<n, T>& b1)
00231   {
00232     if ( isEmpty(b0) )
00233     {
00234       // take b1 if b0 is empty
00235       return Boxnt<n,T>(b1);
00236     }
00237
00238     if ( isEmpty(b1) )
00239     {
00240       // take b0 if b1 is empty
00241       return Boxnt<n,T>(b0);
00242     }
00243
00244     // take union of both boxes
00245     Boxnt<n,T> bbox(b0);
00246     bbox.update(b1.getLower());
00247     bbox.update(b1.getUpper());
00248     return bbox;
00249   }
00250
00251   template<unsigned int n, typename T>
00252   inline bool isEmpty(const Boxnt<n, T>& bbox)
00253   {
00254     // A bounding box is considered empty, if for at least one direction
00255     // in space, the lower edge is greater than the upper edge.
00256
00257     for ( unsigned int i=0; i<n; ++i )
00258     {
00259       if ( bbox.getLower()[i] > bbox.getUpper()[i] )
00260       {
00261         // detected empty
00262         return true;
00263       }
00264     }
00265     // not empty if we get here
00266     return false;
00267   }
00268
00269   template<unsigned int n, typename T>
00270   inline bool operator==(const Boxnt<n,T>& lhs, const Boxnt<n,T>& rhs)
00271   {
00272     return lhs.getLower()==rhs.getLower() && lhs.getUpper()==rhs.getUpper();
00273   }
00274
00275   template<unsigned int n, typename T>
00276   inline bool operator!=(const Boxnt<n,T>& lhs, const Boxnt<n,T>& rhs)
00277   {
00278     return !(lhs==rhs);
00279   }
00280 } // namespace nvmath
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


Camera.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Matnnt.h"
#include "nvmath/Quatt.h"
#include "nvmath/Spherent.h"
#include "nvsg/Object.h"
#include "nvsg/CullData.h"

Include dependency graph for Camera.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:34 2008 for NVSGSDK by NVIDIA


Camera.h Source File

Camera.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Matnnt.h"
00017 #include "nvmath/Quatt.h"
00018 #include "nvmath/Spherent.h"
00019 #include "nvsg/Object.h" // base class definition
00020 #include "nvsg/CullData.h"
00021
00022 //  forward declarations
00023 namespace nvsg
00024 {
00041   class Camera : public Object
00042   {
00043     public:
00045       NVSG_API virtual ~Camera( void );
00046
00052       NVSG_API const nvmath::Vec3f & getPosition( void ) const;
00053
00060       NVSG_API void setPosition( const nvmath::Vec3f & pos );
00061
00068       NVSG_API const nvmath::Quatf & getOrientation( void ) const;
00069
00078       NVSG_API void setOrientation( const nvmath::Quatf & quat );
00079
00087       NVSG_API void setOrientation( const nvmath::Vec3f & dir
00088                                   , const nvmath::Vec3f & up );
00089
00095       NVSG_API nvmath::Vec3f getDirection( void ) const;
00096
00104       NVSG_API void setDirection( const nvmath::Vec3f & dir );
00105
00111       NVSG_API nvmath::Vec3f getUpVector( void ) const;
00112
00120       NVSG_API void setUpVector( const nvmath::Vec3f & up );
00121
00127       NVSG_API nvmath::Mat44f getWorldToViewMatrix( void ) const;
00128
00134       NVSG_API nvmath::Mat44f getViewToWorldMatrix( void ) const;
00135
00144       NVSG_API float getNearDistance( void ) const;
00145
00154       NVSG_API void setNearDistance( float nd );
00155
00162       NVSG_API float getFocusDistance( void ) const;
00163
00171       NVSG_API virtual void setFocusDistance( float fd );
00172
00181       NVSG_API float getFarDistance( void ) const;
00182
00191       NVSG_API void setFarDistance( float fd );
00192
00208       NVSG_API void calcNearFarDistances( const nvmath::Sphere3f &sphere );
00209
00217       NVSG_API bool isAutoClipPlanes( void ) const;
00218
00226       NVSG_API void setAutoClipPlanes( bool on );
00227
00231       NVSG_API virtual nvmath::Mat44f getProjection( void ) const = 0;
00232
00236       NVSG_API virtual nvmath::Mat44f getInverseProjection( void ) const = 0;
00237
00246       NVSG_API const nvmath::Vec2f & getWindowSize( void ) const;
00247
00256       NVSG_API void setWindowSize( const nvmath::Vec2f & size );
00257
00262       NVSG_API float getAspectRatio( void ) const;
00263
00273       NVSG_API void setAspectRatio( float ar
00274                                   , bool keepWidth = false );
00275
00289       NVSG_API const nvmath::Vec2f & getWindowOffset( void ) const;
00290
00304       NVSG_API void setWindowOffset( const nvmath::Vec2f &offset );
00305
00319       NVSG_API void getWindowRegion( nvmath::Vec2f & lowerLeft
00320                                    , nvmath::Vec2f & upperRight ) const;
00321
00335       NVSG_API void setWindowRegion( const nvmath::Vec2f & lowerLeft
00336                                    , const nvmath::Vec2f & upperRight );
00337
00343       NVSG_API unsigned int getNumberOfHeadLights( void ) const;
00344
00353       NVSG_API LightSourceHandle * getHeadLight( unsigned int index ) const;
00354
00364       NVSG_API void addHeadLight( LightSourceHandle * light );
00365
00375       NVSG_API void removeHeadLight( unsigned int index );
00376
00384       NVSG_API void clearHeadLights( void );
00385
00398       NVSG_API virtual void getPickRay( int x
00399                                       , int y
00400                                       , int w
00401                                       , int h
00402                                       , nvmath::Vec3f & rayOrigin
00403                                       , nvmath::Vec3f & rayDir ) const = 0;
00404
00414       NVSG_API void move( const nvmath::Vec3f & delta
00415                         , bool cameraRelative = true );
00416
00432       NVSG_API void orbit( const nvmath::Vec3f & axis
00433                          , float targetDistance
00434                          , float angle
00435                          , bool  cameraRelative = true );
00436
00447       NVSG_API void rotate( const nvmath::Vec3f& axis
00448                           , float angle
00449                           , bool  cameraRelative = true );
00450
00461       NVSG_API void zoom( float factor );
00462
00473       NVSG_API void zoom( const nvmath::Sphere3f & sphere
00474                         , float fovy = -1.0f );
00475
00481       void moveX( float val );
00482
00488       void moveY( float val );
00489
00495       void moveZ( float val );
00496
00503       void orbitX( float targetDistance
00504                  , float angle );
00505
00512       void orbitY( float targetDistance
00513                  , float angle );
00514
00522       void orbitZ( float targetDistance
00523                  , float angle );
00524
00530       void rotateX( float angle );
00531
00537       void rotateY( float angle );
00538
00544       void rotateZ( float angle );
00545
00551       NVSG_API virtual CullCode determineCullCode( const nvmath::Sphere3f &sphere ) const = 0;
00552
00558       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00559
00560     protected:
00565       NVSG_API Camera( void );
00566
00572       NVSG_API Camera( const Camera& rhs );
00573
00580       NVSG_API Camera & operator=( const Camera & rhs );
00581
00582     private:
00583       void copyHeadLights(const Camera& rhs);
00584       void removeHeadLights();
00585
00586     private:
00587       typedef std::vector<LightSourceHandle *>::const_iterator ConstHeadlightIterator;
00588       typedef std::vector<LightSourceHandle *>::iterator HeadlightIterator;
00589       std::vector<LightSourceHandle *>  m_headLights;
00590
00591       nvmath::Quatf m_orientation;
00592       nvmath::Vec3f m_position;
00593
00594       bool          m_isAutoClipPlanes;
00595       float         m_nearDist;
00596       float         m_focusDist;
00597       float         m_farDist;
00598
00599       nvmath::Vec2f m_windowSize;
00600       nvmath::Vec2f m_windowOffset;
00601       nvmath::Vec2f m_lowerLeft;
00602       nvmath::Vec2f m_upperRight;
00603
00604       mutable nvmath::Mat44f  m_viewToWorld;
00605       mutable bool            m_viewToWorldValid;
00606       mutable nvmath::Mat44f  m_worldToView;
00607       mutable bool            m_worldToViewValid;
00608   };
00609
00610   inline float Camera::getAspectRatio( void ) const
00611   {
00612     NVSG_TRACE();
00613     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00614     return( m_windowSize[0] / m_windowSize[1] );
00615   }
00616
00617   inline nvmath::Vec3f Camera::getDirection( void ) const
00618   {
00619     NVSG_TRACE();
00620     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00621     //  NOTE: normalizing shouldn't be necessary, but rounding errors do catch us!
00622     nvmath::Vec3f dir = nvmath::Vec3f( 0.0f, 0.0f, -1.0f ) * m_orientation;
00623     dir.normalize();
00624     return( dir );
00625   }
00626
00627   inline float Camera::getFarDistance( void ) const
00628   {
00629     NVSG_TRACE();
00630     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00631     NVSG_ASSERT( m_nearDist < m_farDist );
00632     return( m_farDist );
00633   }
00634
00635   inline float Camera::getFocusDistance( void ) const
00636   {
00637     NVSG_TRACE();
00638     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00639     return( m_focusDist );
00640   }
00641
00642   inline LightSourceHandle * Camera::getHeadLight( unsigned int index ) const
00643   {
00644     NVSG_TRACE();
00645     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00646     NVSG_ASSERT( index < m_headLights.size() );
00647     return m_headLights[index];
00648   }
00649
00650   inline float Camera::getNearDistance( void ) const
00651   {
00652     NVSG_TRACE();
00653     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00654     NVSG_ASSERT( m_nearDist < m_farDist );
00655     return( m_nearDist );
00656   }
00657
00658   inline unsigned int Camera::getNumberOfHeadLights( void ) const
00659   {
00660     NVSG_TRACE();
00661     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00662     NVSG_ASSERT( m_headLights.size() <= UINT_MAX );
00663     return( static_cast<unsigned int>(m_headLights.size()) );
00664   }
00665
00666   inline const nvmath::Quatf & Camera::getOrientation( void ) const
00667   {
00668     NVSG_TRACE();
00669     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00670     return( m_orientation );
00671   }
00672
00673   inline const nvmath::Vec3f & Camera::getPosition( void ) const
00674   {
00675     NVSG_TRACE();
00676     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00677     return( m_position );
00678   }
00679
00680   inline nvmath::Vec3f Camera::getUpVector( void ) const
00681   {
00682     NVSG_TRACE();
00683     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00684     NVSG_ASSERT( isNormalized( m_orientation ) );
00685     //  NOTE: normalizing shouldn't be necessary, but rounding errors do catch us!
00686     nvmath::Vec3f up = nvmath::Vec3f( 0.0f, 1.0f, 0.0f ) * m_orientation;
00687     up.normalize();
00688     return( up );
00689   }
00690
00691   inline const nvmath::Vec2f & Camera::getWindowOffset( void ) const
00692   {
00693     NVSG_TRACE();
00694     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00695     return m_windowOffset;
00696   }
00697
00698   inline void Camera::getWindowRegion( nvmath::Vec2f & lowerLeft, nvmath::Vec2f & upperRight ) const
00699   {
00700     NVSG_TRACE();
00701     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00702     lowerLeft = m_lowerLeft;
00703     upperRight = m_upperRight;
00704   }
00705
00706   inline const nvmath::Vec2f & Camera::getWindowSize( void ) const
00707   {
00708     NVSG_TRACE();
00709     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00710     return( m_windowSize );
00711   }
00712
00713   inline bool Camera::isAutoClipPlanes( void ) const
00714   {
00715     NVSG_TRACE();
00716     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00717     return( m_isAutoClipPlanes );
00718   }
00719
00720   inline void Camera::setFarDistance( float fd )
00721   {
00722     NVSG_TRACE();
00723     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00724     NVSG_ASSERT( ( FLT_EPSILON < fd ) );
00725     if ( m_farDist != fd )
00726     {
00727       m_farDist = fd;
00728       invalidateIncarnation();
00729     }
00730   }
00731
00732   inline void Camera::setNearDistance( float nd )
00733   {
00734     NVSG_TRACE();
00735     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00736     NVSG_ASSERT( ( FLT_EPSILON <= nd ) );
00737     if ( m_nearDist != nd )
00738     {
00739       m_nearDist = nd;
00740       invalidateIncarnation();
00741     }
00742   }
00743
00744   inline void Camera::setWindowSize( const nvmath::Vec2f & size )
00745   {
00746     NVSG_TRACE();
00747     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00748     if ( m_windowSize != size )
00749     {
00750       m_windowSize = size;
00751       invalidateIncarnation();
00752     }
00753   }
00754
00755   inline void Camera::setWindowOffset( const nvmath::Vec2f & offset )
00756   {
00757     NVSG_TRACE();
00758     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00759     if ( m_windowOffset != offset )
00760     {
00761       m_windowOffset = offset;
00762       invalidateIncarnation();
00763     }
00764   }
00765
00766   inline void Camera::setWindowRegion( const nvmath::Vec2f & lowerLeft, const nvmath::Vec2f & upperRight )
00767   {
00768     NVSG_TRACE();
00769     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00770     if ( ( m_lowerLeft != lowerLeft ) || ( m_upperRight != upperRight ) )
00771     {
00772       m_lowerLeft  = lowerLeft;
00773       m_upperRight = upperRight;
00774       invalidateIncarnation();
00775     }
00776   }
00777
00778   inline void Camera::zoom( float factor )
00779   {
00780     NVSG_TRACE();
00781     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00782     NVSG_ASSERT( FLT_EPSILON < factor );
00783     if ( factor != 1.0f )
00784     {
00785       m_windowSize *= factor;
00786       invalidateIncarnation();
00787     }
00788   }
00789
00790   inline void Camera::moveX( float val )
00791   {
00792     NVSG_TRACE();
00793     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00794     move( nvmath::Vec3f( val, 0.f, 0.f ) );
00795   }
00796
00797   inline void Camera::moveY( float val )
00798   {
00799     NVSG_TRACE();
00800     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00801     move( nvmath::Vec3f( val, 1.f, 0.f ) );
00802   }
00803
00804   inline void  Camera::moveZ( float val )
00805   {
00806     NVSG_TRACE();
00807     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00808     move( nvmath::Vec3f( val, 0.f, 1.f ) );
00809   }
00810
00811   inline void  Camera::orbitX( float targetDistance, float rad )
00812   {
00813     NVSG_TRACE();
00814     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00815     orbit( nvmath::Vec3f( 1.f, 0.f, 0.f ), targetDistance, rad );
00816   }
00817
00818   inline void  Camera::orbitY( float targetDistance, float rad )
00819   {
00820     NVSG_TRACE();
00821     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00822     orbit( nvmath::Vec3f( 0.f, 1.f, 0.f ), targetDistance, rad );
00823   }
00824
00825   inline void  Camera::orbitZ( float targetDistance, float rad )
00826   {
00827     NVSG_TRACE();
00828     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00829     orbit( nvmath::Vec3f( 0.f, 0.f, 1.f ), targetDistance, rad );
00830   }
00831
00832   inline void  Camera::rotateX( float rad )
00833   {
00834     NVSG_TRACE();
00835     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00836     rotate( nvmath::Vec3f(1.f, 0.f, 0.f), rad );
00837   }
00838
00839   inline void  Camera::rotateY( float rad )
00840   {
00841     NVSG_TRACE();
00842     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00843     rotate( nvmath::Vec3f(0.f, 1.f, 0.f), rad );
00844   }
00845
00846   inline void  Camera::rotateZ( float rad )
00847   {
00848     NVSG_TRACE();
00849     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00850     rotate( nvmath::Vec3f(0.f, 0.f, 1.f), rad );
00851   }
00852
00853   template <typename T>
00854   inline T camera_cast(const Camera * camera)
00855   {
00856     NVSG_CTASSERT(!!(nvutil::Conversion<T,const Camera*>::exists));
00857     return dynamic_cast<T>(camera);
00858   }
00859
00860   template <typename T>
00861   inline T camera_cast(Camera * camera)
00862   {
00863     NVSG_CTASSERT(!!(nvutil::Conversion<T,Camera*>::exists));
00864     return dynamic_cast<T>(camera);
00865   }
00866 } // namespace
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


CgFx.h File Reference

#include "nvsgcommon.h"
#include "nvsg/StateAttribute.h"
#include "nvsg/TextureImage.h"
#include "nvsg/TextureAttribute.h"
#include "Cg/cg.h"
#include <vector>
#include <set>

Include dependency graph for CgFx.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:34 2008 for NVSGSDK by NVIDIA


CgFx.h Source File

CgFx.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2005-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsgcommon.h"
00015 #include "nvsg/StateAttribute.h"
00016 #include "nvsg/TextureImage.h"
00017 #include "nvsg/TextureAttribute.h"
00018 #include "Cg/cg.h"
00019
00020 #include <vector>
00021 #include <set>
00022
00023 namespace nvsg
00024 {
00025
00026 // forward declaration of internal types
00027 class CgFxEffectResource;
00028 struct CGIAnnotation;
00029 struct CGIParameter;
00030 struct CGITechnique;
00031 struct CGIPass;
00032 struct CGIProgram;
00033
00035 typedef CGIAnnotation * CgFxAnnotation;
00037 typedef CGIParameter  * CgFxParameter;
00039 typedef CGITechnique  * CgFxTechnique;
00041 typedef CGIPass       * CgFxPass;
00043 typedef CGIProgram    * CgFxProgram;
00044
00065 class CgFxContext
00066 {
00067   friend class CgFxEffect;
00068
00069 public:
00070
00073   enum CgFxStateMachineEnum
00074   {
00075     CGFX_STATE_MACHINE_INVALID = 0,
00076     CGFX_STATE_MACHINE_GL
00077   };
00078
00092   NVSG_API explicit CgFxContext(CgFxStateMachineEnum stateMachine = CGFX_STATE_MACHINE_INVALID);
00093
00098   NVSG_API ~CgFxContext();
00099
00112   NVSG_API void lock() { m_lock.lockExclusive(); }
00113
00120   NVSG_API void unlock() { m_lock.unlockExclusive(); }
00121
00127   NVSG_API operator CGcontext() const { return m_context; }
00128
00140   NVSG_API CgFxStateMachineEnum getStateMachine() const { return m_stateMachine; }
00141
00161   NVSG_API bool setStateMachine(CgFxStateMachineEnum stateMachine);
00162
00163 private:
00164   CgFxStateMachineEnum m_stateMachine; // indicates currently configured state machine
00165   CGcontext m_context; // shareable CGcontext
00166   nvutil::SWMRSync m_lock; // for exclusive locking purposes
00167 };
00168
00176  NVSG_API CgFxContext * cgfxContext();
00177
00178
00199 class CgFxEffect : public nvutil::HandledObject
00200 {
00201   friend class CgFx;
00202
00203 public:
00204
00214   enum TransformType
00215   {
00217     TRAFO_UNKNOWN = -1,
00218
00220     TRAFO_WORLD = 0,
00222     TRAFO_MODEL                             = TRAFO_WORLD,
00223
00225     TRAFO_VIEW,
00226
00228     TRAFO_PROJECTION,
00229
00231     TRAFO_WORLDT,
00233     TRAFO_MODELT                            = TRAFO_WORLDT,
00235     TRAFO_WORLDTRANSPOSE                    = TRAFO_WORLDT,
00237     TRAFO_MODELTRANSPOSE                    = TRAFO_WORLDT,
00238
00240     TRAFO_VIEWT,
00242     TRAFO_VIEWTRANSPOSE                     = TRAFO_VIEWT,
00243
00245     TRAFO_PROJECTIONT,
00247     TRAFO_PROJECTIONTRANSPOSE               = TRAFO_PROJECTIONT,
00248
00250     TRAFO_WORLDI,
00252     TRAFO_MODELI                            = TRAFO_WORLDI,
00254     TRAFO_WORLDINVERSE                      = TRAFO_WORLDI,
00256     TRAFO_MODELINVERSE                      = TRAFO_WORLDI,
00257
00259     TRAFO_VIEWI,
00261     TRAFO_VIEWINVERSE                        = TRAFO_VIEWI,
00262
00264     TRAFO_PROJECTIONI,
00266     TRAFO_PROJECTIONINVERSE                  = TRAFO_PROJECTIONI,
00267
00269     TRAFO_WORLDIT,
00271     TRAFO_MODELIT                            = TRAFO_WORLDIT,
00273     TRAFO_WORLDINVERSETRANSPOSE              = TRAFO_WORLDIT,
00275     TRAFO_MODELINVERSETRANSPOSE              = TRAFO_WORLDIT,
00276
00278     TRAFO_VIEWIT,
00280     TRAFO_VIEWINVERSETRANSPOSE               = TRAFO_VIEWIT,
00281
00283     TRAFO_PROJECTIONIT,
00285     TRAFO_PROJECTIONINVERSETRANSPOSE         = TRAFO_PROJECTIONIT,
00286
00288     TRAFO_WORLDVIEW,
00290     TRAFO_MODELVIEW                           = TRAFO_WORLDVIEW,
00291
00293     TRAFO_WORLDVIEWPROJECTION,
00295     TRAFO_MODELVIEWPROJECTION                 = TRAFO_WORLDVIEWPROJECTION,
00296
00298     TRAFO_WORLDVIEWT,
00300     TRAFO_MODELVIEWT                          = TRAFO_WORLDVIEWT,
00302     TRAFO_WORLDVIEWTRANSPOSE                  = TRAFO_WORLDVIEWT,
00304     TRAFO_MODELVIEWTRANSPOSE                  = TRAFO_WORLDVIEWT,
00305
00307     TRAFO_WORLDVIEWPROJECTIONT,
00309     TRAFO_MODELVIEWPROJECTIONT                = TRAFO_WORLDVIEWPROJECTIONT,
00311     TRAFO_WORLDVIEWPROJECTIONTRANSPOSE        = TRAFO_WORLDVIEWPROJECTIONT,
00313     TRAFO_MODELVIEWPROJECTIONTRANSPOSE        = TRAFO_WORLDVIEWPROJECTIONT,
00314
00316     TRAFO_WORLDVIEWI,
00318     TRAFO_MODELVIEWI                          = TRAFO_WORLDVIEWI,
00320     TRAFO_WORLDVIEWINVERSE                    = TRAFO_WORLDVIEWI,
00322     TRAFO_MODELVIEWINVERSE                    = TRAFO_WORLDVIEWI,
00323
00325     TRAFO_WORLDVIEWPROJECTIONI,
00327     TRAFO_MODELVIEWPROJECTIONI                = TRAFO_WORLDVIEWPROJECTIONI,
00329     TRAFO_WORLDVIEWPROJECTIONINVERSE          = TRAFO_WORLDVIEWPROJECTIONI,
00331     TRAFO_MODELVIEWPROJECTIONINVERSE          = TRAFO_WORLDVIEWPROJECTIONI,
00332
00334     TRAFO_WORLDVIEWIT,
00336     TRAFO_MODELVIEWIT                         = TRAFO_WORLDVIEWIT,
00338     TRAFO_WORLDVIEWINVERSETRANSPOSE           = TRAFO_WORLDVIEWIT,
00340     TRAFO_MODELVIEWINVERSETRANSPOSE           = TRAFO_WORLDVIEWIT,
00341
00343     TRAFO_WORLDVIEWPROJECTIONIT,
00345     TRAFO_MODELVIEWPROJECTIONIT               = TRAFO_WORLDVIEWPROJECTIONIT,
00347     TRAFO_WORLDVIEWPROJECTIONINVERSETRANSPOSE = TRAFO_WORLDVIEWPROJECTIONIT,
00349     TRAFO_MODELVIEWPROJECTIONINVERSETRANSPOSE = TRAFO_WORLDVIEWPROJECTIONIT
00350   };
00351
00357   enum ProgramIOType
00358   {
00360     PROGRAM_IO_VERTEX       = CG_VERTEX,
00362     PROGRAM_IO_FRAGMENT     = CG_FRAGMENT,
00364     PROGRAM_IO_POINT        = CG_POINT,
00366     PROGRAM_IO_LINE         = CG_LINE,
00368     PROGRAM_IO_LINE_ADJ     = CG_LINE_ADJ,
00370     PROGRAM_IO_TRIANGLE     = CG_TRIANGLE,
00372     PROGRAM_IO_TRIANGLE_ADJ = CG_TRIANGLE_ADJ,
00373   };
00374
00375 public:
00378   CgFxEffect();
00379
00383   CgFxEffect(const CgFxEffect& rhs);
00384
00387   ~CgFxEffect();
00388
00435   NVSG_API bool createFromFile(const std::string& file, std::string& err);
00436
00518   NVSG_API bool createFromLump(const std::string& lump, std::string& err);
00519
00534   NVSG_API bool isValid() const;
00535
00548   NVSG_API CGcontext getContext() const;
00549
00562   NVSG_API bool isFromFile() const;
00563
00576   NVSG_API bool isFromLump() const;
00577
00611   NVSG_API bool getFileName(std::string& file) const;
00612
00646   NVSG_API bool getSourceCode(std::string& code) const;
00647
00648   // API concerning annotation queries
00649
00679   NVSG_API unsigned int getNumberOfParameterAnnotations(CgFxParameter param) const;
00680
00722   NVSG_API CgFxAnnotation getParameterAnnotation(CgFxParameter param, unsigned int index) const;
00723
00767   NVSG_API CgFxAnnotation getParameterAnnotationByName(CgFxParameter param, const std::string& name) const;
00768
00795   NVSG_API unsigned int getNumberOfTechniqueAnnotations(CgFxTechnique tech) const;
00796
00835   NVSG_API CgFxAnnotation getTechniqueAnnotation(CgFxTechnique tech, unsigned int index) const;
00836
00877   NVSG_API CgFxAnnotation getTechniqueAnnotationByName(CgFxTechnique tech, const std::string& name) const;
00878
00904   NVSG_API unsigned int getNumberOfPassAnnotations(CgFxPass pass) const;
00905
00944   NVSG_API CgFxAnnotation getPassAnnotation(CgFxPass pass, unsigned int index) const;
00945
00986   NVSG_API CgFxAnnotation getPassAnnotationByName(CgFxPass pass, const std::string& name) const;
00987
01006   NVSG_API const std::string& getAnnotationName(CgFxAnnotation anno) const;
01007
01024   NVSG_API const std::string& getAnnotationTypeString(CgFxAnnotation anno) const;
01025
01073   NVSG_API bool isFloatAnnotation(CgFxAnnotation anno) const;
01074
01122   NVSG_API bool isIntAnnotation(CgFxAnnotation anno) const;
01123
01171   NVSG_API bool isBoolAnnotation(CgFxAnnotation anno) const;
01172
01208   NVSG_API bool isStringAnnotation(CgFxAnnotation anno) const;
01209
01229   NVSG_API unsigned int getAnnotationValueSize(CgFxAnnotation anno) const;
01230
01253   NVSG_API unsigned int getNumberOfAnnotationValueComponents(CgFxAnnotation anno) const;
01254
01282   NVSG_API bool getFloatAnnotationValue(CgFxAnnotation anno, float * value) const;
01283
01311   NVSG_API bool getIntAnnotationValue(CgFxAnnotation anno, int * value) const;
01312
01341   NVSG_API bool getBoolAnnotationValue(CgFxAnnotation anno, int * value) const;
01342
01362   NVSG_API bool getStringAnnotationValue(CgFxAnnotation anno, std::string& value) const;
01363
01377   NVSG_API const std::string& getParameterName(CgFxParameter param) const;
01378
01392   NVSG_API const std::string& getParameterSemantic(CgFxParameter param) const;
01393
01408   NVSG_API const std::string& getParameterTypeString(CgFxParameter param) const;
01409
01470   NVSG_API CgFxParameter getParameterByName(const std::string& name) const;
01471
01484   NVSG_API CgFxParameter getParameterBySemantic(const std::string& semantic) const;
01485
01499   NVSG_API unsigned int getNumberOfArrayParameterElements(CgFxParameter param) const;
01500
01519   NVSG_API CgFxParameter getArrayParameterElement(CgFxParameter param, unsigned int index) const;
01520
01535   NVSG_API unsigned int getNumberOfStructParameterMembers(CgFxParameter param) const;
01536
01559   NVSG_API CgFxParameter getStructParameterMember(CgFxParameter param, unsigned int index) const;
01560
01616   NVSG_API CgFxParameter getStructParameterMemberByName(CgFxParameter param, const std::string& member) const;
01617
01639   NVSG_API unsigned int getParameterValueSize(CgFxParameter param) const;
01640
01642
01658   NVSG_API unsigned int getNumberOfParameterValueComponents(CgFxParameter param) const;
01659
01671   NVSG_API bool isScalarParameter(CgFxParameter param) const;
01672
01684   NVSG_API bool isVector2Parameter(CgFxParameter param) const;
01685
01697   NVSG_API bool isVector3Parameter(CgFxParameter param) const;
01698
01710   NVSG_API bool isVector4Parameter(CgFxParameter param) const;
01711
01723   NVSG_API bool isMatrix22Parameter(CgFxParameter param) const;
01724
01736   NVSG_API bool isMatrix23Parameter(CgFxParameter param) const;
01737
01749   NVSG_API bool isMatrix24Parameter(CgFxParameter param) const;
01750
01762   NVSG_API bool isMatrix32Parameter(CgFxParameter param) const;
01763
01775   NVSG_API bool isMatrix33Parameter(CgFxParameter param) const;
01776
01788   NVSG_API bool isMatrix34Parameter(CgFxParameter param) const;
01789
01801   NVSG_API bool isMatrix42Parameter(CgFxParameter param) const;
01802
01814   NVSG_API bool isMatrix43Parameter(CgFxParameter param) const;
01815
01827   NVSG_API bool isMatrix44Parameter(CgFxParameter param) const;
01828
01840   NVSG_API bool isFloatParameter(CgFxParameter param) const;
01841
01853   NVSG_API bool isIntParameter(CgFxParameter param) const;
01854
01866   NVSG_API bool isBoolParameter(CgFxParameter param) const;
01867
01879   NVSG_API bool isStringParameter(CgFxParameter param) const;
01880
01895   NVSG_API bool isSamplerParameter(CgFxParameter param) const;
01896
01912   NVSG_API bool isSampler1DParameter(CgFxParameter param) const;
01913
01929   NVSG_API bool isSampler2DParameter(CgFxParameter param) const;
01930
01946   NVSG_API bool isSampler3DParameter(CgFxParameter param) const;
01947
01963   NVSG_API bool isSamplerRectParameter(CgFxParameter param) const;
01964
01979   NVSG_API bool isSamplerCubeParameter(CgFxParameter param) const;
01980
01993   NVSG_API bool isSamplerArrayParameter(CgFxParameter param) const;
01994
02012   NVSG_API bool isLightParameter(CgFxParameter param) const;
02013
02029   NVSG_API bool isLightArrayParameter(CgFxParameter param) const;
02030
02048   NVSG_API bool isMaterialParameter(CgFxParameter param) const;
02049
02068   NVSG_API bool isSceneParameter(CgFxParameter param) const;
02069
02173   NVSG_API bool isTransformParameter(CgFxParameter param) const;
02174
02183   NVSG_API bool isArrayParameter(CgFxParameter param) const;
02184
02194   NVSG_API bool isStructParameter(CgFxParameter param) const;
02195
02206   NVSG_API unsigned int getNumberOfTransforms() const;
02207
02209
02238   NVSG_API CgFxParameter getTransform(unsigned int index) const;
02239
02254   NVSG_API TransformType getTransformType(CgFxParameter param) const;
02255
02274   NVSG_API bool setTransformValue(CgFxParameter param, const float * value);
02275
02289   NVSG_API unsigned int getNumberOfTweakables() const;
02290
02303   NVSG_API CgFxParameter getTweakable(unsigned int index) const;
02304
02316   NVSG_API CgFxParameter getTweakableBySemantic(const std::string& semantic) const;
02317
02329   NVSG_API CgFxParameter getTweakableByName(const std::string& name) const;
02330
02339   NVSG_API unsigned int getNumberOfLights() const;
02340
02367   NVSG_API CgFxParameter getLight(unsigned int index) const;
02368
02381   NVSG_API CgFxParameter getLightBySemantic(const std::string& semantic) const;
02382
02395   NVSG_API CgFxParameter getLightByName(const std::string& name) const;
02396
02408   NVSG_API CgFxParameter getMaterial() const;
02409
02421   NVSG_API CgFxParameter getScene() const;
02422
02450   NVSG_API bool getParameterValueAsFloat(CgFxParameter param, float * value) const;
02451
02479   NVSG_API bool setParameterValueAsFloat(CgFxParameter param, const float * value);
02480
02507   NVSG_API bool getFloatParameterValue(CgFxParameter param, float * value) const;
02508
02533   NVSG_API bool setFloatParameterValue(CgFxParameter param, const float* value);
02534
02561   NVSG_API bool getIntParameterValue(CgFxParameter param, int * value) const;
02562
02587   NVSG_API bool setIntParameterValue(CgFxParameter param, const int* value);
02588
02616   NVSG_API bool getBoolParameterValue(CgFxParameter param, int * value) const;
02617
02643   NVSG_API bool setBoolParameterValue(CgFxParameter param, const int* value);
02644
02665   NVSG_API bool getStringParameterValue(CgFxParameter param, std::string& value) const;
02666
02684   NVSG_API bool setStringParameterValue(CgFxParameter param, const std::string& value);
02685
02694   NVSG_API void resetSceneValues(CgFxParameter param);
02695
02716   NVSG_API bool getSceneAmbientValue(CgFxParameter param, float * value) const;   // float4
02717
02734   NVSG_API bool setSceneAmbientValue(CgFxParameter param, const float * value);   // float4
02735
02757   NVSG_API bool getSceneFrameNumberValue(CgFxParameter param, int * value) const;
02758
02776   NVSG_API bool setSceneFrameNumberValue(CgFxParameter param, const int * value);
02777
02778
02787   NVSG_API void resetMaterialValues(CgFxParameter param);
02788
02807   NVSG_API bool getMaterialEmissionValue(CgFxParameter param, float * value) const;  // float4
02808
02823   NVSG_API bool setMaterialEmissionValue(CgFxParameter param, const float * value);  // float4
02824
02843   NVSG_API bool getMaterialAmbientValue(CgFxParameter param, float * value) const;   // float4
02844
02859   NVSG_API bool setMaterialAmbientValue(CgFxParameter param, const float * value);   // float4
02860
02879   NVSG_API bool getMaterialDiffuseValue(CgFxParameter param, float * value) const;   // float4
02880
02895   NVSG_API bool setMaterialDiffuseValue(CgFxParameter param, const float * value);   // float4
02896
02915   NVSG_API bool getMaterialSpecularValue(CgFxParameter param, float * value) const;  // float4
02916
02931   NVSG_API bool setMaterialSpecularValue(CgFxParameter param, const float * value);  // float4
02932
02949   NVSG_API bool getMaterialShininessValue(CgFxParameter param, float * value) const; // float
02950
02965   NVSG_API bool setMaterialShininessValue(CgFxParameter param, const float * value); // float
02966
02975   NVSG_API void resetLightValues(CgFxParameter param);
02976
02995   NVSG_API bool getLightAmbientValue(CgFxParameter param, float * value) const;
02996
03011   NVSG_API bool setLightAmbientValue(CgFxParameter param, const float * value);
03012
03031   NVSG_API bool getLightDiffuseValue(CgFxParameter param, float * value) const;
03032
03047   NVSG_API bool setLightDiffuseValue(CgFxParameter param, const float * value);
03048
03067   NVSG_API bool getLightSpecularValue(CgFxParameter param, float * value) const;
03068
03083   NVSG_API bool setLightSpecularValue(CgFxParameter param, const float * value);
03084
03103   NVSG_API bool getLightPositionValue(CgFxParameter param, float * value) const;
03104
03120   NVSG_API bool setLightPositionValue(CgFxParameter param, const float * value);
03121
03140   NVSG_API bool getLightDirectionValue(CgFxParameter param, float * value) const;
03141
03157   NVSG_API bool setLightDirectionValue(CgFxParameter param, const float * value);
03158
03177   NVSG_API bool getLightSpotExponentValue(CgFxParameter param, float * value) const;
03178
03193   NVSG_API bool setLightSpotExponentValue(CgFxParameter param, const float * value);
03194
03213   NVSG_API bool getLightSpotCutoffValue(CgFxParameter param, float * value) const;
03214
03229   NVSG_API bool setLightSpotCutoffValue(CgFxParameter param, const float * value);
03230
03249   NVSG_API bool getLightConstantAttenuationValue(CgFxParameter param, float * value) const;
03250
03265   NVSG_API bool setLightConstantAttenuationValue(CgFxParameter param, const float * value);
03266
03285   NVSG_API bool getLightLinearAttenuationValue(CgFxParameter param, float * value) const;
03286
03301   NVSG_API bool setLightLinearAttenuationValue(CgFxParameter param, const float * value);
03302
03321   NVSG_API bool getLightQuadraticAttenuationValue(CgFxParameter param, float * value) const;
03322
03337   NVSG_API bool setLightQuadraticAttenuationValue(CgFxParameter param, const float * value);
03338
03346   NVSG_API unsigned int getNumberOfSamplers() const;
03347
03349
03364   NVSG_API CgFxParameter getSampler(unsigned int index) const;
03365
03377   NVSG_API CgFxParameter getSamplerByName(const std::string& name) const;
03378
03405   NVSG_API CgFxParameter getSamplerByTextureParameterName(const std::string& name) const;
03406
03420   NVSG_API CGparameter getSamplerTexture(CgFxParameter param) const;
03421
03429   NVSG_API unsigned int getNumberOfProgramSamplers(CgFxProgram prog) const;
03430
03432
03449   NVSG_API CgFxParameter getProgramSampler(CgFxProgram prog, unsigned int index) const;
03450
03452
03462   NVSG_API ProgramIOType getProgramInputType(CgFxProgram prog) const;
03463
03465
03475   NVSG_API ProgramIOType getProgramOutputType(CgFxProgram prog) const;
03476
03477
03490   NVSG_API bool isMipmapSamplerState(CgFxParameter sampler) const;
03491
03507   NVSG_API bool isTextureImageSamplerCompliant(CgFxParameter sampler, TextureImageHandle * image) const;
03508
03535   NVSG_API bool setSamplerTextureImage(CgFxParameter param, TextureImageHandle * image);
03536
03553   NVSG_API bool getSamplerTextureFileName(CgFxParameter param, std::string& file) const;
03554
03570   NVSG_API TextureImageHandle * getSamplerTextureImage(CgFxParameter param) const;
03571
03582   NVSG_API bool setSamplerTextureGPUFormat(CgFxParameter param,
03583                                         TextureImage::TextureGPUFormat format);
03584
03599   NVSG_API bool getSamplerTextureGPUFormat(CgFxParameter param,
03600                                     TextureImage::TextureGPUFormat & format);
03601
03611   NVSG_API TextureTarget getSamplerTextureTarget(CgFxParameter param) const;
03612
03633   NVSG_API unsigned int getNumberOfSamplerStateValueComponents(CgFxParameter param, const std::string& name) const;
03634
03653   NVSG_API bool isFloatSamplerState(CgFxParameter param, const std::string& name) const;
03654
03673   NVSG_API bool isIntSamplerState(CgFxParameter param, const std::string& name) const;
03674
03693   NVSG_API bool isBoolSamplerState(CgFxParameter param, const std::string& name) const;
03694
03731   NVSG_API bool getFloatSamplerStateValue(CgFxParameter param, const std::string& name, float* value) const;
03732
03769   NVSG_API bool getIntSamplerStateValue(CgFxParameter param, const std::string& name, int* value) const;
03770
03807   NVSG_API bool getBoolSamplerStateValue(CgFxParameter param, const std::string& name, int* value) const;
03808
03829   NVSG_API unsigned int getNumberOfTechniques() const;
03830
03844   NVSG_API CgFxTechnique getTechnique(unsigned int index) const;
03845
03859   NVSG_API CgFxTechnique getTechniqueByName(const std::string& name) const;
03860
03867   NVSG_API unsigned int getTechniqueIndex(CgFxTechnique tech) const;
03868
03882   NVSG_API const std::string& getTechniqueName(CgFxTechnique tech) const;
03883
03893   NVSG_API CgFxTechnique getCurrentTechnique() const;
03894
03907   NVSG_API void setCurrentTechnique(CgFxTechnique tech);
03908
03919   NVSG_API bool validateCurrentTechnique();
03920
03937   NVSG_API unsigned int getNumberOfPasses(CgFxTechnique tech) const;
03938
03957   NVSG_API CgFxPass getPass(CgFxTechnique tech, unsigned int index) const;
03958
03979   NVSG_API CgFxPass getPassByName(CgFxTechnique tech, const std::string& name) const;
03980
03994   NVSG_API const std::string& getPassName(CgFxPass pass) const;
03995
04008   NVSG_API bool isTransparentPass(CgFxPass pass) const;
04009
04057   NVSG_API void applyPass(unsigned int index);
04058
04072   NVSG_API void resetPass(unsigned int index);
04073
04093   NVSG_API unsigned int getNumberOfPassStateValueComponents(CgFxPass pass, const std::string& name) const;
04094
04113   NVSG_API bool isFloatPassState(CgFxPass pass, const std::string& name) const;
04114
04133   NVSG_API bool isIntPassState(CgFxPass pass, const std::string& name) const;
04134
04153   NVSG_API bool isBoolPassState(CgFxPass pass, const std::string& name) const;
04154
04191   NVSG_API bool getFloatPassStateValue(CgFxPass pass, const std::string& name, float* value) const;
04192
04229   NVSG_API bool getIntPassStateValue(CgFxPass pass, const std::string& name, int* value) const;
04230
04267   NVSG_API bool getBoolPassStateValue(CgFxPass pass, const std::string& name, int* value) const;
04268
04276   NVSG_API CgFxProgram getVertexProgram(CgFxPass pass) const;
04277
04285   NVSG_API CgFxProgram getGeometryProgram(CgFxPass pass) const;
04286
04294   NVSG_API CgFxProgram getFragmentProgram(CgFxPass pass) const;
04295
04308   NVSG_API bool isProgramCompiled(CgFxProgram prog) const;
04309
04327   NVSG_API bool compileProgram(CgFxProgram prog);
04328
04352   NVSG_API bool setProgramProfile(CgFxProgram prog, const std::string& profile);
04353
04365   NVSG_API const std::string& getProgramProfile(CgFxProgram prog) const;
04366
04380   NVSG_API unsigned int getNumberOfProgramParameters(CgFxProgram prog) const;
04381
04397   NVSG_API CgFxParameter getProgramParameter(CgFxProgram prog, unsigned int index) const;
04398
04417   NVSG_API bool isInputProgramParameter(CgFxProgram prog, CgFxParameter param) const;
04418
04437   NVSG_API bool isOutputProgramParameter(CgFxProgram prog, CgFxParameter param) const;
04438
04439 private:
04440   CgFxEffect& operator=(const CgFxEffect& rhs);
04441
04442   bool initialize(); // parse effect and fill internal structs
04443   void uninitialize(); // cleanup internal structs
04444
04445   // invalidates transparency containment caches of the owning attribute
04446   void invalidateTransparencyContainment();
04447
04448   template <typename T>
04449   bool getParameterValue(CgFxParameter param, T * value, bool (*testType)(CGtype)) const;
04450   template <typename T>
04451   bool setParameterValue(CgFxParameter param, const T * value, bool (*testType)(CGtype));
04452
04453   // sync cached values with effect
04454   void flush();
04455
04456   // walks all techniques for their passes to unload their vertex and fragment programs
04457   void unloadPrograms();
04458
04459   // tests on equivalency with another effect
04460   bool isEquivalent(const CgFxEffect * rhs) const;
04461
04462 private:
04463   CgFxHandle * m_attrib; // associated attribute. need this link for cache updates
04464   CgFxEffectResource * m_effect; // handle to the effect resource
04465
04466   enum SourceType
04467   {
04468     SOURCE_UNKNOWN = 0
04469   , SOURCE_FILE = 1
04470   , SOURCE_LUMP
04471   };
04472
04473   unsigned int m_from; // either SOURCE_FILE or SOURCE_LUMP
04474   std::string * m_source; // either filename or code
04475
04476   // distinguish several parameter traits
04477   enum {
04478     PTRAIT_TRAFO = 0
04479   , PTRAIT_LIGHT
04480   , FIRST_FLUSHABLE = PTRAIT_LIGHT
04481   , PTRAIT_MATERIAL
04482   , PTRAIT_SCENE
04483   , PTRAIT_TWEAK
04484   , LAST_FLUSHABLE = PTRAIT_TWEAK
04485   , PTRAIT_SAMPLER
04486   , NUM_PTRAITS
04487   };
04488
04489   std::vector< std::vector<CgFxParameter> > m_params;
04490   std::vector<CgFxTechnique> m_techs;
04491   std::set<CgFxParameter> m_flushList; // unique flush list
04492
04493   CgFxTechnique m_currTech; // current technique
04494   CgFxTechnique m_lastCurrTech; // last current technique - need this to check whether validation is pending
04495 };
04496
04497
04501 class CgFx : public StateAttribute
04502 {
04503 public:
04506   NVSG_API CgFx();
04507
04510   NVSG_API CgFx(const CgFx& rhs);
04511
04514   NVSG_API virtual ~CgFx();
04515
04524   NVSG_API CgFx& operator=(const CgFx& rhs);
04525
04541   NVSG_API virtual bool isDataShared() const;
04542
04552   NVSG_API virtual DataID getDataID() const;
04553
04578   NVSG_API CgFxEffectHandle * getEffect() const;
04579
04622   static NVSG_API CgFxHandle * createFromFile( const std::string & file,
04623                                                std::vector< std::string > & searchPaths,
04624                                                std::string & errorReturn,
04625                                                bool & failOnTextureLoadInOut );
04626
04667   static NVSG_API CgFxHandle * createFromLump( const std::string & lump,
04668                                                std::vector< std::string > & searchPaths,
04669                                                std::string & errorReturn,
04670                                                bool & failOnTextureLoadInOut );
04671
04679   NVSG_API void unloadPrograms();
04680
04686   NVSG_API virtual bool isTransparent() const;
04687
04704   NVSG_API virtual bool isEquivalent(const Object *object, bool ignoreNames, bool deepCompare) const;
04705
04706
04707 private:
04708   CgFxEffectHandle * getEffect_impl_init() const;
04709   CgFxEffectHandle * getEffect_impl() const;
04710 private:
04711   mutable CgFxEffectHandle * (CgFx::*m_pfnGetEffect)() const;
04712   CgFxEffectHandle * m_effect; // embedded effect
04713 };
04714
04715 } // namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


ChangeCallBack.h File Reference

#include "nvutil/RCObject.h"
#include "nvsg/CoreTypes.h"

Include dependency graph for ChangeCallBack.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:34 2008 for NVSGSDK by NVIDIA


ChangeCallBack.h Source File

ChangeCallBack.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvutil/RCObject.h"
00016 #include "nvsg/CoreTypes.h"
00017
00018 namespace nvsg
00019 {
00029   class ChangeCallback : public nvutil::RCObject
00030   {
00031   public:
00032
00042     NVSG_API virtual void changed(nvsg::ObjectHandle * subjectHandle, const void* userData = NULL ) const = 0;
00043   protected:
00046     ChangeCallback();
00047
00050     virtual ~ChangeCallback();
00051   };
00052 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


CPUSkinningProcessor.h File Reference

#include "nvsgcommon.h"
#include "AppTraverser.h"

Include dependency graph for CPUSkinningProcessor.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvgl
namespace | nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:35 2008 for NVSGSDK by NVIDIA


CPUSkinningProcessor.h Source File

CPUSkinningProcessor.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "AppTraverser.h"
00017
00018 namespace nvgl
00019 {
00020   struct GLArrayBufferCache;
00021 }
00022
00023 namespace nvtraverser
00024 {
00026
00028   class CPUSkinningProcessor : public AppTraverser::SkinningProcessor
00029   {
00030     public:
00032       NVSG_API CPUSkinningProcessor();
00033
00035       NVSG_API virtual void process( bool process );
00036       NVSG_API virtual AppTraverser::SkinningProcessorType getType();
00037
00039       static NVSG_API bool isSupported( void );
00040
00041     protected:
00042       NVSG_API virtual ~CPUSkinningProcessor();
00043
00044     private:
00045       nvgl::GLArrayBufferCache * getArrayBufferCache( const nvsg::DALHost * host );
00046       static bool isArrayBufferCacheValid( const nvgl::GLArrayBufferCache * info );
00047   };
00048
00049 } // namespace nvtraverser
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


CullData.h File Reference

#include "nvsgcommon.h"
#include "nvutil/RCObject.h"

Include dependency graph for CullData.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:35 2008 for NVSGSDK by NVIDIA


CullData.h Source File

CullData.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include  "nvutil/RCObject.h"
00017
00018 namespace nvsg
00019 {
00025   typedef enum
00026   {
00027     CC_OUT,
00028     CC_IN,
00029     CC_PART
00030   } CullCode;
00031
00039   class CullData : public nvutil::RCObject
00040   {
00041     public:
00045       NVSG_API CullData( CullCode cullCode );
00046
00047     public:
00054       NVSG_API void balance( void );
00055
00066       NVSG_API void addChild( CullData *cd );
00067
00072       NVSG_API const CullData * getChild( unsigned int i ) const;
00073
00076       NVSG_API CullCode getCullCode( void ) const;
00077
00084       NVSG_API unsigned int getNumberOfChildren( void ) const;
00085
00086     protected:
00088       NVSG_API virtual ~CullData( void );
00089
00090     private:
00091       NVSG_API CullData();  // private default constructor to prevent default creation
00092
00093     private:
00094       CullCode          m_cullCode;
00095       std::vector<CullData*> m_children;
00096   };
00097
00102   NVSG_API CullData * clone( const CullData * rhs );
00103
00112   bool operator==( const CullData &lhs, const CullData &rhs );
00113
00122   bool operator!=( const CullData &lhs, const CullData &rhs );
00123
00124   // - - - - - - - - - - - - - - - - - - - - -
00125   // inlines
00126   // - - - - - - - - - - - - - - - - - - - - -
00127
00128   inline  void  CullData::addChild( CullData *cd )
00129   {
00130     NVSG_TRACE();
00131     NVSG_ASSERT(cd);
00132     cd->addRef();
00133     m_children.push_back( cd );
00134   }
00135
00136   inline  const CullData  * CullData::getChild( unsigned int i ) const
00137   {
00138     NVSG_TRACE();
00139     NVSG_ASSERT( i < m_children.size() );
00140     return( m_children[i] );
00141   }
00142
00143   inline  CullCode  CullData::getCullCode( void ) const
00144   {
00145     NVSG_TRACE();
00146     return( m_cullCode );
00147   }
00148
00149   inline unsigned int CullData::getNumberOfChildren( void ) const
00150   {
00151     NVSG_TRACE();
00152     NVSG_ASSERT( m_children.size() <= UINT_MAX );
00153     return( static_cast<unsigned int>(m_children.size()) );
00154   }
00155
00156 } //  namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


CullTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Spherent.h"
#include "nvsg/CullData.h"
#include "nvsg/FlipbookAnimation.h"
#include "nvtraverser/ModelViewTraverser.h"
#include <map>
#include <utility>

Include dependency graph for CullTraverser.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:35 2008 for NVSGSDK by NVIDIA


CullTraverser.h Source File

CullTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Spherent.h"
00017 #include "nvsg/CullData.h"
00018 #include "nvsg/FlipbookAnimation.h"
00019 #include "nvtraverser/ModelViewTraverser.h"
00020 #include <map>
00021 #include <utility>          // make_pair
00022
00023 // forward declarations
00024 namespace nvsg
00025 {
00026   class Drawable;
00027   class Node;
00028   class GeoNode;
00029   class Group;
00030   class Shape;
00031 }
00032
00033 #ifdef _DEBUG
00034 # ifndef new
00035 #  define new new(__FILE__, __LINE__)
00036 #  define _DEFINED_DBGNEW // restrict the 'new' macro to this header file only
00037 # endif
00038 #endif
00039
00040 namespace nvtraverser
00041 {
00053   class CullTraverser : public SharedModelViewTraverser
00054   {
00055     public:
00056
00057     protected:
00059       NVSG_API CullTraverser();
00060
00064       NVSG_API virtual ~CullTraverser(void);
00065
00074       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00075
00084       NVSG_API virtual void postApply(nvsg::NodeHandle * root);
00085
00090       NVSG_API virtual nvsg::CullCode cullCode( const nvmath::Sphere3f & bs ) const;
00091
00099       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p );
00100
00107       NVSG_API virtual void handleFlipbookAnimation( const nvsg::FlipbookAnimation * p );
00108
00116       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * p );
00117
00125       NVSG_API virtual void handleGroup( const nvsg::Group * p );
00126
00135       NVSG_API virtual void handleLOD( const nvsg::LOD * p );
00136
00145       NVSG_API virtual void handleSwitch( const nvsg::Switch * p );
00146
00154       NVSG_API virtual void handleTransform( const nvsg::Transform * p );
00155
00162       NVSG_API virtual void handleVolumeNode( const nvsg::VolumeNode * p );
00163
00171       NVSG_API virtual void handleShape( const nvsg::Shape * p );
00172
00179       NVSG_API virtual void traversePrimitiveSet( const nvsg::PrimitiveSet * p );
00180
00187       NVSG_API unsigned short getCurrentHints() const;
00188
00195       NVSG_API unsigned short getCurrentHintsContainment() const;
00196
00197     private:
00198       typedef std::map<nvsg::ObjectHandle*,nvsg::CullData*> ObjectCullMap;
00199
00200     private:
00201       template <typename N> void handleNode(void (CullTraverser::*ph)(const N *), const N * p);
00202       nvsg::CullCode determineCullCode( const nvmath::Sphere3f & bs ) const;
00203       template <typename T> nvsg::CullData * determineCullData( const T * p );
00204       void postTraverseObject( const ObjectCullMap::iterator it, nvsg::CullData *cd );
00205       void registerCullCodes( const nvsg::FlipbookAnimation * p ); // initiates FlipbookAnimation specific post-processing
00206       void registerCullCodes( const nvsg::GeoNode * p ); // initiates GeoNode specific post-processing
00207       void registerCullCodes( const nvsg::Group * p ); // initiates Group specific post-processing
00208       void registerCullCodes( const nvsg::Shape * p ); // initiates Shape specific post-processing
00209
00210       // additional level of indirection to call the base implementation of
00211       // a particular handle function. these will be invoked from the general
00212       // handleNode template
00213       void baseHandleBillboard( const nvsg::Billboard * p );
00214       void baseHandleFlipbookAnimation( const nvsg::FlipbookAnimation * p );
00215       void baseHandleGeoNode( const nvsg::GeoNode * p );
00216       void baseHandleGroup( const nvsg::Group * p );
00217       void baseHandleLOD( const nvsg::LOD * p );
00218       void baseHandleSwitch( const nvsg::Switch * p );
00219       void baseHandleTransform( const nvsg::Transform * p );
00220
00221     private:
00222       std::stack<nvsg::CullData *>    m_cullDataStack;
00223       std::stack<ObjectCullMap>       m_objectCullMapStack;
00224       nvsg::CullData                * m_cullTree;
00225       unsigned short                  m_currentHints;
00226       unsigned short                  m_currentHintsContainment;
00227       bool                            m_trivialIn; // status flag to consider while traversing tree objects
00228                                                    // true -> parent/owner is trivial in - just go on with traversal
00229                                                    // false -> requires a more detailed consideration
00230   };
00231
00232   template <typename T> // type providing getBoundingSphere API
00233   inline nvsg::CullData * CullTraverser::determineCullData( const T * p )
00234   {
00235     NVSG_TRACE();
00236     NVSG_ASSERT(!m_trivialIn);
00237
00238     //  This tree object is at least partially visible with respect to a previous cull step.
00239     //  The object CullData should be added to the top element of the ObjectCullCodeMapStack.
00240     ObjectCullMap * top = &m_objectCullMapStack.top();
00241     NVSG_ASSERT(top); // stack corruption if this fires!
00242
00243     // we use the object's handle to map the object to its corresponding CullData
00244     // we need to test if this object is already in the map, because we support multiple identical
00245     // children (same pointer) in a Group!!
00246     nvsg::ObjectHandle * h = nvutil::getHandle<nvsg::ObjectHandle>(p);
00247     if ( top->find(h) == top->end() )
00248     {
00249       nvsg::CullCode cc = determineCullCode( p->getBoundingSphere() );
00250       nvsg::CullData * cd = new nvsg::CullData(cc);
00251       (*top)[h] = cd;
00252     }
00253
00254     return( (*top)[h] );
00255   }
00256
00257   inline unsigned short CullTraverser::getCurrentHints() const
00258   {
00259     return( m_currentHints );
00260   }
00261
00262   inline unsigned short CullTraverser::getCurrentHintsContainment() const
00263   {
00264     return( m_currentHintsContainment );
00265   }
00266 }
00267
00268 #ifdef _DEFINED_DBGNEW
00269 # undef new
00270 #endif
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


DAL.h File Reference

#include "nvsgcommon.h"
#include <vector>
#include <map>
#include "nvsg/CoreTypes.h"
#include "nvutil/Singleton.h"
#include "nvutil/SWMRSync.h"

Include dependency graph for DAL.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:36 2008 for NVSGSDK by NVIDIA


DAL.h Source File

DAL.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include <vector>
00018 #include <map>
00019 #include "nvsg/CoreTypes.h"
00020 #include "nvutil/Singleton.h"
00021 #include "nvutil/SWMRSync.h"
00022
00023 namespace nvsg
00024 {
00025 class DALServer;
00026 class DALData;
00027 class DALHost;
00028
00029 #if defined(_WIN32)
00030 typedef DWORD THREADID;
00031 #elif defined(LINUX)
00032 typedef pthread_t THREADID;
00033 #else
00034 #error Unsupported Operating System!
00035 #endif
00036
00038 typedef unsigned long HDAL;
00040 extern const HDAL HDAL_INVALID;
00041
00042 inline THREADID getCallingThread()
00043 {
00044 #if defined(_WIN32)
00045   return GetCurrentThreadId();
00046 #elif defined(LINUX)
00047   return pthread_self();
00048 #endif
00049 }
00050
00051 class DALHostHolder
00052 {
00053 public:
00054   NVSG_API DALHostHolder();
00055   NVSG_API virtual ~DALHostHolder();
00056   NVSG_API DALHostHolder(const DALHostHolder& rhs);
00057   NVSG_API DALHostHolder& operator=(const DALHostHolder& rhs);
00058
00059   NVSG_API DALHostHandle * getDALHost() const { return m_host; }
00060   NVSG_API void releaseDALData();
00061
00062 private:
00063   DALHostHandle * m_host;
00064 };
00065
00075 class DALHost : public nvutil::HandledObject
00076 {
00077 #if !defined(DOXYGEN_IGNORE)
00078   friend class DALServer;
00079 #endif
00080
00081 public:
00113   NVSG_API HDAL storeDeviceAbstractionLinkData(unsigned int dataID, DALData * data);
00114
00123   NVSG_API void releaseDeviceAbstractionLinkData();
00124
00152   template<typename DALDataType, typename TestFunc>
00153   bool getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *& cache, TestFunc test) const;
00154
00192   NVSG_API DALData * getLastRecentlyUsedDeviceAbstractionLinkData() const;
00193
00194 #if !defined(DOXYGEN_IGNORE)
00195 public:
00196   DALHost();
00197   DALHost(const DALHost&);
00198   ~DALHost();
00199 protected:
00200   DALHost & operator=(const DALHost & rhs) {return *this;}
00201 private:
00202   HDAL m_hdal;
00203   mutable std::map<THREADID, DALData*> m_recent; // per-thread recent data
00204   typedef std::map<THREADID, DALData*>::iterator RecentIter;
00205   typedef std::map<THREADID, DALData*>::const_iterator ConstRecentIter;
00206 #endif
00207 };
00208
00215 class DALDataCreator
00216 {
00217 public:
00218 #if !defined(DOXYGEN_IGNORE)
00219   virtual ~DALDataCreator() {}
00220 #endif
00221
00238   virtual void onReleaseDAL(HDAL hDAL) {}
00239
00240 protected:
00241 #if !defined(DOXYGEN_IGNORE)
00242   // DALDataCreator serves as base class only.
00243   DALDataCreator() {}
00244 #endif
00245
00260   NVSG_API void releaseDeviceAbstractionLinkData(HDAL hDAL, unsigned int dataID);
00261 };
00262
00273 class DALData
00274 {
00275 #if !defined(DOXYGEN_IGNORE)
00276   friend class DALServer;
00277   friend class DALDataCreator;
00278   friend class DALHost;
00279 protected:
00280   virtual ~DALData();
00281 #endif
00282
00283 public:
00293   NVSG_API unsigned int getUserID() const;
00294
00300   NVSG_API void setUserID( unsigned int userID );
00301
00309   NVSG_API bool verifyCreator(const DALDataCreator * creator) const;
00310
00311 protected:
00319   DALData(DALDataCreator * creator);
00320
00331   virtual void deleteThis() { delete this; }
00332
00333 #if !defined(DOXYGEN_IGNORE)
00334 private:
00335   DALDataCreator  * m_creator;
00336   DALHostHandle   * m_host;
00337   unsigned int      m_userID;
00338 #endif
00339 };
00340
00341 inline unsigned int DALData::getUserID() const
00342 {
00343   return( m_userID );
00344 }
00345
00346 inline void DALData::setUserID( unsigned int userID )
00347 {
00348   m_userID = userID;
00349 }
00350
00351 inline bool DALData::verifyCreator(const DALDataCreator * creator) const
00352 {
00353   return creator == m_creator;
00354 }
00355
00356 #if !defined(DOXYGEN_IGNORE)
00357 // Device Abstraction Link Server - implementation details
00358 class DALServer
00359 {
00360   friend class DALDataCreator;
00361   friend class DALHost;
00362
00363 public:
00364   // Initializes the DALServer at instantiation
00365   DALServer();
00366   // Cleanup after deletion
00367   ~DALServer();
00368 private:
00369   // Attaches the data identified by \a dataID and pointed to by \a data
00370   // to the Device Abstraction Link (DAL) identified by \a hDAL.
00371   // If HDAL_INVALID is passed for \a hDAL, a new DAL will be created first.
00372   // \returns A handle to the Device Abstraction Link or DAL_INVALID if the function fails.
00373   HDAL storeDALData(HDAL hDAL, unsigned int dataID, DALData* data);
00374   // Releases the data identified by \a dataID that was attached to the DAL identified by \a hDAL
00375   // by the creator pointed to by \a creator.
00376   // If 0xFFFFFFFF is passed for \a dataID, all data that was attached to the DAL identified by \a hDAL
00377   // by the creator pointed to by \a creator will be released.
00378   // If NULL is passed for \a creator, all data attached to the DAL identified by \a hDAL will be released
00379   // and the DAL will be deleted afterwards.
00380   void releaseDALData(HDAL hDAL, DALDataCreator * creator=NULL, unsigned int dataID=0xFFFFFFFF);
00381   // Provides all addresses of the data objects identified by \a dataID that are currently stored
00382   // with the DAL identified by \a hDAL.
00383   // The addresses of the data objects will be copied to the vector referenced by \a data.
00384   bool getDALData(HDAL hDAL, unsigned int dataID, std::vector<DALData*>& data) const;
00385
00386   // Calls delete this on the data pointer passed
00387   void deleteDALData(DALData * data);
00388
00389 private:
00390   std::map<HDAL, std::multimap<unsigned int, DALData*> > m_DALMap; // map of DALs
00391   std::vector<HDAL> m_freeHDALs; // free DAL handles can be re-used
00392   HDAL m_hDALNext; // use this if no handle is available for re-use
00393
00394   nvutil::SWMRSync m_lock; // secure access to the singleton server in a multi-threaded environment
00395 };
00396
00397 typedef nvutil::Singleton<DALServer> DALS;
00398
00399 #endif // DOXYGEN_IGNORE
00400
00401 inline void DALHostHolder::releaseDALData()
00402 {
00403   NVSG_TRACE();
00404   nvutil::WritableObject<DALHost> host(m_host);
00405   host->releaseDeviceAbstractionLinkData();
00406 }
00407
00408 inline HDAL DALHost::storeDeviceAbstractionLinkData(unsigned int dataID, DALData * data)
00409 {
00410   NVSG_TRACE();
00411   NVSG_ASSERT(data); // do not like bad data
00412   NVSG_ASSERT(data->m_host==NULL); // data must not be hosted by anyone else
00413
00414   m_hdal = DALS::instance()->storeDALData(m_hdal, dataID, data);
00415   if ( HDAL_INVALID != m_hdal )
00416   {
00417     data->m_host = nvutil::getHandle<DALHostHandle>(this);
00418     m_recent[getCallingThread()] = data;
00419   }
00420   return m_hdal;
00421 }
00422
00423 inline void DALHost::releaseDeviceAbstractionLinkData()
00424 {
00425   NVSG_TRACE();
00426
00427   // HDAL_INVALID means no data hosted
00428   if ( HDAL_INVALID != m_hdal )
00429   {
00430     // release all data hosted
00431     //
00432     DALS::instance()->releaseDALData(m_hdal);
00433     m_recent.clear();
00434     m_hdal = HDAL_INVALID;
00435   }
00436 }
00437
00438 template <typename DALDataType, typename TestFunc>
00439 inline bool DALHost::getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *& data, TestFunc test) const
00440 {
00441   NVSG_TRACE();
00442
00443   data = NULL;
00444   std::vector<DALData*> caches;
00445
00446   if ( DALS::instance()->getDALData(m_hdal, dataID, caches) )
00447   {
00448     for ( std::vector<DALData*>::iterator i = caches.begin(); i!=caches.end(); ++i )
00449     {
00450       DALDataType * theData = dynamic_cast<DALDataType*>(*i);
00451       if ( theData && test(theData) )
00452       {
00453         m_recent[getCallingThread()] = theData;
00454         data = theData;
00455         return true;
00456       }
00457     }
00458   }
00459   return false;
00460 }
00461
00462 inline DALData * DALHost::getLastRecentlyUsedDeviceAbstractionLinkData() const
00463 {
00464   NVSG_TRACE();
00465   ConstRecentIter ri = m_recent.find(getCallingThread());
00466   if ( m_recent.end() == ri )
00467   {
00468     return NULL;
00469   }
00470   return ri->second;
00471 }
00472
00473 inline void DALDataCreator::releaseDeviceAbstractionLinkData(HDAL hDAL, unsigned int dataID)
00474 {
00475   NVSG_TRACE();
00476   NVSG_ASSERT(hDAL != HDAL_INVALID);
00477   DALS::instance()->releaseDALData(hDAL, this, dataID);
00478 }
00479
00480 } // namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


DbgNew.h File Reference

#include <new>
#include "nvsgcommon.h"

Include dependency graph for DbgNew.h:

Include dependency graph

Go to the source code of this file.

Functions

void * | operator new (size_t size, const char *src, unsigned int ln)
Dummy overload for objects that don't have an according new operator.

void * | operator new[] (size_t size, const char *src, unsigned int ln)
Dummy overload for arrays of objects that don't have an according new operator.

Detailed Description

Function Documentation

void* operator new | ( | size_t | size,
 |  | const char * | src,
 |  | unsigned int | ln
 | ) | [inline]

Dummy overload for objects that don't have an according new operator.

void* operator new[] | ( | size_t | size,
 |  | const char * | src,
 |  | unsigned int | ln
 | ) | [inline]

Dummy overload for arrays of objects that don't have an according new operator.

Generated on Tue Jan 15 10:27:36 2008 for NVSGSDK by NVIDIA


DbgNew.h Source File

DbgNew.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <new>
00016
00017 #include "nvsgcommon.h"
00018
00019 // The following new operator overload forwards to default new, and hence
00020 // has a matching delete operator. Disable the warning.
00021 #pragma warning (disable:4291)
00022
00024 inline void * operator new(size_t size, const char * src, unsigned int ln)
00025 {
00026   return operator new(size);
00027 }
00028
00030 #if !defined (_WIN64)
00031 inline void * operator new[](size_t size, const char * src, unsigned int ln)
00032 {
00033   return ::operator new[](size, std::nothrow);
00034 }
00035 #endif
00036
00037 #if defined(_DEBUG)
00038 # define new new(__FILE__, __LINE__)
00039 #endif
00040
00041
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


DefaultCullTraverser.h File Reference

#include "nvtraverser/CullTraverser.h"

Include dependency graph for DefaultCullTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:36 2008 for NVSGSDK by NVIDIA


DefaultCullTraverser.h Source File

DefaultCullTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvtraverser/CullTraverser.h"
00016
00017 namespace nvtraverser
00018 {
00019   class DefaultCullTraverser : public CullTraverser
00020   {
00021   protected:
00024     NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00025   };
00026 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


DepthAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/StateAttribute.h"

Include dependency graph for DepthAttribute.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:37 2008 for NVSGSDK by NVIDIA


DepthAttribute.h Source File

DepthAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/StateAttribute.h"
00017
00018
00019 namespace nvsg
00020 {
00030   typedef enum
00031   {
00032     DF_NEVER,
00033     DF_ALWAYS,
00034     DF_LESS,
00035     DF_LESS_OR_EQUAL,
00036     DF_EQUAL,
00037     DF_GREATER_OR_EQUAL,
00038     DF_GREATER,
00039     DF_NOT_EQUAL
00040   } DepthFunction;
00041
00051   class DepthAttribute : public StateAttribute
00052   {
00053     public:
00057       NVSG_API DepthAttribute();
00058
00063       NVSG_API explicit DepthAttribute( const StateAttribute &rhs );
00064
00066       NVSG_API DepthAttribute( const DepthAttribute &rhs );
00067
00069       NVSG_API virtual ~DepthAttribute();
00070
00074       NVSG_API nvsg::DepthFunction getDepthFunction() const;
00075
00079       NVSG_API void setDepthFunction( nvsg::DepthFunction df );
00080
00084       NVSG_API bool isDepthWritingEnabled() const;
00085
00089       NVSG_API void setDepthWritingEnabled( bool enabled );
00090
00094       NVSG_API bool isDepthTestingEnabled() const;
00095
00099       NVSG_API void setDepthTestingEnabled( bool enabled );
00100
00110       NVSG_API virtual bool isEquivalent( const Object * p
00111                                         , bool ignoreNames
00112                                         , bool deepCompare ) const;
00113
00120       NVSG_API DepthAttribute & operator=( const DepthAttribute & rhs );
00121
00122     private:
00123       DepthFunction m_depthFunction;
00124       bool          m_depthTesting;
00125       bool          m_depthWriting;
00126   };
00127
00128   inline DepthFunction DepthAttribute::getDepthFunction() const
00129   {
00130     NVSG_TRACE();
00131     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00132     return( m_depthFunction );
00133   }
00134
00135   inline bool DepthAttribute::isDepthTestingEnabled() const
00136   {
00137     NVSG_TRACE();
00138     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00139     return( m_depthTesting );
00140   }
00141
00142   inline bool DepthAttribute::isDepthWritingEnabled() const
00143   {
00144     NVSG_TRACE();
00145     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00146     return( m_depthWriting );
00147   }
00148
00149 } // namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


DestrippingTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvtraverser/Traverser.h"

Include dependency graph for DestrippingTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:37 2008 for NVSGSDK by NVIDIA


DestrippingTraverser.h Source File

DestrippingTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvtraverser/Traverser.h"
00017
00018 namespace nvtraverser
00019 {
00029   class DestrippingTraverser : public ExclusiveTraverser
00030   {
00031     public:
00034       NVSG_API DestrippingTraverser(void);
00035
00036     protected:
00040       NVSG_API virtual ~DestrippingTraverser(void);
00041
00047       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00048
00055       NVSG_API virtual void handleGeoNode( nvsg::GeoNode * p );
00056
00060       NVSG_API virtual void handleLineStrips( nvsg::LineStrips *p );
00061
00065       NVSG_API virtual void handleQuadStrips( nvsg::QuadStrips *p );
00066
00070       NVSG_API virtual void handleTriFans( nvsg::TriFans *p );
00071
00075       NVSG_API virtual void handleTriStrips( nvsg::TriStrips *p );
00076
00077     private:
00078       nvsg::LinesHandle     * createLinesFromLineStrips( nvutil::ReadableObject<nvsg::LineStrips> &ls );
00079       nvsg::QuadsHandle     * createQuadsFromQuadStrips( nvutil::ReadableObject<nvsg::QuadStrips> &qs );
00080       nvsg::TrianglesHandle * createTrianglesFromTriFans( nvutil::ReadableObject<nvsg::TriFans> &tf );
00081       nvsg::TrianglesHandle * createTrianglesFromTriStrips( nvutil::ReadableObject<nvsg::TriStrips> &ts );
00082
00083     private:
00084       std::vector<nvsg::LineStripsHandle *>                     m_lineStrips;
00085       std::map<nvsg::LineStripsHandle *,nvsg::LinesHandle *>    m_lineStripsToLines;
00086       std::vector<nvsg::QuadStripsHandle *>                     m_quadStrips;
00087       std::map<nvsg::QuadStripsHandle *,nvsg::QuadsHandle *>    m_quadStripsToQuads;
00088       std::vector<nvsg::TriFansHandle *>                        m_triFans;
00089       std::map<nvsg::TriFansHandle *,nvsg::TrianglesHandle *>   m_triFansToTriangles;
00090       std::vector<nvsg::TriStripsHandle *>                      m_triStrips;
00091       std::map<nvsg::TriStripsHandle *,nvsg::TrianglesHandle *> m_triStripsToTriangles;
00092   };
00093 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


DirectedLight.h File Reference

#include "nvsgcommon.h"
#include "nvsg/LightSource.h"

Include dependency graph for DirectedLight.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:37 2008 for NVSGSDK by NVIDIA


DirectedLight.h Source File

DirectedLight.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include "nvsg/LightSource.h"
00018
00019 namespace nvsg
00020 {
00026   class DirectedLight : public LightSource
00027   {
00028     public:
00031       NVSG_API DirectedLight();
00032
00040       NVSG_API explicit DirectedLight( const LightSource &rhs );
00041
00044       NVSG_API DirectedLight( const DirectedLight &rhs );
00045
00048       NVSG_API virtual ~DirectedLight();
00049
00054       NVSG_API nvmath::Vec3f getDirection() const;
00055
00061       NVSG_API void setDirection( const nvmath::Vec3f & direction );
00062
00068       NVSG_API const nvmath::Quatf & getOrientation() const;
00069
00076       NVSG_API void setOrientation( const nvmath::Quatf & orientation );
00077
00083       NVSG_API DirectedLight & operator=( const DirectedLight & rhs );
00084   };
00085
00086   inline nvmath::Vec3f DirectedLight::getDirection() const
00087   {
00088     NVSG_TRACE();
00089     return nvmath::Vec3f (0.f, 0.f, -1.f) * m_trafo.getOrientation();
00090   }
00091
00092   inline const nvmath::Quatf & DirectedLight::getOrientation() const
00093   {
00094     NVSG_TRACE();
00095     return m_trafo.getOrientation();
00096   }
00097 } //  namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


Drawable.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Boxnt.h"
#include "nvmath/Spherent.h"
#include "nvsg/OwnedObject.h"
#include "nvutil/BitMask.h"

Include dependency graph for Drawable.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:38 2008 for NVSGSDK by NVIDIA


Drawable.h Source File

Drawable.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"  // commonly used stuff
00016 #include "nvmath/Boxnt.h"
00017 #include "nvmath/Spherent.h"
00018 #include "nvsg/OwnedObject.h" // base class definition
00019 #include "nvutil/BitMask.h"
00020
00021 namespace nvsg
00022 {
00030   class Drawable : public OwnedObject<NodeHandle>
00031   {
00032     friend class Node;
00033
00034     public:
00037       NVSG_API virtual ~Drawable( void );
00038
00041       NVSG_API const nvmath::Box3f & getBoundingBox() const;
00042
00051       NVSG_API const nvmath::Sphere3f & getBoundingSphere() const;
00052
00057       NVSG_API void invalidateBoundingVolumes();
00058
00061       NVSG_API void invalidateAnimationContainment();
00062
00065       NVSG_API virtual bool containsAnimation() const;
00066
00074       NVSG_API void attachHighlightObject( HighlightObjectHandle* obj = NULL );
00075
00079       NVSG_API HighlightObjectHandle * getHighlightObject( void ) const;
00080
00087       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00088
00089     protected:
00094       NVSG_API Drawable( void );
00095
00100       NVSG_API Drawable( const Drawable& );
00101
00107       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const = 0;
00108
00115       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const = 0;
00116
00125       NVSG_API Drawable & operator=(const Drawable & rhs);
00126
00127     private:
00128
00129       // private status flags controlling invalidation
00130       enum
00131       {
00132         DF_BOUNDING_BOX_VALID = BIT0,
00133         DF_BOUNDING_SPHERE_VALID = BIT1,
00134         DF_BOUNDING_VOLUMES_VALID = DF_BOUNDING_BOX_VALID | DF_BOUNDING_SPHERE_VALID
00135       };
00136
00137       mutable unsigned int m_flags;
00138       mutable nvmath::Box3f m_boundingBox;
00139       mutable nvmath::Sphere3f m_boundingSphere;
00140
00141       HighlightObjectHandle * m_highlightObject; // optional attached HighlightObject
00142   };
00143
00144   inline HighlightObjectHandle * Drawable::getHighlightObject( void ) const
00145   {
00146     NVSG_TRACE();
00147     return( m_highlightObject );
00148   }
00149
00150   template <typename T>
00151   inline T drawable_cast(const Drawable * drwbl)
00152   {
00153     NVSG_CTASSERT(!!(nvutil::Conversion<T,const Drawable*>::exists));
00154     return dynamic_cast<T>(drwbl);
00155   }
00156
00157   template <typename T>
00158   inline T drawable_cast(Drawable * drwbl)
00159   {
00160     NVSG_CTASSERT(!!(nvutil::Conversion<T,Drawable*>::exists));
00161     return dynamic_cast<T>(drwbl);
00162   }
00163 } // namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


EliminateTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvtraverser/OptimizeTraverser.h"

Include dependency graph for EliminateTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:38 2008 for NVSGSDK by NVIDIA


EliminateTraverser.h Source File

EliminateTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include "nvtraverser/OptimizeTraverser.h"
00018
00019 namespace nvtraverser
00020 {
00031   class EliminateTraverser : public OptimizeTraverser
00032   {
00033     public:
00034       enum
00035       {
00036         ET_GROUP                  = BIT0,
00037         ET_LOD                    = BIT1,
00038         ET_STATE_PASS             = BIT2,
00039         ET_STATE_SET              = BIT3,
00040         ET_STATE_VARIANT          = BIT4,
00041         ET_TEXTURE_ATTRIBUTE      = BIT5,
00042         ET_TEXTURE_ATTRIBUTE_ITEM = BIT6,
00043         ET_ALL_TARGETS_MASK   = ( ET_GROUP | ET_LOD | ET_STATE_PASS | ET_STATE_SET
00044                                 | ET_STATE_VARIANT | ET_TEXTURE_ATTRIBUTE
00045                                 | ET_TEXTURE_ATTRIBUTE_ITEM )
00046       } EliminateTarget;
00047
00048     public:
00050       NVSG_API EliminateTraverser( void );
00051
00054       NVSG_API unsigned int getEliminateTargets() const;
00055
00058       NVSG_API void setEliminateTargets( unsigned int mask );
00059
00060     protected:
00062       NVSG_API virtual ~EliminateTraverser( void );
00063
00065       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00066
00068
00069       NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransform *p );
00070
00072       NVSG_API virtual void handleBillboard( nvsg::Billboard *p );
00073
00075       NVSG_API virtual void handleFlipbookAnimation( nvsg::FlipbookAnimation * p );
00076
00077       NVSG_API virtual void handleGeoNode( nvsg::GeoNode * p );
00078
00080       NVSG_API virtual void handleGroup( nvsg::Group * p );
00081
00083       NVSG_API virtual void handleLOD( nvsg::LOD *p );
00084
00085       NVSG_API virtual void handleStatePass( nvsg::StatePass * p );
00086
00087       NVSG_API virtual void handleStateSet( nvsg::StateSet * p );
00088
00089       NVSG_API virtual void handleStateVariant( nvsg::StateVariant * p );
00090
00092       NVSG_API virtual void handleSwitch( nvsg::Switch *p );
00093
00094       NVSG_API virtual void handleTextureAttribute( nvsg::TextureAttribute * p );
00095
00097       NVSG_API virtual void handleTransform( nvsg::Transform *p );
00098
00099     private:
00100       void eliminateGroups( nvsg::Group *p );
00101       void eliminateSingleChildChildren( nvsg::Group *p, unsigned int objectCode );
00102       bool isOneChildCandidate( const nvsg::Group * p );
00103
00104     private:
00105       unsigned int m_eliminateTargets;
00106   };
00107
00108   inline unsigned int EliminateTraverser::getEliminateTargets() const
00109   {
00110     return( m_eliminateTargets );
00111   }
00112
00113   inline void EliminateTraverser::setEliminateTargets( unsigned int mask )
00114   {
00115     m_eliminateTargets = mask;
00116   }
00117 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


ErrorHandling.h File Reference

#include "nvsgcommon.h"
#include <string>

Include dependency graph for ErrorHandling.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:38 2008 for NVSGSDK by NVIDIA


ErrorHandling.h Source File

ErrorHandling.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include <string>
00018
00019 namespace nvsg
00020 {
00021 // forward declaration
00022 class NVSGException;
00024 typedef void NVSGERRORHANDLER(const NVSGException&);
00025
00029 extern NVSGERRORHANDLER * nvsgErrorHandler;
00039 NVSGERRORHANDLER * nvsgSetErrorHandler(NVSGERRORHANDLER * newErrorHandler);
00040
00044 class NVSGException
00045 {
00046 public:
00055   NVSGException(bool critical, const std::string& errMsg) : m_critical(critical), m_errMsg(errMsg) {}
00069   NVSGException(bool critical, unsigned int errMsgID) {}
00070   virtual ~NVSGException() {}
00071
00082   virtual bool isCritical() const;
00088   virtual const std::string& getErrorMessage() const;
00089
00090 private:
00091   bool m_critical;
00092   std::string m_errMsg;
00093 };
00094
00095 // inline function implementation
00096
00097 inline bool NVSGException::isCritical() const
00098 {
00099   return m_critical;
00100 }
00101
00102 inline const std::string& NVSGException::getErrorMessage() const
00103 {
00104   return m_errMsg;
00105 }
00106
00107 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


ExtractGeometryTraverser.h File Reference

#include <nvsgcommon.h>
#include <nvtraverser/Traverser.h>
#include <nvutil/TransformStack.h>
#include <nvmath/Trafo.h>
#include <string>

Include dependency graph for ExtractGeometryTraverser.h:

Include dependency graph

Go to the source code of this file.

Classes

class ExtractGeometryTraverser
Traverser that can handle the model view transform stack. More...

Detailed Description

Generated on Tue Jan 15 10:27:38 2008 for NVSGSDK by NVIDIA


ExtractGeometryTraverser.h Source File

ExtractGeometryTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00005 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00006 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00007 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00008 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00009 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00010 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00011 // POSSIBILITY OF SUCH DAMAGES
00012
00013 #pragma once
00014
00016 #include <nvsgcommon.h>
00017 #include <nvtraverser/Traverser.h>
00018 #include <nvutil/TransformStack.h>
00019 #include <nvmath/Trafo.h>
00020 #include <string>
00021
00022 #ifdef NVSG_API
00023 #undef NVSG_API
00024 #endif
00025
00026 #define NVSG_API
00027
00029
00034 class ExtractGeometryTraverser : public nvtraverser::SharedTraverser
00035 {
00036   protected:
00038
00040     NVSG_API ExtractGeometryTraverser();
00041
00043     NVSG_API virtual ~ExtractGeometryTraverser();
00044
00046
00047     NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00048                                                 );
00049
00051
00053     NVSG_API virtual void handleBillboard( const nvsg::Billboard *p
00054                                          );
00055
00057     NVSG_API virtual void handleSwitch( const nvsg::Switch *p
00058                                          );
00059
00060     NVSG_API virtual void handleLOD( const nvsg::LOD *lod );
00061
00063
00065     NVSG_API virtual void handleTransform( const nvsg::Transform *p
00066                                         );
00067
00069
00070     NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00071                                               );
00072
00074
00076     NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00077                                               );
00078
00079     NVSG_API virtual void traversePrimitiveSet( const nvsg::PrimitiveSet * pset );
00080
00081     //
00082     // Override this method to be informed of transformed indexed triangle
00083     // sets.  Quads will be triangulated before being sumbitted.
00084     //
00085     NVSG_API virtual void submitIndexedTriangleSet(
00086                 const std::vector<unsigned int> & indices,
00087                 const std::vector<nvmath::Vec3f> & verts,
00088                 const std::vector<nvmath::Vec3f> & normals ) = 0;
00089
00090     // override this method to be informed of dynamic objects on the
00091     // terrain
00092     NVSG_API virtual void submitDynamicObject(
00093                 unsigned int id,
00094                 const std::string & annotation,
00095                 nvmath::Trafo & m_trafo,
00096                 const std::vector<unsigned int> & indices,
00097                 const std::vector<nvmath::Vec3f> & verts,
00098                 const std::vector<nvmath::Vec3f> & normals ) = 0;
00099
00100   protected:
00101     nvutil::TransformStack  m_transformStack;
00102     bool m_inObject;
00103     nvmath::Trafo m_trafo;
00104     unsigned int m_id;
00105     unsigned int m_idCount;
00106     std::string m_annotation;
00107 };
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


Face.h File Reference

#include "nvsgcommon.h"

Include dependency graph for Face.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:39 2008 for NVSGSDK by NVIDIA


Face.h Source File

Face.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 namespace nvsg
00018 {
00024   template<unsigned char n> class Face
00025   {
00026     public:
00032       template<typename T>
00033         unsigned int & operator[]( T i );
00034
00040       template<typename T>
00041         const unsigned int & operator[]( T i ) const;
00042
00043     public:
00044       unsigned int m_indices[n];
00045   };
00046
00047   template<unsigned char n>
00048   template<typename T>
00049     inline unsigned int & Face<n>::operator[]( T i )
00050   {
00051     NVSG_CTASSERT( std::numeric_limits<T>::is_integer );
00052     NVSG_ASSERT( i < n );
00053     return m_indices[i];
00054   }
00055
00056   template<unsigned char n>
00057   template<typename T>
00058     inline const unsigned int & Face<n>::operator[]( T i ) const
00059   {
00060     NVSG_CTASSERT( std::numeric_limits<T>::is_integer );
00061     NVSG_ASSERT( i < n );
00062     return m_indices[i];
00063   }
00064
00065   typedef Face<2> Segment;
00066   typedef Face<3> Face3;
00067   typedef Face<4> Face4;
00068 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


FaceAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/PrimitiveAttribute.h"
#include "nvutil/BitMask.h"

Include dependency graph for FaceAttribute.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:39 2008 for NVSGSDK by NVIDIA


FaceAttribute.h Source File

FaceAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/PrimitiveAttribute.h"
00017 #include "nvutil/BitMask.h"
00018
00019
00020 namespace nvsg
00021 {
00022   class FaceAttribute;
00023
00024   typedef enum
00025   {
00026     FM_POINT,
00027     FM_LINE,
00028     FM_FACE
00029   } FaceMode;
00030
00036   class FaceAttribute : public PrimitiveAttribute
00037   {
00038     public:
00042       NVSG_API FaceAttribute();
00043
00048       NVSG_API explicit FaceAttribute( const PrimitiveAttribute &rhs );
00049
00051       NVSG_API FaceAttribute( const FaceAttribute &rhs );
00052
00054       NVSG_API virtual ~FaceAttribute();
00055
00063       NVSG_API bool isFrontFaceCulling() const;
00064
00071       NVSG_API bool isBackFaceCulling() const;
00072
00083       NVSG_API void setCullMode( bool frontCulling, bool backCulling );
00084
00092       NVSG_API FaceMode getFrontFaceMode() const;
00093
00101       NVSG_API FaceMode getBackFaceMode() const;
00102
00111       NVSG_API void setFaceMode( FaceMode frontMode, FaceMode backMode );
00112
00121       NVSG_API bool isPolygonOffset() const;
00122
00128       NVSG_API float getPolygonOffsetFactor() const;
00129
00135       NVSG_API float getPolygonOffsetUnits() const;
00136
00146       NVSG_API void setPolygonOffset( bool onOff );
00147
00156       NVSG_API void setPolygonOffset( float factor
00157                                     , float units );
00158
00169       NVSG_API bool isTwoSidedLighting() const;
00170
00180       NVSG_API void setTwoSidedLighting( bool onOff );
00181
00188       NVSG_API FaceAttribute & operator=( const FaceAttribute & rhs );
00189
00200       NVSG_API virtual bool isEquivalent( const Object * p
00201                                         , bool ignoreNames
00202                                         , bool deepCompare ) const;
00203
00204     private:
00205       bool            m_cullMode[2];
00206       FaceMode        m_faceMode[2];
00207       struct
00208       {
00209         bool  enabled;
00210         float factor;
00211         float units;
00212       }               m_polygonOffset;
00213       bool            m_twoSidedLighting;
00214   };
00215
00216   inline bool FaceAttribute::isFrontFaceCulling() const
00217   {
00218     NVSG_TRACE();
00219     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00220     return( m_cullMode[0] );
00221   }
00222
00223   inline bool FaceAttribute::isBackFaceCulling() const
00224   {
00225     NVSG_TRACE();
00226     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00227     return( m_cullMode[1] );
00228   }
00229
00230   inline void FaceAttribute::setCullMode( bool frontCulling, bool backCulling )
00231   {
00232     NVSG_TRACE();
00233     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00234     if ( ( m_cullMode[0] != frontCulling ) || ( m_cullMode[1] != backCulling ) )
00235     {
00236       m_cullMode[0] = frontCulling;
00237       m_cullMode[1] = backCulling;
00238       invalidateIncarnation();
00239     }
00240   }
00241
00242   inline FaceMode FaceAttribute::getFrontFaceMode() const
00243   {
00244     NVSG_TRACE();
00245     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00246     return( m_faceMode[0] );
00247   }
00248
00249   inline FaceMode FaceAttribute::getBackFaceMode() const
00250   {
00251     NVSG_TRACE();
00252     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00253     return( m_faceMode[1] );
00254   }
00255
00256   inline void FaceAttribute::setFaceMode( FaceMode frontMode, FaceMode backMode )
00257   {
00258     NVSG_TRACE();
00259     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00260     if ( ( m_faceMode[0] != frontMode ) || ( m_faceMode[1] != backMode ) )
00261     {
00262       m_faceMode[0] = frontMode;
00263       m_faceMode[1] = backMode;
00264       invalidateIncarnation();
00265     }
00266   }
00267
00268   inline void FaceAttribute::setPolygonOffset( bool enabled )
00269   {
00270     NVSG_TRACE();
00271     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00272     if ( m_polygonOffset.enabled != enabled )
00273     {
00274       m_polygonOffset.enabled = enabled;
00275       invalidateIncarnation();
00276     }
00277   }
00278
00279   inline void FaceAttribute::setPolygonOffset( float factor, float units )
00280   {
00281     NVSG_TRACE();
00282     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00283     if ( ( m_polygonOffset.factor != factor ) || ( m_polygonOffset.units != units ) )
00284     {
00285       m_polygonOffset.factor = factor;
00286       m_polygonOffset.units = units;
00287       invalidateIncarnation();
00288     }
00289   }
00290
00291   inline bool FaceAttribute::isPolygonOffset() const
00292   {
00293     NVSG_TRACE();
00294     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00295     return( m_polygonOffset.enabled );
00296   }
00297
00298   inline float FaceAttribute::getPolygonOffsetFactor() const
00299   {
00300     NVSG_TRACE();
00301     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00302     return( m_polygonOffset.factor );
00303   }
00304
00305   inline float FaceAttribute::getPolygonOffsetUnits() const
00306   {
00307     NVSG_TRACE();
00308     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00309     return( m_polygonOffset.units );
00310   }
00311
00312   inline void FaceAttribute::setTwoSidedLighting( bool enabled )
00313   {
00314     NVSG_TRACE();
00315     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00316     if ( m_twoSidedLighting != enabled )
00317     {
00318       m_twoSidedLighting = enabled;
00319       invalidateIncarnation();
00320     }
00321   }
00322
00323   inline bool FaceAttribute::isTwoSidedLighting() const
00324   {
00325     NVSG_TRACE();
00326     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00327     return( m_twoSidedLighting );
00328   }
00329
00330 } // namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


FileMapping.h File Reference

#include "nvsgcommon.h"
#include <map>
#include <vector>
#include <errno.h>

Include dependency graph for FileMapping.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:27:39 2008 for NVSGSDK by NVIDIA


FileMapping.h Source File

FileMapping.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include <map>
00017 #include <vector>
00018
00019 #if defined(LINUX)
00020 # include <errno.h>
00021 #endif
00022
00023 namespace nvutil
00024 {
00031   class FileMapping
00032   {
00033     public :
00046       NVSG_API unsigned int getLastError() const;
00047
00057       NVSG_API bool isValid() const;
00058
00072       NVSG_API void mapOut( const void * offsetPtr );
00073
00074     protected:
00078       NVSG_API FileMapping();
00079
00083       NVSG_API ~FileMapping();
00084
00091       NVSG_API void * mapIn( size_t offset, size_t numBytes );
00092
00093     private:
00094       struct ViewHeader
00095       {
00096         ViewHeader( size_t start, size_t size, void * base )
00097           : basePtr(base)
00098           , startOffset(start)
00099           , endOffset(start+size)
00100           , refCnt(0)
00101         {}
00102
00103         void  * basePtr;      // points to the beginning of the view
00104         size_t  startOffset;  // the view's start offset inside the mapped file
00105         size_t  endOffset;    // the view's 'past tht end' offset inside the mapped file
00106         int     refCnt;       // reflects if the view is in use or not
00107       };
00108
00109     protected:
00110       unsigned int                m_accessType;
00111 #if defined(_WIN32)
00112       HANDLE                      m_file;
00113       HANDLE                      m_fileMapping;
00114 #elif defined(LINUX)
00115       int                         m_file;
00116 #endif
00117       size_t                      m_mappingSize;
00118       bool                        m_isValid;
00119
00120     private :
00121       std::vector<ViewHeader*>    m_mappedViews;      // collection of currently mapped views
00122       std::map<void*,ViewHeader*> m_offsetPtrViewMap; // mapping offset pointers to their associated mapped view
00123   };
00124
00127   class ReadMapping : public FileMapping
00128   {
00129     public :
00140       NVSG_API ReadMapping( const std::string & fileName );
00141
00144       NVSG_API ~ReadMapping();
00145
00152       NVSG_API const void * mapIn( size_t offset, size_t numBytes );
00153   };
00154
00157   class WriteMapping : public FileMapping
00158   {
00159     public:
00171       NVSG_API WriteMapping( const std::string & fileName, size_t fileSize );
00172
00175       NVSG_API ~WriteMapping();
00176
00183       NVSG_API void * mapIn( size_t offset, size_t numBytes );
00184
00185     private :
00186       size_t  m_endOffset;    // last accessed offset in file => eof
00187   };
00188
00189
00190   inline unsigned int FileMapping::getLastError() const
00191   {
00192 #if defined(_WIN32)
00193     return( GetLastError() );
00194 #elif defined(LINUX)
00195     return( errno );
00196 #else
00197     NVSG_CTASSERT( false );
00198 #endif
00199   }
00200
00201   inline bool FileMapping::isValid() const
00202   {
00203     return( m_isValid );
00204   }
00205
00206
00207   inline const void * ReadMapping::mapIn( size_t offset, size_t numBytes )
00208   {
00209     return( FileMapping::mapIn( offset, numBytes ) );
00210   }
00211
00212 } // namespace nvutil
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


FlightCameraManipulator.h File Reference

#include "nvsgcommon.h"
#include "nvmath/nvmath.h"
#include "nvmath/Vecnt.h"
#include "nvui/Manipulator.h"
#include "nvui/KeyInput.h"
#include "nvui/MouseInput.h"

Include dependency graph for FlightCameraManipulator.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:27:39 2008 for NVSGSDK by NVIDIA


FlightCameraManipulator.h Source File

FlightCameraManipulator.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/nvmath.h"
00017 #include "nvmath/Vecnt.h"
00018 #include "nvui/Manipulator.h"
00019 #include "nvui/KeyInput.h"
00020 #include "nvui/MouseInput.h"
00021
00022 namespace nvui
00023 {
00050   class FlightCameraManipulator : public Manipulator
00051   {
00052     public:
00062       NVSG_API FlightCameraManipulator(UINT screenSizeX = 1280, UINT screenSizeY = 1024);
00063
00065       NVSG_API ~FlightCameraManipulator();
00066
00068       enum
00069       { _NO_BTN_KEY         = 0x0000
00070       , _LEFT_MOUSE_BTN     = 0x0001
00071       , _MIDDLE_MOUSE_BTN   = 0x0002
00072       , _W_KEY              = 0x0004
00073       , _S_KEY              = 0x0008
00074       };
00075
00098       NVSG_API virtual bool updateFrame();
00099
00103       NVSG_API virtual bool isActive();
00104
00112       NVSG_API void reset();
00113
00123       NVSG_API virtual bool isFly();
00124
00131       NVSG_API virtual bool isFlyForward();
00132
00139       NVSG_API virtual bool isFlyBackward();
00140
00148       void setWorldUpVector(nvmath::Vec3f up);
00149
00155       const nvmath::Vec3f& getWorldUpVector();
00156
00164       void setSpeedIncreaseFactor(float factor);
00165
00172       float getSpeedIncreaseFactor();
00173
00181       void setHSensitivity(float sensitivity);
00182
00190       float getHSensitivity();
00191
00200       void setVSensitivity(float sensitivity);
00201
00210       float getVSensitivity();
00211
00216       void setSpeed(float speed);
00217
00221       float getSpeed();
00222
00229       NVSG_API void keyDown(UINT key);
00230
00237       NVSG_API void keyUp( UINT key);
00238
00249       NVSG_API void mouseButtonDown(UINT btn, int x, int y);
00250
00261       NVSG_API void mouseButtonUp(UINT btn, int x, int y);
00262
00270       NVSG_API void mouseMotion(int x, int y);
00271
00272     protected:
00274       static NVSG_API const UINT FLYFORWARD;
00276       static NVSG_API const UINT FLYBACKWARD;
00278       static NVSG_API const UINT INCREASESPEED;
00280       static NVSG_API const UINT DECREASESPEED;
00282       static NVSG_API const float AREAOFPEACE;
00283
00284       UINT  m_ScreenSizeX;
00285       UINT  m_ScreenSizeY;
00286
00287       nvmath::Vec3f m_worldUpVector;
00288
00289       float m_speedIncreaseFactor;
00290       float m_hSensitivity;
00291       float m_vSensitivity;
00292
00293       float m_speed;
00294
00295       nvui::MouseInput m_mouseInput;
00296       nvui::KeyInput   m_keyInput;
00297
00298     protected:
00302       NVSG_API virtual bool fly();
00303   };
00304
00305   inline void FlightCameraManipulator::setWorldUpVector(nvmath::Vec3f up)
00306   {
00307     m_worldUpVector = up;
00308   }
00309
00310   inline const nvmath::Vec3f& FlightCameraManipulator::getWorldUpVector()
00311   {
00312     return m_worldUpVector;
00313   }
00314
00315   inline void FlightCameraManipulator::setSpeedIncreaseFactor(float factor)
00316   {
00317     NVSG_ASSERT(fabs(factor) > FLT_EPSILON);
00318     m_speedIncreaseFactor = factor;
00319   }
00320
00321   inline float FlightCameraManipulator::getSpeedIncreaseFactor()
00322   {
00323     return m_speedIncreaseFactor;
00324   }
00325
00326   inline void FlightCameraManipulator::setHSensitivity(float sensitivity)
00327   {
00328     m_hSensitivity = sensitivity;
00329   }
00330
00331   inline float FlightCameraManipulator::getHSensitivity()
00332   {
00333     return m_hSensitivity;
00334   }
00335
00336   inline void FlightCameraManipulator::setVSensitivity(float sensitivity)
00337   {
00338     m_vSensitivity = sensitivity;
00339   }
00340
00341   inline float FlightCameraManipulator::getVSensitivity()
00342   {
00343     return m_vSensitivity;
00344   }
00345
00346   inline void FlightCameraManipulator::setSpeed(float speed)
00347   {
00348     m_speed = speed;
00349   }
00350
00351   inline float FlightCameraManipulator::getSpeed()
00352   {
00353     return m_speed;
00354   }
00355
00356 } //  namespace nvui
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


FlipbookAnimation.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Animation.h"
#include "nvsg/Group.h"

Include dependency graph for FlipbookAnimation.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:40 2008 for NVSGSDK by NVIDIA


FlipbookAnimation.h Source File

FlipbookAnimation.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h" // commonly used stuff
00016 #include "nvsg/Animation.h"
00017 #include "nvsg/Group.h" // base class definition
00018
00019 namespace nvsg
00020 {
00027   class FlipbookAnimation : public Group
00028   {
00029     public:
00031       NVSG_API FlipbookAnimation();
00032
00034       NVSG_API FlipbookAnimation(const FlipbookAnimation& rhs);
00035
00037       NVSG_API virtual ~FlipbookAnimation();
00038
00042       NVSG_API IndexAnimationHandle * getAnimation() const;
00043
00052       NVSG_API void setAnimation( IndexAnimationHandle *animation );
00053
00057       NVSG_API virtual bool determineAnimationContainment() const;
00058
00066       NVSG_API FlipbookAnimation & operator=( const FlipbookAnimation & rhs );
00067
00081       NVSG_API virtual bool isEquivalent( const Object *p
00082                                         , bool ignoreNames
00083                                         , bool deepCompare ) const;
00084
00090       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00091
00094       NVSG_API NodeHandle * getCurrentChild() const;
00095
00096     private:
00097       IndexAnimationHandle  * m_animation;
00098   };
00099
00100   // - - - - - - - - - - - - - - - - - - - - - - - - -
00101   // inlines
00102   // - - - - - - - - - - - - - - - - - - - - - - - - -
00103
00104   inline IndexAnimationHandle * FlipbookAnimation::getAnimation() const
00105   {
00106     NVSG_TRACE();
00107     return( m_animation );
00108   }
00109 } //  namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


FramedAnimation.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Trafo.h"
#include "nvsg/Animation.h"
#include "nvsg/VertexAttribute.h"

Include dependency graph for FramedAnimation.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:40 2008 for NVSGSDK by NVIDIA


FramedAnimation.h Source File

FramedAnimation.h

Go to the documentation of this file.
00001  // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Trafo.h"
00017 #include "nvsg/Animation.h"
00018 #include "nvsg/VertexAttribute.h"
00019
00020 // Important note: extra qualifier required for name lookup!
00021 // from the ISO c++ spec (14.6.2, section 3):
00022 // "In the definition of a class template or in the definition of a member of such a
00023 // template that appears outside of the template definition, if a base class of this
00024 // template depends on a template-parameter, the base class scope is not examined
00025 // during name lookup until the class template is instantiated."
00026
00027 namespace nvsg
00028 {
00036   template<typename T> class FramedAnimation : public Animation<T>
00037   {
00038     public:
00041       FramedAnimation();
00042
00045       explicit FramedAnimation( const Animation<T> &rhs );
00046
00049       FramedAnimation( const FramedAnimation<T> &rhs );
00050
00053       virtual ~FramedAnimation();
00054
00058       void addStep( const T & value );
00059
00064       void addSteps( unsigned int numberOfSteps, const T * values );
00065
00070       virtual const T & getCurrentValue() const;
00071
00078       virtual T getStepValue( unsigned int step ) const;
00079
00083       const T * getStepValues() const;
00084
00091       virtual void replaceStep( unsigned int step, const T & value );
00092
00100       void replaceSteps( unsigned int step, unsigned int numberOfSteps, const T * values );
00101
00107       virtual void removeStep( unsigned int step );
00108
00115       void removeSteps( unsigned int step, unsigned int numberOfSteps );
00116
00120       void reserveSteps( unsigned int numberOfSteps );
00121
00128       virtual bool isCompatible( const Animation<T> * p ) const;
00129
00144       virtual bool isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const;
00145
00152       FramedAnimation<T> & operator=( const FramedAnimation<T> & rhs );
00153
00154     private:
00155       std::vector<T> m_values;
00156   };
00157
00158   template<typename T>
00159     inline FramedAnimation<T>::FramedAnimation( void )
00160   {
00161     NVSG_TRACE();
00162     NVSG_ASSERT( false );
00163   }
00164
00165   template<typename T>
00166     inline FramedAnimation<T>::~FramedAnimation( void )
00167   {
00168     NVSG_TRACE();
00169   }
00170
00171   template<>
00172     inline FramedAnimation<unsigned int>::FramedAnimation( void )
00173   { // explicit constructor
00174     NVSG_TRACE();
00175     //  See Important Note above !!
00176     this->m_objectCode = OC_FRAMEDINDEXANIMATION;
00177   }
00178
00179   template<>
00180     inline FramedAnimation<nvmath::Trafo>::FramedAnimation( void )
00181   { // explicit constructor
00182     NVSG_TRACE();
00183     //  See Important Note above !!
00184     this->m_objectCode = OC_FRAMEDTRAFOANIMATION;
00185   }
00186
00187   template<>
00188     inline FramedAnimation<VertexAttribute>::FramedAnimation( void )
00189   { // explicit constructor
00190     NVSG_TRACE();
00191     //  See Important Note above !!
00192     this->m_objectCode = OC_FRAMEDVERTEXATTRIBUTEANIMATION;
00193   }
00194
00195   template<typename T>
00196     inline FramedAnimation<T>::FramedAnimation( const Animation<T> &rhs )
00197   {
00198     NVSG_TRACE();
00199     NVSG_ASSERT( false );
00200   }
00201
00202   template<>
00203     inline FramedAnimation<unsigned int>::FramedAnimation( const Animation<unsigned int> &rhs )
00204     : Animation<unsigned int>(rhs)
00205   { // explicit constructor
00206     NVSG_TRACE();
00207     //  See Important Note above !!
00208     this->m_objectCode = OC_FRAMEDINDEXANIMATION;
00209   }
00210
00211   template<>
00212     inline FramedAnimation<nvmath::Trafo>::FramedAnimation( const Animation<nvmath::Trafo> &rhs )
00213     : Animation<nvmath::Trafo>(rhs)
00214   { // explicit constructor
00215     NVSG_TRACE();
00216     //  See Important Note above !!
00217     this->m_objectCode = OC_FRAMEDTRAFOANIMATION;
00218   }
00219
00220   template<>
00221     inline FramedAnimation<VertexAttribute>::FramedAnimation( const Animation<VertexAttribute> &rhs )
00222     : Animation<VertexAttribute>(rhs)
00223   { // explicit constructor
00224     NVSG_TRACE();
00225     //  See Important Note above !!
00226     this->m_objectCode = OC_FRAMEDVERTEXATTRIBUTEANIMATION;
00227   }
00228
00229   template<typename T>
00230     inline FramedAnimation<T>::FramedAnimation( const FramedAnimation<T> &rhs )
00231     : Animation<T>(rhs)
00232     , m_values(rhs.m_values)
00233   {
00234     NVSG_TRACE();
00235     //  See Important Note above !!
00236     this->m_objectCode=rhs.m_objectCode;
00237   }
00238
00239   template<>
00240     inline FramedAnimation<unsigned int>::FramedAnimation( const FramedAnimation<unsigned int> &rhs )
00241     : Animation<unsigned int>(rhs)
00242     , m_values(rhs.m_values)
00243   {
00244     NVSG_TRACE();
00245     //  See Important Note above !!
00246     this->m_objectCode = OC_FRAMEDINDEXANIMATION;
00247   }
00248
00249   template<>
00250     inline FramedAnimation<nvmath::Trafo>::FramedAnimation( const FramedAnimation<nvmath::Trafo> &rhs )
00251     : Animation<nvmath::Trafo>(rhs)
00252     , m_values(rhs.m_values)
00253   {
00254     NVSG_TRACE();
00255     //  See Important Note above !!
00256     this->m_objectCode = OC_FRAMEDTRAFOANIMATION;
00257   }
00258
00259   template<>
00260     inline FramedAnimation<VertexAttribute>::FramedAnimation( const FramedAnimation<VertexAttribute> &rhs )
00261     : Animation<VertexAttribute>(rhs)
00262     , m_values(rhs.m_values)
00263   {
00264     NVSG_TRACE();
00265     //  See Important Note above !!
00266     this->m_objectCode = OC_FRAMEDVERTEXATTRIBUTEANIMATION;
00267   }
00268
00269   template<typename T>
00270   inline void FramedAnimation<T>::addStep( const T & value )
00271   {
00272     NVSG_TRACE();
00273     m_values.push_back( value );
00274     NVSG_ASSERT( m_values.size() <= UINT_MAX );
00275     //  See Important Note above !!
00276     this->setNumberOfSteps( static_cast<unsigned int>(m_values.size()) );
00277   }
00278
00279   template<typename T>
00280   inline void FramedAnimation<T>::addSteps( unsigned int numberOfSteps, const T * values )
00281   {
00282     m_values.insert( m_values.end(), values, values + numberOfSteps );
00283     NVSG_ASSERT( m_values.size() <= UINT_MAX );
00284     //  See Important Note above !!
00285     this->setNumberOfSteps( static_cast<unsigned int>(m_values.size()) );
00286   }
00287
00288   template<typename T>
00289   inline const T & FramedAnimation<T>::getCurrentValue() const
00290   {
00291     NVSG_TRACE();
00292     return( m_values[this->getCurrentStep()] );
00293   }
00294
00295   template<typename T>
00296   inline T FramedAnimation<T>::getStepValue( unsigned int step ) const
00297   {
00298     NVSG_TRACE();
00299     NVSG_ASSERT( step < m_values.size() );
00300     return( m_values[step] );
00301   }
00302
00303   template<typename T>
00304   inline const T * FramedAnimation<T>::getStepValues() const
00305   {
00306     NVSG_TRACE();
00307     return( m_values.empty() ? NULL : &m_values[0] );
00308   }
00309
00310   template<typename T>
00311   inline void FramedAnimation<T>::replaceStep( unsigned int step, const T & value )
00312   {
00313     NVSG_TRACE();
00314     NVSG_ASSERT( step < m_values.size() );
00315     m_values[step] = value;
00316     this->invalidateIncarnation();
00317   }
00318
00319   template<typename T>
00320   inline void FramedAnimation<T>::replaceSteps( unsigned int step, unsigned int numberOfSteps, const T * values )
00321   {
00322     NVSG_TRACE();
00323     NVSG_ASSERT( step + numberOfSteps < m_values.size() );
00324     for ( unsigned int i=0, j=step ; i<numberOfSteps ; i++, j++ )
00325     {
00326       m_values[j] = values[i];
00327     }
00328     this->invalidateIncarnation();
00329   }
00330
00331   template<typename T>
00332   inline void FramedAnimation<T>::removeStep( unsigned int step )
00333   {
00334     NVSG_TRACE();
00335     NVSG_ASSERT( step < m_values.size() );
00336     m_values.erase( m_values.begin() + step );
00337     this->invalidateIncarnation();
00338   }
00339
00340   template<typename T>
00341   inline void FramedAnimation<T>::removeSteps( unsigned int step, unsigned int numberOfSteps )
00342   {
00343     NVSG_TRACE();
00344     NVSG_ASSERT( step + numberOfSteps < m_values.size() );
00345     m_values.erase( m_values.begin() + step, m_values.begin() + step + numberOfSteps );
00346     this->invalidateIncarnation();
00347   }
00348
00349   template<typename T>
00350   inline void FramedAnimation<T>::reserveSteps( unsigned int numberOfSteps )
00351   {
00352     NVSG_TRACE();
00353     m_values.reserve( numberOfSteps );
00354   }
00355
00356   template<typename T>
00357   inline bool FramedAnimation<T>::isCompatible( const Animation<T> * p ) const
00358   {
00359     // two FramedAnimations are compatible, if they're Animation parts are equivalent
00360     return( Animation<T>::isEquivalent( p, true, true ) );
00361   }
00362
00363   template<typename T>
00364   inline bool FramedAnimation<T>::isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const
00365   {
00366     bool equi = Animation<T>::isEquivalent( p, ignoreNames, deepCompare );
00367     if ( equi )
00368     {
00369       const FramedAnimation<T> * fat = dynamic_cast<const FramedAnimation<T> *>(p);
00370       equi = ( m_values == fat->m_values );
00371     }
00372     return( equi );
00373   }
00374
00375   template<typename T>
00376     inline FramedAnimation<T> & FramedAnimation<T>::operator=(const FramedAnimation<T> & rhs)
00377   {
00378     NVSG_TRACE();
00379     if (&rhs != this)
00380     {
00381       Animation<T>::operator=(rhs);
00382       m_values = rhs.m_values;
00383     }
00384     return *this;
00385   }
00386 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


FrustumCullTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CullData.h"
#include "nvtraverser/CullTraverser.h"

Include dependency graph for FrustumCullTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:40 2008 for NVSGSDK by NVIDIA


FrustumCullTraverser.h Source File

FrustumCullTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/CullData.h"
00017 #include "nvtraverser/CullTraverser.h"
00018
00019 namespace nvtraverser
00020 {
00029   class FrustumCullTraverser : public CullTraverser
00030   {
00031     public:
00034       NVSG_API FrustumCullTraverser(void);
00035
00036     protected:
00040       NVSG_API virtual ~FrustumCullTraverser(void);
00041
00042       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00043
00051       NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p );
00052
00058       NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p );
00059
00065       NVSG_API virtual nvsg::CullCode cullCode( const nvmath::Sphere3f & bs ) const;
00066
00067     private:
00068       const nvsg::Camera  * m_camera;
00069       std::stack<float>     m_scaleFactors;
00070   };
00071
00072 }
00073
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


GeoNode.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Node.h"
#include "nvsg/VertexAttributeSet.h"
#include <vector>

Include dependency graph for GeoNode.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:41 2008 for NVSGSDK by NVIDIA


GeoNode.h Source File

GeoNode.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h" // commonly used stuff
00016 #include "nvsg/Node.h" // base class definition
00017 // additional dependencies
00018 #include "nvsg/VertexAttributeSet.h"
00019 #include <vector>
00020
00021 namespace nvsg
00022 {
00034   class GeoNode : public Node
00035   {
00036     public:
00039       NVSG_API GeoNode();
00040
00048       NVSG_API explicit GeoNode( const Node &rhs );
00049
00052       NVSG_API GeoNode( const GeoNode& rhs );
00053
00056       NVSG_API virtual ~GeoNode();
00057
00074       NVSG_API unsigned int getNumberOfGeometries() const;
00075
00084       NVSG_API unsigned int getNumberOfDrawables( unsigned int index ) const;
00085
00104       NVSG_API void addGeometry( DrawableHandle * drawable, StateSetHandle * stateSet = NULL );
00105
00114       NVSG_API bool removeGeometry( StateSetHandle * stateSet );
00115
00128       NVSG_API bool removeGeometry( DrawableHandle * drawable );
00129
00136       NVSG_API void clearGeometries();
00137
00152       NVSG_API void replaceStateSet( StateSetHandle * newStateSet, StateSetHandle * oldStateSet );
00153
00170       NVSG_API void replaceDrawable( DrawableHandle * newDrawable, DrawableHandle * oldDrawable );
00171
00181       NVSG_API StateSetHandle * getStateSet( unsigned int index ) const;
00182
00191       NVSG_API StateSetHandle * getStateSet( DrawableHandle * drawable ) const;
00192
00226       NVSG_API DrawableHandle * getDrawable( unsigned int geometryIndex, unsigned int drawableIndex ) const;
00227
00229       NVSG_API void clearTexCoords( unsigned int tu = 0 );
00230
00243       NVSG_API virtual bool isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const;
00244
00252       NVSG_API GeoNode & operator=(const GeoNode & rhs);
00253
00260       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00261
00262     protected:
00263
00269       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00270
00276       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00277
00284       NVSG_API virtual bool determineTransparencyContainment() const;
00285
00290       NVSG_API virtual bool determineCgFxContainment() const;
00291
00294       NVSG_API virtual bool determineAnimationContainment() const;
00295
00296     private:
00297
00298       struct Geometry
00299       {
00300         Geometry() : m_stateSet(NULL) {}
00301         explicit Geometry(StateSetHandle* stateSet) : m_stateSet(stateSet) {}
00302
00303         StateSetHandle                * m_stateSet;
00304         std::vector<DrawableHandle *>   m_drawables;
00305       };
00306
00307     private:
00308
00309       // query zero-based positions of a StateSet or a Drawable, resp.
00310       unsigned int getGeometryIndex(StateSetHandle * stateSet) const;
00311       unsigned int getGeometryIndex(DrawableHandle * drawable) const;
00312
00313       // invalidate caches on insertion or removal of a StateSet or Drawable, resp.
00314       void invalidateCaches( StateSetHandle * stateSet, bool insert );
00315       void invalidateCaches( DrawableHandle * drawable, bool insert );
00316
00317       // helper with copying geometries
00318       void copyGeometries(const std::vector<Geometry> & from);
00319
00320       void referenceDrawable(DrawableHandle* drawable);
00321       void unreferenceDrawable(DrawableHandle* drawable);
00322
00323       void referenceStateSet(StateSetHandle* stateSet);
00324       void unreferenceStateSet(StateSetHandle* stateSet);
00325
00326       void unreferenceGeometry(Geometry& geometry);
00327
00328     private:
00329       std::vector<Geometry> m_geometries;
00330   };
00331
00348   NVSG_API void calculateTangentSpace( GeoNode * gn
00349                                      , unsigned int tu = 0
00350                                      , unsigned int tg = 1
00351                                      , unsigned int bn = 2
00352                                      , bool overwrite = true );
00353
00359   NVSG_API void generateNormals( GeoNode * gn );
00360
00374   NVSG_API void generateTexCoords( GeoNode * gn
00375                                  , TextureCoordType tct
00376                                  , unsigned int tu = 0
00377                                  , bool overwrite = true );
00378
00379   // - - - - - - - - - - - - - - - - - - - - - - - - -
00380   // inlines
00381   // - - - - - - - - - - - - - - - - - - - - - - - - -
00382
00383   inline DrawableHandle * GeoNode::getDrawable(unsigned int geometryIndex, unsigned int drawableIndex) const
00384   {
00385     NVSG_TRACE();
00386     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00387     NVSG_ASSERT(geometryIndex<m_geometries.size());
00388     NVSG_ASSERT(drawableIndex<m_geometries[geometryIndex].m_drawables.size());
00389     return( m_geometries[geometryIndex].m_drawables[drawableIndex] );
00390   }
00391
00392   inline unsigned int GeoNode::getNumberOfDrawables(unsigned int geometryIndex) const
00393   {
00394     NVSG_TRACE();
00395     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00396     NVSG_ASSERT(geometryIndex<m_geometries.size());
00397     NVSG_ASSERT( m_geometries[geometryIndex].m_drawables.size() <= UINT_MAX );
00398     return( static_cast<unsigned int>(m_geometries[geometryIndex].m_drawables.size()) );
00399   }
00400
00401   inline unsigned int GeoNode::getNumberOfGeometries() const
00402   {
00403     NVSG_TRACE();
00404     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00405     NVSG_ASSERT( m_geometries.size() <= UINT_MAX );
00406     return( static_cast<unsigned int>(m_geometries.size()) );
00407   }
00408
00409   inline StateSetHandle * GeoNode::getStateSet( unsigned int geometryIndex ) const
00410   {
00411     NVSG_TRACE();
00412     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00413     NVSG_ASSERT(geometryIndex<m_geometries.size());
00414     return( m_geometries[geometryIndex].m_stateSet );
00415   }
00416
00417   inline StateSetHandle * GeoNode::getStateSet( DrawableHandle * drawable ) const
00418   {
00419     NVSG_TRACE();
00420     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00421     NVSG_ASSERT( drawable );
00422     unsigned int gi = getGeometryIndex( drawable );
00423     return( ( gi != ~0 ) ? m_geometries[gi].m_stateSet : NULL );
00424   }
00425
00426 } //  namespace nvsg
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


GLContext.h File Reference

#include "nvsgcommon.h"
#include "nvgl/nvgl.h"
#include "nvgl/GLStatistics.h"
#include "nvmath/Vecnt.h"
#include "nvutil/RCObject.h"
#include "nvsg/TextureAttribute.h"
#include "nvsg/TextureImage.h"
#include "nvsg/CgFx.h"
#include <map>
#include <stack>
#include <string>
#include <algorithm>
#include <utility>
#include "nvgl/GLFunctions.h"
#include "nvgl/GLObjects.h"

Include dependency graph for GLContext.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvgl

Defines

#define | GET_CURRENT_DC() WGLGetCurrentDC()
Get the current device context.

#define | GET_CURRENT_RC() WGLGetCurrentContext()
Get the current render context.

#define | MAKE_CURRENT(DC, RC) WGLMakeCurrent(DC,RC)
Make the given device context and render context current.

#define | NVSG_TIF_INVALID 0
Invalid texture format.

#define | NVSG_CACHE_FRONT 0
ID for the front caches.

#define | NVSG_CACHE_BACK 1
ID for the back caches.

#define | BUFFER_OFFSET(i) ((char*)NULL + (i))
Helper macro with buffer-usage.

Typedefs

typedef HDC | DEVICE_CONTEXT
Helper type that maps to HDC on Windows and Drawable on Linux.

typedef HGLRC | RENDER_CONTEXT
Helper type that maps to HGLRC on Windows and GLXContext on Linux.

Detailed Description

Define Documentation

#define GET_CURRENT_DC ( ) WGLGetCurrentDC()

Get the current device context.

This is a helper macro defined for both Windows and Linux. It maps to either WGLGetCurrentDC or GLXGetCurrentDrawable.

#define GET_CURRENT_RC ( ) WGLGetCurrentContext()

Get the current render context.

This is a helper macro defined for both Windows and Linux. It maps to either WGLGetCurrentContext or GLXGetCurrentContext.

#define MAKE_CURRENT | ( | DC,
 |  | RC | ) | WGLMakeCurrent(DC,RC)

Make the given device context and render context current.

This is a helper macro defined for both Windows and Linux. It maps to either WGLMakeCurrent or GLXMakeCurrent.

#define NVSG_TIF_INVALID 0

Invalid texture format.

#define NVSG_CACHE_FRONT 0

ID for the front caches.

#define NVSG_CACHE_BACK 1

ID for the back caches.

#define BUFFER_OFFSET ( i ) ((char*)NULL + (i))

Helper macro with buffer-usage.

Typedef Documentation

typedef HDC DEVICE_CONTEXT

Helper type that maps to HDC on Windows and Drawable on Linux.

typedef HGLRC RENDER_CONTEXT

Helper type that maps to HGLRC on Windows and GLXContext on Linux.

Generated on Tue Jan 15 10:27:41 2008 for NVSGSDK by NVIDIA


GLContext.h Source File

GLContext.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvgl/nvgl.h"
00017 #include "nvgl/GLStatistics.h"
00018 #include "nvmath/Vecnt.h"
00019 #include "nvutil/RCObject.h"
00020 #include "nvsg/TextureAttribute.h"
00021 #include "nvsg/TextureImage.h"
00022 #include "nvsg/CgFx.h"
00023 #include <map>
00024 #include <stack>
00025 #include <string>
00026 #include <algorithm>
00027 #include <utility>
00028
00029
00030 // common device context helper data types for Windows and Linux
00031 #if defined(_WIN32)
00032 typedef HDC   DEVICE_CONTEXT;
00033 typedef HGLRC RENDER_CONTEXT;
00034 #elif defined(LINUX)
00035 typedef Drawable   DEVICE_CONTEXT;
00036 typedef GLXContext RENDER_CONTEXT;
00037 #endif
00038
00039 namespace nvsg
00040 {
00041   class DALHost;
00042 }
00043
00044 namespace nvgl
00045 {
00046 class GLFunctions;
00047 class GLObjects;
00048 struct GLTextureCache;
00049 struct GLDisplayListCache;
00050 struct GLArrayBufferCache;
00051 struct GLElementArrayBufferCache;
00052 struct GLPixelBufferCache;
00053
00054 #if !defined(DOXYGEN_IGNORE)
00055 typedef void (*PFNUPLOADTEXTUREPROC)(GLint, GLint, GLint, nvsg::TextureImage*, GLTextureCache*);
00056 #endif // DOXYGEN_IGNORE
00057
00058 // common device context helper function for Windows and Linux
00059 #if defined(_WIN32)
00060
00061 class WGLFunctions;
00062
00064
00065 # define GET_CURRENT_DC()    WGLGetCurrentDC()
00066
00067
00068 # define GET_CURRENT_RC()    WGLGetCurrentContext()
00069
00070
00071 # define MAKE_CURRENT(DC,RC) WGLMakeCurrent(DC,RC)
00072
00073 #elif defined(LINUX)
00074
00075 class GLXFunctions;
00076
00077 # define GET_CURRENT_DC()    GLXGetCurrentDrawable()
00078 # define GET_CURRENT_RC()    GLXGetCurrentContext()
00079 # define MAKE_CURRENT(DC,RC) GLXMakeCurrent(glContext()->getDisplay(),DC,RC)
00080
00081 #else
00082
00083 # error Unsupported Operating System!
00084
00085 #endif
00086
00087 #if !defined(DOXYGEN_IGNORE)
00088 # define GL_CACHING
00089 # if defined( GL_CACHING )
00090 #  define GL_SUPPORT_RESET
00091 # endif
00092 #endif // DOXYGEN_IGNORE
00093
00095 struct GLTexImageFmt
00096 {
00097   GLint intFmt;
00098   GLint usrFmt;
00099   GLint type;
00100   GLint uploadHint;
00101 };
00102
00104 struct NVSGTexImageFmt
00105 {
00106   GLint fixedPtFmt;
00107   GLint floatFmt;
00108   GLint integerFmt;
00109   GLint compressedFmt;
00110   GLint nonLinearFmt;
00111   GLint usrFmt;
00112   GLint type;
00113   GLint uploadHint;
00114 };
00115
00116 #define NVSG_TIF_INVALID 0
00117
00118 #define NVSG_CACHE_FRONT  0
00119 #define NVSG_CACHE_BACK   1
00120
00121 // provide zero-based mapping of buffer bindings
00122 enum
00123 {
00124   // vertex buffer targets
00125   NVSG_ARRAY_BUFFER = 0,
00126   NVSG_FIRST_VERTEX_BUFFER = NVSG_ARRAY_BUFFER,
00127   NVSG_ELEMENT_ARRAY_BUFFER,
00128   NVSG_LAST_VERTEX_BUFFER = NVSG_ELEMENT_ARRAY_BUFFER,
00129   // pixel buffer targets
00130   NVSG_PIXEL_PACK_BUFFER,
00131   NVSG_FIRST_PIXEL_BUFFER = NVSG_PIXEL_PACK_BUFFER,
00132   NVSG_PIXEL_UNPACK_BUFFER,
00133   NVSG_LAST_PIXEL_BUFFER = NVSG_PIXEL_UNPACK_BUFFER,
00134
00135   NVSG_NUM_VERTEX_BUFFERS = NVSG_LAST_VERTEX_BUFFER - NVSG_FIRST_VERTEX_BUFFER + 1,
00136   NVSG_NUM_PIXEL_BUFFERS  = NVSG_LAST_PIXEL_BUFFER - NVSG_FIRST_PIXEL_BUFFER + 1,
00137   NVSG_NUM_BUFFERS = NVSG_NUM_VERTEX_BUFFERS + NVSG_NUM_PIXEL_BUFFERS
00138 };
00139
00140 #define BUFFER_OFFSET(i) ((char*)NULL + (i))
00141
00142
00143
00156 class GLContext
00157 {
00158   friend NVSG_API void GLAccum( GLenum op, GLfloat value );
00159   friend NVSG_API void GLActiveStencilFace( GLenum face );
00160   friend NVSG_API void GLActiveTexture( GLenum texture );
00161   friend NVSG_API void GLActiveVarying( GLuint program, const GLchar *name );
00162   friend NVSG_API void GLAddSwapHintRect( GLint x, GLint y, GLsizei width, GLsizei height );
00163   friend NVSG_API void GLAlphaFunc( GLenum func, GLclampf ref );
00164   friend NVSG_API GLboolean GLAreProgramsResident( GLsizei n, const GLuint *programs, GLboolean *residences );
00165   friend NVSG_API GLboolean GLAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences );
00166   friend NVSG_API void GLArrayElement( GLint i );
00167   friend NVSG_API void GLAttachObject( GLhandleARB containerObj, GLhandleARB attachedObj );
00168   friend NVSG_API void GLAttachShader( GLuint program, GLuint shader );
00169   friend NVSG_API void GLBegin( GLenum mode );
00170   friend NVSG_API void GLBeginOcclusionQuery( GLuint id );
00171   friend NVSG_API void GLBeginQuery( GLenum target, GLuint id );
00172   friend NVSG_API void GLBeginTransformFeedback( GLenum primitiveMode );
00173   friend NVSG_API void GLBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
00174   friend NVSG_API void GLBindArraySet( GLuint buffer );
00175   friend NVSG_API void GLBindAttribLocation( GLuint program, GLuint index, const GLchar *name );
00176   friend NVSG_API void GLBindBuffer(GLenum target, GLuint id);
00177   friend NVSG_API void GLBindBufferBase( GLenum target, GLuint index, GLuint buffer );
00178   friend NVSG_API void GLBindBufferOffset( GLenum target, GLuint index, GLuint buffer, GLintptr offset );
00179   friend NVSG_API void GLBindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size );
00180   friend NVSG_API void GLBindFragDataLocation( GLuint program, GLuint color, const GLchar *name );
00181   friend NVSG_API void GLBindProgram( GLenum target, GLuint id );
00182   friend NVSG_API void GLBindTexture( GLenum target, GLuint texture );
00183   friend NVSG_API void GLBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap );
00184   friend NVSG_API void GLBlendEquation( GLenum mode );
00185   friend NVSG_API void GLBlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha );
00186   friend NVSG_API void GLBlendFunc( GLenum sfactor, GLenum dfactor );
00187   friend NVSG_API void GLBlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha );
00188   friend NVSG_API void GLBlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter );
00189   friend NVSG_API void GLBufferData( GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage );
00190   friend NVSG_API void GLBufferSubData( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data );
00191   friend NVSG_API void GLCallList( GLuint list );
00192   friend NVSG_API void GLCallLists( GLsizei n, GLenum type, const GLvoid *lists );
00193   friend NVSG_API void GLClampColor( GLenum target, GLenum clamp );
00194   friend NVSG_API void GLClear( GLbitfield mask );
00195   friend NVSG_API void GLClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
00196   friend NVSG_API void GLClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
00197   friend NVSG_API void GLClearColorIi( GLint red, GLint green, GLint blue, GLint alpha );
00198   friend NVSG_API void GLClearColorIui( GLuint red, GLuint green, GLuint blue, GLuint alpha );
00199   friend NVSG_API void GLClearDepth( GLclampd depth );
00200   friend NVSG_API void GLClearDepthd( GLdouble depth );
00201   friend NVSG_API void GLClearIndex( GLfloat c );
00202   friend NVSG_API void GLClearStencil( GLint s );
00203   friend NVSG_API void GLClientActiveTexture( GLenum texture );
00204   friend NVSG_API void GLClipPlane( GLenum plane, const GLdouble *equation );
00205   friend NVSG_API void GLColor3b( GLbyte red, GLbyte green, GLbyte blue );
00206   friend NVSG_API void GLColor3bv( const GLbyte *v );
00207   friend NVSG_API void GLColor3d( GLdouble red, GLdouble green, GLdouble blue );
00208   friend NVSG_API void GLColor3dv( const GLdouble *v );
00209   friend NVSG_API void GLColor3f( GLfloat red, GLfloat green, GLfloat blue );
00210   friend NVSG_API void GLColor3fv( const GLfloat * v );
00211   friend NVSG_API void GLColor3h( GLhalf red, GLhalf green, GLhalf blue );
00212   friend NVSG_API void GLColor3hv( const GLhalf * v );
00213   friend NVSG_API void GLColor3i( GLint red, GLint green, GLint blue );
00214   friend NVSG_API void GLColor3iv( const GLint * v );
00215   friend NVSG_API void GLColor3s( GLshort red, GLshort green, GLshort blue );
00216   friend NVSG_API void GLColor3sv( const GLshort * v );
00217   friend NVSG_API void GLColor3ub( GLubyte red, GLubyte green, GLubyte blue );
00218   friend NVSG_API void GLColor3ubv( const GLubyte * v );
00219   friend NVSG_API void GLColor3ui( GLuint red, GLuint green, GLuint blue );
00220   friend NVSG_API void GLColor3uiv( const GLuint * v );
00221   friend NVSG_API void GLColor3us( GLushort red, GLushort green, GLushort blue );
00222   friend NVSG_API void GLColor3usv( const GLushort * v );
00223   friend NVSG_API void GLColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha );
00224   friend NVSG_API void GLColor4bv( const GLbyte * v );
00225   friend NVSG_API void GLColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha );
00226   friend NVSG_API void GLColor4dv( const GLdouble * v );
00227   friend NVSG_API void GLColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
00228   friend NVSG_API void GLColor4fv( const GLfloat * v );
00229   friend NVSG_API void GLColor4h( GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha );
00230   friend NVSG_API void GLColor4hv( const GLhalf * v );
00231   friend NVSG_API void GLColor4i( GLint red, GLint green, GLint blue, GLint alpha );
00232   friend NVSG_API void GLColor4iv( const GLint * v );
00233   friend NVSG_API void GLColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha );
00234   friend NVSG_API void GLColor4sv( const GLshort * v );
00235   friend NVSG_API void GLColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
00236   friend NVSG_API void GLColor4ubv( const GLubyte * v );
00237   friend NVSG_API void GLColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha );
00238   friend NVSG_API void GLColor4uiv( const GLuint * v );
00239   friend NVSG_API void GLColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha );
00240   friend NVSG_API void GLColor4usv( const GLushort * v );
00241   friend NVSG_API void GLColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
00242   friend NVSG_API void GLColorMaskIndexed( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a );
00243   friend NVSG_API void GLColorMaterial( GLenum face, GLenum mode );
00244   friend NVSG_API void GLColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00245   friend NVSG_API void GLColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data );
00246   friend NVSG_API void GLColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table );
00247   friend NVSG_API void GLColorTableParameterfv( GLenum target, GLenum pname, const GLfloat *params );
00248   friend NVSG_API void GLColorTableParameteriv( GLenum target, GLenum pname, const GLint *params );
00249   friend NVSG_API void GLCombinerInput( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage );
00250   friend NVSG_API void GLCombinerOutput( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum );
00251   friend NVSG_API void GLCombinerParameterf( GLenum pname, GLfloat param );
00252   friend NVSG_API void GLCombinerParameterfv( GLenum pname, const GLfloat *params );
00253   friend NVSG_API void GLCombinerParameteri( GLenum pname, GLint param );
00254   friend NVSG_API void GLCombinerParameteriv( GLenum pname, const GLint *params );
00255   friend NVSG_API void GLCombinerStageParameterfv( GLenum stage, GLenum pname, const GLfloat *params );
00256   friend NVSG_API void GLCompileShader( GLuint shader );
00257   friend NVSG_API void GLCompressedTexImage1D( GLenum target, int level, GLenum internalformat, GLsizei width, int border, GLsizei imageSize, const void *data );
00258   friend NVSG_API void GLCompressedTexImage2D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, int border, GLsizei imageSize, const void *data );
00259   friend NVSG_API void GLCompressedTexImage3D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLsizei imageSize, const void *data );
00260   friend NVSG_API void GLCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data );
00261   friend NVSG_API void GLCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data );
00262   friend NVSG_API void GLCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data );
00263   friend NVSG_API void GLConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image );
00264   friend NVSG_API void GLConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image );
00265   friend NVSG_API void GLConvolutionParameterf( GLenum target, GLenum pname, GLfloat params );
00266   friend NVSG_API void GLConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params );
00267   friend NVSG_API void GLConvolutionParameteri( GLenum target, GLenum pname, GLint params );
00268   friend NVSG_API void GLConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params );
00269   friend NVSG_API void GLCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width );
00270   friend NVSG_API void GLCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
00271   friend NVSG_API void GLCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
00272   friend NVSG_API void GLCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height );
00273   friend NVSG_API void GLCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type );
00274   friend NVSG_API void GLCopyTexImage1D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border );
00275   friend NVSG_API void GLCopyTexImage2D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border );
00276   friend NVSG_API void GLCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width );
00277   friend NVSG_API void GLCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height );
00278   friend NVSG_API void GLCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
00279   friend NVSG_API GLuint GLCreateProgram();
00280   friend NVSG_API GLhandleARB GLCreateProgramObject();
00281   friend NVSG_API GLuint GLCreateShader( GLenum type );
00282   friend NVSG_API GLhandleARB GLCreateShaderObject( GLenum shaderType );
00283   friend NVSG_API void GLCullFace( GLenum mode );
00284   friend NVSG_API void GLCullFaceLock( GLenum mode );
00285   friend NVSG_API void GLCullFaceUnlock( GLenum mode );
00286   friend NVSG_API void GLDeleteArraySets( GLsizei n, const GLuint *buffers );
00287   friend NVSG_API void GLDeleteBuffers( GLsizei n, const GLuint *buffers );
00288   friend NVSG_API void GLDeleteFences( GLsizei n, const GLuint *fences );
00289   friend NVSG_API void GLDeleteLists( GLuint list, GLsizei range );
00290   friend NVSG_API void GLDeleteObject( GLhandleARB obj );
00291   friend NVSG_API void GLDeleteOcclusionQueries( GLsizei n, const GLuint *ids );
00292   friend NVSG_API void GLDeleteProgram( GLuint program );
00293   friend NVSG_API void GLDeletePrograms( GLsizei n, const GLuint *ids );
00294   friend NVSG_API void GLDeleteQueries( GLsizei n, const GLuint *ids );
00295   friend NVSG_API void GLDeleteShader( GLuint shader );
00296   friend NVSG_API void GLDeleteTextures( GLsizei n, const GLuint *textures );
00297   friend NVSG_API void GLDepthBounds( GLclampd zmin, GLclampd zmax );
00298   friend NVSG_API void GLDepthBoundsd( GLdouble zmin, GLdouble zmax );
00299   friend NVSG_API void GLDepthFunc( GLenum func );
00300   friend NVSG_API void GLDepthMask( GLboolean flag );
00301   friend NVSG_API void GLDepthRange( GLclampd znear, GLclampd zfar );
00302   friend NVSG_API void GLDepthRanged( GLdouble zNear, GLdouble zFar );
00303   friend NVSG_API void GLDetachObject( GLhandleARB containerObj, GLhandleARB attachedObj );
00304   friend NVSG_API void GLDetachShader( GLuint program, GLuint shader );
00305   friend NVSG_API void GLDisable( GLenum cap );
00306   friend NVSG_API void GLDisableAlphaTest( void );
00307   friend NVSG_API void GLDisableAutoNormal( void );
00308   friend NVSG_API void GLDisableBlend( void );
00309   friend NVSG_API void GLDisableClientState( GLenum array );
00310   friend NVSG_API void GLDisableClipPlane( GLenum plane );
00311   friend NVSG_API void GLDisableColorArray( void );
00312   friend NVSG_API void GLDisableColorLogicOp( void );
00313   friend NVSG_API void GLDisableColorMaterial( void );
00314   friend NVSG_API void GLDisableCullFace( void );
00315   friend NVSG_API void GLDisableCullFaceLock( void );
00316   friend NVSG_API void GLDisableCullFaceUnlock( void );
00317   friend NVSG_API void GLDisableDepthTest( void );
00318   friend NVSG_API void GLDisableFogCoordinateArray( void );
00319   friend NVSG_API void GLDisableNormalArray( void );
00320   friend NVSG_API void GLDisableDither( void );
00321   friend NVSG_API void GLDisableFog( void );
00322   friend NVSG_API void GLDisableIndexed( GLenum target, GLuint index );
00323   friend NVSG_API void GLDisableLight( GLenum light );
00324   friend NVSG_API void GLDisableLighting( void );
00325   friend NVSG_API void GLDisableLightingLock( void );
00326   friend NVSG_API void GLDisableLightingUnlock( void );
00327   friend NVSG_API void GLDisableLineSmooth( void );
00328   friend NVSG_API void GLDisableLineStipple( void );
00329   friend NVSG_API void GLDisableLogicOp( void );
00330   friend NVSG_API void GLDisableNormalize( void );
00331   friend NVSG_API void GLDisablePointSmooth( void );
00332   friend NVSG_API void GLDisablePolygonOffsetFill( void );
00333   friend NVSG_API void GLDisablePolygonOffsetLine( void );
00334   friend NVSG_API void GLDisablePolygonOffsetPoint( void );
00335   friend NVSG_API void GLDisablePolygonSmooth( void );
00336   friend NVSG_API void GLDisablePolygonStipple( void );
00337   friend NVSG_API void GLDisableScissorTest( void );
00338   friend NVSG_API void GLDisableSecondaryColorArray( void );
00339   friend NVSG_API void GLDisableStencilTest( void );
00340   friend NVSG_API void GLDisableTexture( GLenum target );
00341   friend NVSG_API void GLDisableTextureCoordArray( void );
00342   friend NVSG_API void GLDisableTextureGen( GLenum target );
00343   friend NVSG_API void GLDisableVertexArray( void );
00344   friend NVSG_API void GLDisableVertexAttribArray( GLuint index );
00345   friend NVSG_API void GLDrawArrays( GLenum mode, GLint first, GLsizei count );
00346   friend NVSG_API void GLDrawArraysInstanced( GLenum mode, GLint start, GLsizei count, GLsizei primcount );
00347   friend NVSG_API void GLDrawBuffer( GLenum mode );
00348   friend NVSG_API void GLDrawBuffers( GLsizei n, const GLenum *bufs );
00349   friend NVSG_API void GLDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices );
00350   friend NVSG_API void GLDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount );
00351   friend NVSG_API void GLDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels );
00352   friend NVSG_API void GLDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
00353   friend NVSG_API void GLEdgeFlagPointer( GLsizei stride, const GLboolean *pointer );
00354   friend NVSG_API void GLEdgeFlag( GLboolean flag );
00355   friend NVSG_API void GLEdgeFlagv( const GLboolean *flag );
00356   friend NVSG_API void GLEnable( GLenum cap );
00357   friend NVSG_API void GLEnableAlphaTest( void );
00358   friend NVSG_API void GLEnableAutoNormal( void );
00359   friend NVSG_API void GLEnableBlend( void );
00360   friend NVSG_API void GLEnableClientState( GLenum array );
00361   friend NVSG_API void GLEnableClipPlane( GLenum plane );
00362   friend NVSG_API void GLEnableColorArray( void );
00363   friend NVSG_API void GLEnableColorLogicOp( void );
00364   friend NVSG_API void GLEnableColorMaterial( void );
00365   friend NVSG_API void GLEnableCullFace( void );
00366   friend NVSG_API void GLEnableCullFaceLock( void );
00367   friend NVSG_API void GLEnableCullFaceUnlock( void );
00368   friend NVSG_API void GLEnableDepthTest( void );
00369   friend NVSG_API void GLEnableFogCoordinateArray( void );
00370   friend NVSG_API void GLEnableDither( void );
00371   friend NVSG_API void GLEnableFog( void );
00372   friend NVSG_API void GLEnableIndexed( GLenum target, GLuint index );
00373   friend NVSG_API void GLEnableLight( GLenum light );
00374   friend NVSG_API void GLEnableLighting( void );
00375   friend NVSG_API void GLEnableLineSmooth( void );
00376   friend NVSG_API void GLEnableLineStipple( void );
00377   friend NVSG_API void GLEnableLogicOp( void );
00378   friend NVSG_API void GLEnableNormalArray( void );
00379   friend NVSG_API void GLEnableNormalize( void );
00380   friend NVSG_API void GLEnablePointSmooth( void );
00381   friend NVSG_API void GLEnablePolygonOffsetFill( void );
00382   friend NVSG_API void GLEnablePolygonOffsetLine( void );
00383   friend NVSG_API void GLEnablePolygonOffsetPoint( void );
00384   friend NVSG_API void GLEnablePolygonSmooth( void );
00385   friend NVSG_API void GLEnablePolygonStipple( void );
00386   friend NVSG_API void GLEnableScissorTest( void );
00387   friend NVSG_API void GLEnableStencilTest( void );
00388   friend NVSG_API void GLEnableSecondaryColorArray( void );
00389   friend NVSG_API void GLEnableTexture( GLenum target );
00390   friend NVSG_API void GLEnableTextureCoordArray( void );
00391   friend NVSG_API void GLEnableTextureGen( GLenum target );
00392   friend NVSG_API void GLEnableVertexArray( void );
00393   friend NVSG_API void GLEnableVertexAttribArray( GLuint index );
00394   friend NVSG_API void GLEnd( void );
00395   friend NVSG_API void GLEndList( void );
00396   friend NVSG_API void GLEndOcclusionQuery( void );
00397   friend NVSG_API void GLEndQuery( GLenum target );
00398   friend NVSG_API void GLEndTransformFeedback();
00399   friend NVSG_API void GLEvalCoord1d( GLdouble u );
00400   friend NVSG_API void GLEvalCoord1f( GLfloat u );
00401   friend NVSG_API void GLEvalCoord2d( GLdouble u, GLdouble v );
00402   friend NVSG_API void GLEvalCoord2f( GLfloat u, GLfloat v );
00403   friend NVSG_API void GLEvalMesh1( GLenum mode, GLint i1, GLint i2 );
00404   friend NVSG_API void GLEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 );
00405   friend NVSG_API void GLEvalPoint1( GLint i );
00406   friend NVSG_API void GLEvalPoint2( GLint i, GLint j );
00407   friend NVSG_API void GLExecuteProgram( GLenum target, GLuint id, const GLfloat *params );
00408   friend NVSG_API void GLFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer );
00409   friend NVSG_API void GLFinalCombinerInput( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage );
00410   friend NVSG_API void GLFinish( void );
00411   friend NVSG_API void GLFinishFence( GLuint fence );
00412   friend NVSG_API void GLFlush( void );
00413   friend NVSG_API void GLFlushPixelDataRange( GLenum target );
00414   friend NVSG_API void GLFlushVertexArrayRange();
00415   friend NVSG_API void GLFogColor( const GLfloat * color );
00416   friend NVSG_API void GLFogCoordd( GLdouble fog );
00417   friend NVSG_API void GLFogCoorddv( const GLdouble *fog );
00418   friend NVSG_API void GLFogCoordf( GLfloat fog );
00419   friend NVSG_API void GLFogCoordfv( const GLfloat *fog );
00420   friend NVSG_API void GLFogCoordh( GLhalf fog );
00421   friend NVSG_API void GLFogCoordhv( const GLhalf *fog );
00422   friend NVSG_API void GLFogCoordPointer( GLenum type, GLsizei stride, const GLvoid *pointer );
00423   friend NVSG_API void GLFogDensity( GLfloat density );
00424   friend NVSG_API void GLFogEnd( GLfloat end );
00425   friend NVSG_API void GLFogf( GLenum pname, GLfloat param );
00426   friend NVSG_API void GLFogfv( GLenum pname, const GLfloat *params );
00427   friend NVSG_API void GLFogi( GLenum pname, GLint param );
00428   friend NVSG_API void GLFogiv( GLenum pname, const GLint *params );
00429   friend NVSG_API void GLFogMode( GLenum param );
00430   friend NVSG_API void GLFogStart( GLfloat start );
00431   friend NVSG_API void GLFrameTerminator( void );
00432   friend NVSG_API void GLFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level );
00433   friend NVSG_API void GLFramebufferTextureFace( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face );
00434   friend NVSG_API void GLFrontFace( GLenum mode );
00435   friend NVSG_API void GLFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
00436   friend NVSG_API void GLGenArraySets( GLsizei n, GLuint *buffers );
00437   friend NVSG_API void GLGenBuffers( GLsizei n, GLuint *buffers );
00438   friend NVSG_API void GLGenFences( GLsizei n, GLuint *fences );
00439   friend NVSG_API GLuint GLGenLists( GLsizei range );
00440   friend NVSG_API void GLGenOcclusionQueries( GLsizei n, GLuint *ids );
00441   friend NVSG_API void GLGenPrograms( GLsizei n, GLuint *ids );
00442   friend NVSG_API void GLGenQueries( GLsizei n, GLuint *ids );
00443   friend NVSG_API void GLGenTextures( GLsizei n, GLuint *textures );
00444   friend NVSG_API void GLGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name );
00445   friend NVSG_API void GLGetActiveUniform( GLuint program, GLuint index, GLsizei maxLength, GLsizei *length, GLsizei *size, GLenum *type, GLcharARB *name );
00446   friend NVSG_API void GLGetActiveVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name );
00447   friend NVSG_API void GLGetAttachedObjects( GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj );
00448   friend NVSG_API void GLGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders );
00449   friend NVSG_API GLint GLGetAttribLocation( GLuint program, const GLchar *name );
00450   friend NVSG_API void GLGetBooleanv( GLenum pname, GLboolean *params );
00451   friend NVSG_API void GLGetBooleanIndexedv( GLenum target, GLuint index, GLboolean *data );
00452   friend NVSG_API void GLGetBufferParameteriv( GLenum target, GLenum pname, GLint *params );
00453   friend NVSG_API void GLGetBufferPointerv( GLenum target, GLenum pname, GLvoid* *params );
00454   friend NVSG_API void GLGetBufferSubData( GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data );
00455   friend NVSG_API void GLGetClipPlane( GLenum plane, GLdouble *equation );
00456   friend NVSG_API void GLGetColorTable( GLenum target, GLenum format, GLenum type, GLvoid *table );
00457   friend NVSG_API void GLGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params );
00458   friend NVSG_API void GLGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params );
00459   friend NVSG_API void GLGetCombinerInputParameterfv( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params );
00460   friend NVSG_API void GLGetCombinerInputParameteriv( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params );
00461   friend NVSG_API void GLGetCombinerOutputParameterfv( GLenum stage, GLenum portion, GLenum pname, GLfloat *params );
00462   friend NVSG_API void GLGetCombinerOutputParameteriv( GLenum stage, GLenum portion, GLenum pname, GLint *params );
00463   friend NVSG_API void GLGetCombinerStageParameterfv( GLenum stage, GLenum pname, GLfloat *params );
00464   friend NVSG_API void GLGetCompressedTexImage( GLenum target, GLint lod, GLvoid *img );
00465   friend NVSG_API void GLGetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid *image );
00466   friend NVSG_API void GLGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params );
00467   friend NVSG_API void GLGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params );
00468   friend NVSG_API void GLGetDoublev( GLenum pname, GLdouble *params );
00469   friend NVSG_API void GLGetFenceiv( GLuint fence, GLenum pname, GLint *params );
00470   friend NVSG_API void GLGetFinalCombinerInputParameterfv( GLenum variable, GLenum pname, GLfloat *params );
00471   friend NVSG_API void GLGetFinalCombinerInputParameteriv( GLenum variable, GLenum pname, GLint *params );
00472   friend NVSG_API void GLGetFloatv( GLenum pname, GLfloat *params );
00473   friend NVSG_API void GLGetFogColor( GLfloat * fogColor );
00474   friend NVSG_API GLint GLGetFragDataLocation( GLuint program, const GLchar *name );
00475   friend NVSG_API GLhandleARB GLGetHandle( GLenum pname );
00476   friend NVSG_API void GLGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values );
00477   friend NVSG_API void GLGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params );
00478   friend NVSG_API void GLGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params );
00479   friend NVSG_API void GLGetInfoLog( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog );
00480   friend NVSG_API void GLGetIntegerv( GLenum pname, GLint *params );
00481   friend NVSG_API void GLGetIntegerIndexedv( GLenum target, GLuint index, GLint *data );
00482   friend NVSG_API void GLGetLightfv( GLenum light, GLenum pname, GLfloat *params );
00483   friend NVSG_API void GLGetLightiv( GLenum light, GLenum pname, GLint *params );
00484   friend NVSG_API void GLGetMapdv( GLenum target, GLenum query, GLdouble *v );
00485   friend NVSG_API void GLGetMapfv( GLenum target, GLenum query, GLfloat *v );
00486   friend NVSG_API void GLGetMapiv( GLenum target, GLenum query, GLint *v );
00487   friend NVSG_API void GLGetMaterialfv( GLenum face, GLenum pname, GLfloat *params );
00488   friend NVSG_API void GLGetMaterialiv( GLenum face, GLenum pname, GLint *params );
00489   friend NVSG_API GLint GLGetMaxTexCoords( void );
00490   friend NVSG_API GLint GLGetMaxTexUnits( void );
00491   friend NVSG_API GLint GLGetMaxTexImageUnits( void );
00492   friend NVSG_API void GLGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values );
00493   friend NVSG_API void GLGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params );
00494   friend NVSG_API void GLGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params );
00495   friend NVSG_API void GLGetObjectParameterfv( GLhandleARB obj, GLenum pname, GLfloat *params );
00496   friend NVSG_API void GLGetObjectParameteriv( GLhandleARB obj, GLenum pname, GLint *params );
00497   friend NVSG_API void GLGetOcclusionQueryiv( GLuint id, GLenum pname, GLint *params );
00498   friend NVSG_API void GLGetOcclusionQueryuiv( GLuint id, GLenum pname, GLuint *params );
00499   friend NVSG_API void GLGetPixelMapfv( GLenum map, GLfloat *values );
00500   friend NVSG_API void GLGetPixelMapuiv( GLenum map, GLuint *values );
00501   friend NVSG_API void GLGetPixelMapusv( GLenum map, GLushort *values );
00502   friend NVSG_API void GLGetPointerv( GLenum pname, GLvoid* *params );
00503   friend NVSG_API void GLGetPolygonStipple( GLubyte *mask );
00504   friend NVSG_API void GLGetProgramEnvParameterdv( GLenum target, GLuint index, GLdouble *params );
00505   friend NVSG_API void GLGetProgramEnvParameterfv( GLenum target, GLuint index, GLfloat *params );
00506   friend NVSG_API void GLGetProgramiv( GLuint program, GLenum pname, GLint *params );
00507   friend NVSG_API void GLGetProgramLocalParameterdv( GLenum target, GLuint index, GLdouble *params );
00508   friend NVSG_API void GLGetProgramLocalParameterfv( GLenum target, GLuint index, GLfloat *params );
00509   friend NVSG_API void GLGetProgramInfoLog( GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog );
00510   friend NVSG_API void GLGetProgramEnvParameterIiv( GLenum target, GLuint index, GLint *params );
00511   friend NVSG_API void GLGetProgramEnvParameterIuiv( GLenum target, GLuint index, GLuint *params );
00512   friend NVSG_API void GLGetProgramLocalParameterIiv( GLenum target, GLuint index, GLint *params );
00513   friend NVSG_API void GLGetProgramLocalParameterIuiv( GLenum target, GLuint index, GLuint *params );
00514   friend NVSG_API void GLGetProgramNamedParameterdv( GLuint id, GLsizei len, const GLubyte *name, GLdouble *params );
00515   friend NVSG_API void GLGetProgramNamedParameterfv( GLuint id, GLsizei len, const GLubyte *name, GLfloat *params );
00516   friend NVSG_API void GLGetProgramParameterdv( GLenum target, GLuint index, GLenum pname, GLdouble *params );
00517   friend NVSG_API void GLGetProgramParameterfv( GLenum target, GLuint index, GLenum pname, GLfloat *params );
00518   friend NVSG_API void GLGetProgramString( GLuint id, GLenum pname, GLubyte *program );
00519   friend NVSG_API void GLGetQueryiv( GLenum target, GLenum pname, GLint *params );
00520   friend NVSG_API void GLGetQueryObjecti64v( GLuint id, GLenum pname, GLint64EXT *params );
00521   friend NVSG_API void GLGetQueryObjectiv( GLuint id, GLenum pname, GLint *params );
00522   friend NVSG_API void GLGetQueryObjectui64v( GLuint id, GLenum pname, GLuint64EXT *params );
00523   friend NVSG_API void GLGetQueryObjectuiv( GLuint id, GLenum pname, GLuint *params );
00524   friend NVSG_API void GLGetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span );
00525   friend NVSG_API void GLGetShaderiv( GLuint shader, GLenum pname, GLint *params );
00526   friend NVSG_API void GLGetShaderInfoLog( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog );
00527   friend NVSG_API void GLGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei *length, GLcharARB *source );
00528   friend NVSG_API const GLubyte * GLGetString( GLenum name );
00529   friend NVSG_API void GLGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params );
00530   friend NVSG_API void GLGetTexEnviv( GLenum target, GLenum pname, GLint *params );
00531   friend NVSG_API void GLGetTexGendv( GLenum coord, GLenum pname, GLdouble *params );
00532   friend NVSG_API void GLGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params );
00533   friend NVSG_API void GLGetTexGeniv( GLenum coord, GLenum pname, GLint *params );
00534   friend NVSG_API void GLGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels );
00535   friend NVSG_API void GLGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params );
00536   friend NVSG_API void GLGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params );
00537   friend NVSG_API void GLGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params );
00538   friend NVSG_API void GLGetTexParameteriv( GLenum target, GLenum pname, GLint *params );
00539   friend NVSG_API void GLGetTexParameterIiv( GLenum target, GLenum pname, GLint *params );
00540   friend NVSG_API void GLGetTexParameterIuiv( GLenum target, GLenum pname, GLuint *params );
00541   friend NVSG_API void GLGetTrackMatrixiv( GLenum target, GLuint address, GLenum pname, GLint *params );
00542   friend NVSG_API void GLGetTransformFeedbackVarying( GLuint program, GLuint index, GLint *location );
00543   friend NVSG_API void GLGetUniformfv( GLuint program, GLint location, GLfloat *params );
00544   friend NVSG_API void GLGetUniformiv( GLuint program, GLint location, GLint *params );
00545   friend NVSG_API void GLGetUniformuiv( GLuint program, GLint location, GLuint *params );
00546   friend NVSG_API GLint GLGetUniformBufferSize( GLuint program, GLint location );
00547   friend NVSG_API GLint GLGetUniformLocation( GLuint program, const GLcharARB *name );
00548   friend NVSG_API GLintptr GLGetUniformOffset( GLuint program, GLint location );
00549   friend NVSG_API GLint GLGetVaryingLocation( GLuint program, const GLchar *name );
00550   friend NVSG_API void GLGetVertexAttribdv( GLuint index, GLenum pname, GLdouble *params );
00551   friend NVSG_API void GLGetVertexAttribfv( GLuint index, GLenum pname, GLfloat *params );
00552   friend NVSG_API void GLGetVertexAttribiv( GLuint index, GLenum pname, GLint *params );
00553   friend NVSG_API void GLGetVertexAttribIiv( GLuint index, GLenum pname, GLint *params );
00554   friend NVSG_API void GLGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint *params );
00555   friend NVSG_API void GLGetVertexAttribPointerv( GLuint index, GLenum pname, GLvoid* *pointer );
00556   friend NVSG_API GLint GLGetVersion();
00557   friend NVSG_API void GLHint( GLenum target, GLenum mode );
00558   friend NVSG_API void GLHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink );
00559   friend NVSG_API void GLIndexd( GLdouble c );
00560   friend NVSG_API void GLIndexf( GLfloat c );
00561   friend NVSG_API void GLIndexi( GLint c );
00562   friend NVSG_API void GLIndexMask( GLuint mask );
00563   friend NVSG_API void GLIndexPointer( GLenum type, GLsizei stride, const GLvoid *pointer );
00564   friend NVSG_API void GLIndexs( GLshort c );
00565   friend NVSG_API void GLIndexub( GLubyte c );
00566   friend NVSG_API void GLInitNames( void );
00567   friend NVSG_API void GLInterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer );
00568   friend NVSG_API GLboolean GLIsArraySet( GLuint buffer );
00569   friend NVSG_API GLboolean GLIsBuffer( GLuint name );
00570   friend NVSG_API GLboolean GLIsEnabled( GLenum cap );
00571   friend NVSG_API GLboolean GLIsEnabledAlphaTest();
00572   friend NVSG_API GLboolean GLIsEnabledAutoNormal();
00573   friend NVSG_API GLboolean GLIsEnabledBlend();
00574   friend NVSG_API GLboolean GLIsEnabledClipPlane( GLenum plane );
00575   friend NVSG_API GLboolean GLIsEnabledColorLogicOp();
00576   friend NVSG_API GLboolean GLIsEnabledColorMaterial();
00577   friend NVSG_API GLboolean GLIsEnabledCullFace();
00578   friend NVSG_API GLboolean GLIsEnabledDepthTest();
00579   friend NVSG_API GLboolean GLIsEnabledDither();
00580   friend NVSG_API GLboolean GLIsEnabledFog();
00581   friend NVSG_API GLboolean GLIsEnabledIndexed( GLenum target, GLuint index );
00582   friend NVSG_API GLboolean GLIsEnabledLight( GLenum cap );
00583   friend NVSG_API GLboolean GLIsEnabledLighting();
00584   friend NVSG_API GLboolean GLIsEnabledLineSmooth();
00585   friend NVSG_API GLboolean GLIsEnabledLineStipple();
00586   friend NVSG_API GLboolean GLIsEnabledLogicOp();
00587   friend NVSG_API GLboolean GLIsEnabledNormalize();
00588   friend NVSG_API GLboolean GLIsEnabledPointSmooth();
00589   friend NVSG_API GLboolean GLIsEnabledPolygonOffsetFill();
00590   friend NVSG_API GLboolean GLIsEnabledPolygonOffsetLine();
00591   friend NVSG_API GLboolean GLIsEnabledPolygonOffsetPoint();
00592   friend NVSG_API GLboolean GLIsEnabledPolygonSmooth();
00593   friend NVSG_API GLboolean GLIsEnabledPolygonStipple();
00594   friend NVSG_API GLboolean GLIsEnabledScissorTest();
00595   friend NVSG_API GLboolean GLIsEnabledStencilTest();
00596   friend NVSG_API GLboolean GLIsEnabledTexture( GLenum cap );
00597   friend NVSG_API GLboolean GLIsEnabledTextureGen( GLenum cap );
00598   friend NVSG_API GLboolean GLIsExtensionAvailable( const std::string& extension );
00599   friend NVSG_API GLboolean GLIsExtensionExported( const std::string& extension );
00600   friend NVSG_API GLboolean GLIsFence( GLuint fence );
00601   friend NVSG_API GLboolean GLIsList( GLuint list );
00602   friend NVSG_API GLboolean GLIsOcclusionQuery( GLuint id );
00603   friend NVSG_API GLboolean GLIsProgram( GLuint program );
00604   friend NVSG_API GLboolean GLIsQuery( GLuint id );
00605   friend NVSG_API GLboolean GLIsShader( GLuint shader );
00606   friend NVSG_API GLboolean GLIsTexture( GLuint texture );
00607   friend NVSG_API void GLLightAmbient( GLenum light, const GLfloat *params );
00608   friend NVSG_API void GLLightConstantAttenuation( GLenum light, GLfloat param );
00609   friend NVSG_API void GLLightDiffuse( GLenum light, const GLfloat *params );
00610   friend NVSG_API void GLLightf( GLenum light, GLenum pname, GLfloat param );
00611   friend NVSG_API void GLLightfv( GLenum light, GLenum pname, const GLfloat *params );
00612   friend NVSG_API void GLLighti( GLenum light, GLenum pname, GLint param );
00613   friend NVSG_API void GLLightiv( GLenum light, GLenum pname, GLint *params );
00614   friend NVSG_API void GLLightPosition( GLenum light, const GLfloat * params );
00615   friend NVSG_API void GLLightLinearAttenuation( GLenum light, GLfloat param );
00616   friend NVSG_API void GLLightQuadraticAttenuation( GLenum light, GLfloat param );
00617   friend NVSG_API void GLLightSpecular( GLenum light, const GLfloat *params );
00618   friend NVSG_API void GLLightSpotCutoff( GLenum light, GLfloat param );
00619   friend NVSG_API void GLLightSpotDirection( GLenum light, const GLfloat *params );
00620   friend NVSG_API void GLLightSpotExponent( GLenum light, GLfloat param );
00621   friend NVSG_API void GLLightModelf( GLenum pname, GLfloat param );
00622   friend NVSG_API void GLLightModelfv( GLenum pname, const GLfloat *params );
00623   friend NVSG_API void GLLightModeli( GLenum pname, GLint param );
00624   friend NVSG_API void GLLightModeliv( GLenum pname, const GLint *params );
00625   friend NVSG_API void GLLightModelAmbient( const GLfloat * params );
00626   friend NVSG_API void GLLightModelLocalViewer( GLint param );
00627   friend NVSG_API void GLLightModelTwoSide( GLint param );
00628   friend NVSG_API void GLLightModelTwoSideLock( GLint param );
00629   friend NVSG_API void GLLightModelTwoSideUnlock( GLint param );
00630   friend NVSG_API void GLLineStipple( GLint factor, GLushort pattern );
00631   friend NVSG_API void GLLineWidth( GLfloat width );
00632   friend NVSG_API void GLLinkProgram( GLuint program );
00633   friend NVSG_API void GLListBase( GLuint base );
00634   friend NVSG_API void GLLoadIdentity( void );
00635   friend NVSG_API void GLLoadMatrixd( const GLdouble *m );
00636   friend NVSG_API void GLLoadMatrixf( const GLfloat *m );
00637   friend NVSG_API void GLLoadTransposedMatrixd( const GLdouble *m );
00638   friend NVSG_API void GLLoadTransposeMatrixf( const GLfloat *m );
00639   friend NVSG_API void GLLoadName( GLuint name );
00640   friend NVSG_API void GLLoadProgram( GLenum target, GLuint id, GLsizei len, const GLubyte *program );
00641   friend NVSG_API void GLLockArrays( GLint first, GLsizei count );
00642   friend NVSG_API void GLLogicOp( GLenum opcode );
00643   friend NVSG_API void GLMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points );
00644   friend NVSG_API void GLMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points );
00645   friend NVSG_API void GLMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points );
00646   friend NVSG_API void GLMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points );
00647   friend NVSG_API GLvoid* GLMapBuffer( GLenum target, GLenum access );
00648   friend NVSG_API void GLMapGrid1d( GLint un, GLdouble u1, GLdouble u2 );
00649   friend NVSG_API void GLMapGrid1f( GLint un, GLfloat u1, GLfloat u2 );
00650   friend NVSG_API void GLMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 );
00651   friend NVSG_API void GLMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 );
00652   friend NVSG_API void GLMaterialAmbient( GLenum face, const GLfloat *params );
00653   friend NVSG_API void GLMaterialAmbientBack( const GLfloat *params );
00654   friend NVSG_API void GLMaterialAmbientFront( const GLfloat *params );
00655   friend NVSG_API void GLMaterialAmbientFrontAndBack( const GLfloat *params );
00656   friend NVSG_API void GLMaterialDiffuse( GLenum face, const GLfloat *params );
00657   friend NVSG_API void GLMaterialDiffuseBack( const GLfloat *params );
00658   friend NVSG_API void GLMaterialDiffuseFront( const GLfloat *params );
00659   friend NVSG_API void GLMaterialDiffuseFrontAndBack( const GLfloat *params );
00660   friend NVSG_API void GLMaterialEmission( GLenum face, const GLfloat *params );
00661   friend NVSG_API void GLMaterialEmissionBack( const GLfloat *params );
00662   friend NVSG_API void GLMaterialEmissionFront( const GLfloat *params );
00663   friend NVSG_API void GLMaterialEmissionFrontAndBack( const GLfloat *params );
00664   friend NVSG_API void GLMaterialf( GLenum face, GLenum pname, GLfloat param );
00665   friend NVSG_API void GLMaterialfv( GLenum face, GLenum pname, const GLfloat *params );
00666   friend NVSG_API void GLMateriali( GLenum face, GLenum pname, GLint param );
00667   friend NVSG_API void GLMaterialiv( GLenum face, GLenum pname, const GLint *params );
00668   friend NVSG_API void GLMaterialShininess( GLenum face, GLfloat param );
00669   friend NVSG_API void GLMaterialShininessBack( GLfloat param );
00670   friend NVSG_API void GLMaterialShininessFront( GLfloat param );
00671   friend NVSG_API void GLMaterialShininessFrontAndBack( GLfloat param );
00672   friend NVSG_API void GLMaterialSpecular( GLenum face, const GLfloat *params );
00673   friend NVSG_API void GLMaterialSpecularBack( const GLfloat *params );
00674   friend NVSG_API void GLMaterialSpecularFront( const GLfloat *params );
00675   friend NVSG_API void GLMaterialSpecularFrontAndBack( const GLfloat *params );
00676   friend NVSG_API void GLMatrixMode( GLenum mode );
00677   friend NVSG_API void GLMinmax( GLenum target, GLenum internalformat, GLboolean sink );
00678   friend NVSG_API void GLMultiDrawArrays( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount );
00679   friend NVSG_API void GLMultiDrawElements( GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount );
00680   friend NVSG_API void GLMultiTexCoord1d( GLenum target, GLdouble s );
00681   friend NVSG_API void GLMultiTexCoord1dv( GLenum target, const GLdouble *v );
00682   friend NVSG_API void GLMultiTexCoord1f( GLenum target, GLfloat s );
00683   friend NVSG_API void GLMultiTexCoord1fv( GLenum target, const GLfloat *v );
00684   friend NVSG_API void GLMultiTexCoord1h( GLenum target, GLhalf s );
00685   friend NVSG_API void GLMultiTexCoord1hv( GLenum target, const GLhalf *v );
00686   friend NVSG_API void GLMultiTexCoord1i( GLenum target, GLint s );
00687   friend NVSG_API void GLMultiTexCoord1iv( GLenum target, const GLint *v );
00688   friend NVSG_API void GLMultiTexCoord1s( GLenum target, GLshort s );
00689   friend NVSG_API void GLMultiTexCoord1sv( GLenum target, const GLshort *v );
00690   friend NVSG_API void GLMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t );
00691   friend NVSG_API void GLMultiTexCoord2dv( GLenum target, const GLdouble *v );
00692   friend NVSG_API void GLMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t );
00693   friend NVSG_API void GLMultiTexCoord2fv( GLenum target, const GLfloat *v );
00694   friend NVSG_API void GLMultiTexCoord2h( GLenum target, GLhalf s, GLhalf t );
00695   friend NVSG_API void GLMultiTexCoord2hv( GLenum target, const GLhalf *v );
00696   friend NVSG_API void GLMultiTexCoord2i( GLenum target, GLint s, GLint t );
00697   friend NVSG_API void GLMultiTexCoord2iv( GLenum target, const GLint *v );
00698   friend NVSG_API void GLMultiTexCoord2s( GLenum target, GLshort s, GLshort t );
00699   friend NVSG_API void GLMultiTexCoord2sv( GLenum target, const GLshort *v );
00700   friend NVSG_API void GLMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r );
00701   friend NVSG_API void GLMultiTexCoord3dv( GLenum target, const GLdouble *v );
00702   friend NVSG_API void GLMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r );
00703   friend NVSG_API void GLMultiTexCoord3fv( GLenum target, const GLfloat *v );
00704   friend NVSG_API void GLMultiTexCoord3h( GLenum target, GLhalf s, GLhalf t, GLhalf r );
00705   friend NVSG_API void GLMultiTexCoord3hv( GLenum target, const GLhalf *v );
00706   friend NVSG_API void GLMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r );
00707   friend NVSG_API void GLMultiTexCoord3iv( GLenum target, const GLint *v );
00708   friend NVSG_API void GLMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r );
00709   friend NVSG_API void GLMultiTexCoord3sv( GLenum target, const GLshort *v );
00710   friend NVSG_API void GLMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
00711   friend NVSG_API void GLMultiTexCoord4dv( GLenum target, const GLdouble *v );
00712   friend NVSG_API void GLMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
00713   friend NVSG_API void GLMultiTexCoord4fv( GLenum target, const GLfloat *v );
00714   friend NVSG_API void GLMultiTexCoord4h( GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q );
00715   friend NVSG_API void GLMultiTexCoord4hv( GLenum target, const GLhalf *v );
00716   friend NVSG_API void GLMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q );
00717   friend NVSG_API void GLMultiTexCoord4iv( GLenum target, const GLint *v );
00718   friend NVSG_API void GLMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
00719   friend NVSG_API void GLMultiTexCoord4sv( GLenum target, const GLshort *v );
00720   friend NVSG_API void GLMultiTexCoordPointer( GLenum target, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00721   friend NVSG_API void GLMultMatrixd( const GLdouble *m );
00722   friend NVSG_API void GLMultMatrixf( const GLfloat *m );
00723   friend NVSG_API void GLMultTransposeMatrixd( const GLdouble *m );
00724   friend NVSG_API void GLMultTransposeMatrixf( const GLfloat *m );
00725   friend NVSG_API void GLNewList( GLuint list, GLenum mode );
00726   friend NVSG_API void GLNormal3b( GLbyte nx, GLbyte ny, GLbyte nz );
00727   friend NVSG_API void GLNormal3bv( const GLbyte *v );
00728   friend NVSG_API void GLNormal3d( GLdouble nx, GLdouble ny, GLdouble nz );
00729   friend NVSG_API void GLNormal3dv( const GLdouble *v );
00730   friend NVSG_API void GLNormal3f( GLfloat nx, GLfloat ny, GLfloat nz );
00731   friend NVSG_API void GLNormal3fv( const GLfloat *v );
00732   friend NVSG_API void GLNormal3h( GLhalf nx, GLhalf ny, GLhalf nz );
00733   friend NVSG_API void GLNormal3hv( const GLhalf *v );
00734   friend NVSG_API void GLNormal3i( GLint nx, GLint ny, GLint nz );
00735   friend NVSG_API void GLNormal3iv( const GLint *v );
00736   friend NVSG_API void GLNormal3s( GLshort nx, GLshort ny, GLshort nz );
00737   friend NVSG_API void GLNormal3sv( const GLshort *v );
00738   friend NVSG_API void GLNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer );
00739   friend NVSG_API void GLOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
00740   friend NVSG_API void GLPassThrough( GLfloat token );
00741   friend NVSG_API void GLPixelDataRange( GLenum target, GLsizei size, const GLvoid *pointer );
00742   friend NVSG_API void GLPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values );
00743   friend NVSG_API void GLPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values );
00744   friend NVSG_API void GLPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values );
00745   friend NVSG_API void GLPixelStoref( GLenum pname, GLfloat param );
00746   friend NVSG_API void GLPixelStorei( GLenum pname, GLint param );
00747   friend NVSG_API void GLPixelTransferf( GLenum pname, GLfloat param );
00748   friend NVSG_API void GLPixelTransferi( GLenum pname, GLint param );
00749   friend NVSG_API void GLPixelZoom( GLfloat xfactor, GLfloat yfactor );
00750   friend NVSG_API void GLPointParameterf( GLenum pname, GLfloat param );
00751   friend NVSG_API void GLPointParameterfv( GLenum pname, const GLfloat *params );
00752   friend NVSG_API void GLPointParameteri( GLenum pname, GLint param );
00753   friend NVSG_API void GLPointParameteriv( GLenum pname, const GLint *params );
00754   friend NVSG_API void GLPointSize( GLfloat size );
00755   friend NVSG_API void GLPolygonMode( GLenum face, GLenum mode );
00756   friend NVSG_API void GLPolygonModeBack( GLenum mode );
00757   friend NVSG_API void GLPolygonModeFront( GLenum mode );
00758   friend NVSG_API void GLPolygonModeFrontAndBack( GLenum mode );
00759   friend NVSG_API void GLPolygonModeLock( GLenum face, GLenum mode );
00760   friend NVSG_API void GLPolygonModeUnlock( GLenum face, GLenum mode );
00761   friend NVSG_API void GLPolygonOffset( GLfloat factor, GLfloat units );
00762   friend NVSG_API void GLPolygonStipple( const GLubyte *mask );
00763   friend NVSG_API void GLPopAttrib( void );
00764   friend NVSG_API void GLPopClientAttrib( void );
00765   friend NVSG_API void GLPopMatrix( void );
00766   friend NVSG_API void GLPopName( void );
00767   friend NVSG_API void GLPrimitiveRestart();
00768   friend NVSG_API void GLPrimitiveRestartIndex( GLuint index );
00769   friend NVSG_API void GLPrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities );
00770   friend NVSG_API void GLProgramBufferParametersfv( GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params );
00771   friend NVSG_API void GLProgramBufferParametersIiv( GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params );
00772   friend NVSG_API void GLProgramBufferParametersIuiv( GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params );
00773   friend NVSG_API void GLProgramEnvParameter4d(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
00774   friend NVSG_API void GLProgramEnvParameter4dv(GLenum target, GLuint index, const GLdouble *params);
00775   friend NVSG_API void GLProgramEnvParameter4f(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
00776   friend NVSG_API void GLProgramEnvParameter4fv(GLenum target, GLuint index, const GLfloat *params);
00777   friend NVSG_API void GLProgramEnvParametersI4iv( GLenum target, GLuint index, GLsizei count, const GLint *params );
00778   friend NVSG_API void GLProgramEnvParameterI4i( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w );
00779   friend NVSG_API void GLProgramEnvParameterI4iv( GLenum target, GLuint index, const GLint *params );
00780   friend NVSG_API void GLProgramEnvParametersI4uiv( GLenum target, GLuint index, GLsizei count, const GLuint *params );
00781   friend NVSG_API void GLProgramEnvParameterI4ui( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w );
00782   friend NVSG_API void GLProgramEnvParameterI4uiv( GLenum target, GLuint index, const GLuint *params );
00783   friend NVSG_API void GLProgramEnvParameters4fv( GLenum target, GLuint index, GLsizei count, const GLfloat *params );
00784   friend NVSG_API void GLProgramLocalParameter4d(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
00785   friend NVSG_API void GLProgramLocalParameter4dv(GLenum target, GLuint index, const GLdouble *params);
00786   friend NVSG_API void GLProgramLocalParameter4f(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
00787   friend NVSG_API void GLProgramLocalParameter4fv(GLenum target, GLuint index, const GLfloat *params);
00788   friend NVSG_API void GLProgramLocalParametersI4iv( GLenum target, GLuint index, GLsizei count, const GLint *params );
00789   friend NVSG_API void GLProgramLocalParametersI4uiv( GLenum target, GLuint index, GLsizei count, const GLuint *params );
00790   friend NVSG_API void GLProgramLocalParameterI4i( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w );
00791   friend NVSG_API void GLProgramLocalParameterI4iv( GLenum target, GLuint index, const GLint *params );
00792   friend NVSG_API void GLProgramLocalParameterI4ui( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w );
00793   friend NVSG_API void GLProgramLocalParameterI4uiv( GLenum target, GLuint index, const GLuint *params );
00794   friend NVSG_API void GLProgramLocalParameters4fv( GLenum target, GLuint index, GLsizei count, const GLfloat *params );
00795   friend NVSG_API void GLProgramNamedParameter4d( GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
00796   friend NVSG_API void GLProgramNamedParameter4dv( GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v );
00797   friend NVSG_API void GLProgramNamedParameter4f( GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
00798   friend NVSG_API void GLProgramNamedParameter4fv( GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v );
00799   friend NVSG_API void GLProgramParameter4d( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
00800   friend NVSG_API void GLProgramParameter4dv( GLenum target, GLuint index, const GLdouble *v );
00801   friend NVSG_API void GLProgramParameter4f( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
00802   friend NVSG_API void GLProgramParameter4fv( GLenum target, GLuint index, const GLfloat *v );
00803   friend NVSG_API void GLProgramParameteri( GLuint program, GLenum pname, GLint value );
00804   friend NVSG_API void GLProgramParameters4dv( GLenum target, GLuint index, GLsizei count, const GLdouble *v );
00805   friend NVSG_API void GLProgramParameters4fv( GLenum target, GLuint index, GLsizei count, const GLfloat *v );
00806   friend NVSG_API void GLProgramString( GLenum target, GLenum format, GLsizei len, const GLvoid *string );
00807   friend NVSG_API void GLProgramVertexLimit( GLenum target, GLint limit );
00808   friend NVSG_API void GLPushAttrib( GLbitfield mask );
00809   friend NVSG_API void GLPushClientAttrib( GLbitfield mask );
00810   friend NVSG_API void GLPushMatrix( void );
00811   friend NVSG_API void GLPushName( GLuint name );
00812   friend NVSG_API void GLRasterPos2d( GLdouble x, GLdouble y );
00813   friend NVSG_API void GLRasterPos2f( GLfloat x, GLfloat y );
00814   friend NVSG_API void GLRasterPos2i( GLint x, GLint y );
00815   friend NVSG_API void GLRasterPos2s( GLshort x, GLshort y );
00816   friend NVSG_API void GLRasterPos3d( GLdouble x, GLdouble y, GLdouble z );
00817   friend NVSG_API void GLRasterPos3f( GLfloat x, GLfloat y, GLfloat z );
00818   friend NVSG_API void GLRasterPos3i( GLint x, GLint y, GLint z );
00819   friend NVSG_API void GLRasterPos3s( GLshort x, GLshort y, GLshort z );
00820   friend NVSG_API void GLRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
00821   friend NVSG_API void GLRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
00822   friend NVSG_API void GLRasterPos4i( GLint x, GLint y, GLint z, GLint w );
00823   friend NVSG_API void GLRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w );
00824   friend NVSG_API void GLReadBuffer( GLenum mode );
00825   friend NVSG_API void GLReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels );
00826   friend NVSG_API void GLRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 );
00827   friend NVSG_API void GLRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 );
00828   friend NVSG_API void GLRecti( GLint x1, GLint y1, GLint x2, GLint y2 );
00829   friend NVSG_API void GLRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 );
00830   friend NVSG_API void GLRenderMode( GLenum mode );
00831   friend NVSG_API void GLRequestResidentPrograms( GLsizei n, const GLuint *programs );
00832   friend NVSG_API void GLResetHistogram( GLenum target );
00833   friend NVSG_API void GLResetMinmax( GLenum target );
00834   friend NVSG_API void GLRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z );
00835   friend NVSG_API void GLRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z );
00836   friend NVSG_API void GLScaled( GLdouble x, GLdouble y, GLdouble z );
00837   friend NVSG_API void GLScalef( GLfloat x, GLfloat y, GLfloat z );
00838   friend NVSG_API void GLSampleCoverage( GLclampf value, GLboolean invert );
00839   friend NVSG_API void GLScissor( GLint x, GLint y, GLsizei width, GLsizei height );
00840   friend NVSG_API void GLSecondaryColor3b( GLbyte red, GLbyte green, GLbyte blue );
00841   friend NVSG_API void GLSecondaryColor3bv( const GLbyte *v );
00842   friend NVSG_API void GLSecondaryColor3d( GLdouble red, GLdouble green, GLdouble blue );
00843   friend NVSG_API void GLSecondaryColor3dv( const GLdouble *v );
00844   friend NVSG_API void GLSecondaryColor3f( GLfloat red, GLfloat green, GLfloat blue );
00845   friend NVSG_API void GLSecondaryColor3fv( const GLfloat *v );
00846   friend NVSG_API void GLSecondaryColor3h( GLhalf red, GLhalf green, GLhalf blue );
00847   friend NVSG_API void GLSecondaryColor3hv( const GLhalf *v );
00848   friend NVSG_API void GLSecondaryColor3i( GLint red, GLint green, GLint blue );
00849   friend NVSG_API void GLSecondaryColor3iv( const GLint *v );
00850   friend NVSG_API void GLSecondaryColor3s( GLshort red, GLshort green, GLshort blue );
00851   friend NVSG_API void GLSecondaryColor3sv( const GLshort *v );
00852   friend NVSG_API void GLSecondaryColor3ub( GLubyte red, GLubyte green, GLubyte blue );
00853   friend NVSG_API void GLSecondaryColor3ubv( const GLubyte *v );
00854   friend NVSG_API void GLSecondaryColor3ui( GLuint red, GLuint green, GLuint blue );
00855   friend NVSG_API void GLSecondaryColor3uiv( const GLuint *v );
00856   friend NVSG_API void GLSecondaryColor3us( GLushort red, GLushort green, GLushort blue );
00857   friend NVSG_API void GLSecondaryColor3usv( const GLushort *v );
00858   friend NVSG_API void GLSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00859   friend NVSG_API void GLSelectBuffer( GLsizei size, GLuint *buffer );
00860   friend NVSG_API void GLSelectTexture( GLenum target );
00861   friend NVSG_API void GLSelectTextureCoordSet( GLenum target );
00862   friend NVSG_API void GLSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column );
00863   friend NVSG_API void GLSetFence( GLuint fence, GLenum condition );
00864   friend NVSG_API void GLSetWindowStereoMode( GLboolean displayMode );
00865   friend NVSG_API void GLShadeModel( GLenum mode );
00866   friend NVSG_API void GLShaderSource( GLuint shader, GLsizei count, const GLcharARB* *string, const GLint *length );
00867   friend NVSG_API void GLStencilClearTag( GLsizei tagBits, GLuint clearTag );
00868   friend NVSG_API void GLStencilFunc( GLenum func, GLint ref, GLuint mask );
00869   friend NVSG_API void GLStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask );
00870   friend NVSG_API void GLStencilOpSeparate( GLenum face, GLenum fail, GLenum zfail, GLenum zpass );
00871   friend NVSG_API void GLStencilMaskSeparate( GLenum face, GLuint mask );
00872   friend NVSG_API void GLStencilMask( GLuint mask );
00873   friend NVSG_API void GLStencilOp( GLenum fail, GLenum zfail, GLenum zpass );
00874   friend NVSG_API void GLStringMarker( GLsizei len, const GLvoid *string );
00875   friend NVSG_API GLboolean GLTestFence( GLuint fence );
00876   friend NVSG_API void GLTexBuffer( GLenum target, GLenum internalformat, GLuint buffer );
00877   friend NVSG_API void GLTexCoord1d( GLdouble s );
00878   friend NVSG_API void GLTexCoord1dv( const GLdouble *v );
00879   friend NVSG_API void GLTexCoord1f( GLfloat s );
00880   friend NVSG_API void GLTexCoord1fv( const GLfloat *v );
00881   friend NVSG_API void GLTexCoord1h( GLhalf s );
00882   friend NVSG_API void GLTexCoord1hv( const GLhalf *v );
00883   friend NVSG_API void GLTexCoord1i( GLint s );
00884   friend NVSG_API void GLTexCoord1iv( const GLint *v );
00885   friend NVSG_API void GLTexCoord1s( GLshort s );
00886   friend NVSG_API void GLTexCoord1sv( const GLshort *v );
00887   friend NVSG_API void GLTexCoord2d( GLdouble s, GLdouble t );
00888   friend NVSG_API void GLTexCoord2dv( const GLdouble *v );
00889   friend NVSG_API void GLTexCoord2f( GLfloat s, GLfloat t );
00890   friend NVSG_API void GLTexCoord2fv( const GLfloat *v );
00891   friend NVSG_API void GLTexCoord2h( GLhalf s, GLhalf t );
00892   friend NVSG_API void GLTexCoord2hv( const GLhalf *v );
00893   friend NVSG_API void GLTexCoord2i( GLint s, GLint t );
00894   friend NVSG_API void GLTexCoord2iv( const GLint *v );
00895   friend NVSG_API void GLTexCoord2s( GLshort s, GLshort t );
00896   friend NVSG_API void GLTexCoord2sv( const GLshort *v );
00897   friend NVSG_API void GLTexCoord3d( GLdouble s, GLdouble t, GLdouble r );
00898   friend NVSG_API void GLTexCoord3dv( const GLdouble *v );
00899   friend NVSG_API void GLTexCoord3f( GLfloat s, GLfloat t, GLfloat r );
00900   friend NVSG_API void GLTexCoord3fv( const GLfloat *v );
00901   friend NVSG_API void GLTexCoord3h( GLhalf s, GLhalf t, GLhalf r );
00902   friend NVSG_API void GLTexCoord3hv( const GLhalf *v );
00903   friend NVSG_API void GLTexCoord3i( GLint s, GLint t, GLint r );
00904   friend NVSG_API void GLTexCoord3iv( const GLint *v );
00905   friend NVSG_API void GLTexCoord3s( GLshort s, GLshort t, GLshort r );
00906   friend NVSG_API void GLTexCoord3sv( const GLshort *v );
00907   friend NVSG_API void GLTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q );
00908   friend NVSG_API void GLTexCoord4dv( const GLdouble *v );
00909   friend NVSG_API void GLTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q );
00910   friend NVSG_API void GLTexCoord4fv( const GLfloat *v );
00911   friend NVSG_API void GLTexCoord4h( GLhalf s, GLhalf t, GLhalf r, GLhalf q );
00912   friend NVSG_API void GLTexCoord4hv( const GLhalf *v );
00913   friend NVSG_API void GLTexCoord4i( GLint s, GLint t, GLint r, GLint q );
00914   friend NVSG_API void GLTexCoord4iv( const GLint *v );
00915   friend NVSG_API void GLTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q );
00916   friend NVSG_API void GLTexCoord4sv( const GLshort *v );
00917   friend NVSG_API void GLTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00918   friend NVSG_API void GLTexEnvf( GLenum target, GLenum pname, GLfloat param );
00919   friend NVSG_API void GLTexEnvfv( GLenum target, GLenum pname, const GLfloat *params );
00920   friend NVSG_API void GLTexEnvi( GLenum target, GLenum pname, GLint param );
00921   friend NVSG_API void GLTexEnviv( GLenum target, GLenum pname, const GLint *params );
00922   friend NVSG_API void GLTexGend( GLenum coord, GLenum pname, GLdouble param );
00923   friend NVSG_API void GLTexGenf( GLenum coord, GLenum pname, GLfloat param );
00924   friend NVSG_API void GLTexGenfv( GLenum coord, GLenum pname, const GLfloat *param );
00925   friend NVSG_API void GLTexGeni( GLenum coord, GLenum pname, GLint param );
00926   friend NVSG_API void GLTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels );
00927   friend NVSG_API void GLTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels );
00928   friend NVSG_API void GLTexImage3D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type, const void* pixels);
00929   friend NVSG_API void GLTexParameterf( GLenum target, GLenum pname, GLfloat param );
00930   friend NVSG_API void GLTexParameteri( GLenum target, GLenum pname, GLint param );
00931   friend NVSG_API void GLTexParameterfv( GLenum target, GLenum pname, const GLfloat *params );
00932   friend NVSG_API void GLTexParameteriv( GLenum target, GLenum pname, const GLint *params );
00933   friend NVSG_API void GLTexParameterIiv( GLenum target, GLenum pname, const GLint *params );
00934   friend NVSG_API void GLTexParameterIuiv( GLenum target, GLenum pname, const GLuint *params );
00935   friend NVSG_API void GLTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels );
00936   friend NVSG_API void GLTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels );
00937   friend NVSG_API void GLTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels );
00938   friend NVSG_API void GLTextureBorderColor( GLenum target, const GLfloat *params );
00939   friend NVSG_API void GLTextureEnvColor( const GLfloat * params );
00940   friend NVSG_API void GLTextureEnvMode( GLint param );
00941   friend NVSG_API void GLTextureMagFilter( GLenum target, GLint param );
00942   friend NVSG_API void GLTextureMinFilter( GLenum target, GLint param );
00943   friend NVSG_API void GLTextureWrapR( GLenum target, GLint param );
00944   friend NVSG_API void GLTextureWrapS( GLenum target, GLint param );
00945   friend NVSG_API void GLTextureWrapT( GLenum target, GLint param );
00946   friend NVSG_API void GLTrackMatrix( GLenum target, GLuint address, GLenum matrix, GLenum transform );
00947   friend NVSG_API void GLTransformFeedbackAttribs( GLuint count, const GLint *attribs, GLenum bufferMode );
00948   friend NVSG_API void GLTransformFeedbackVaryings( GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode );
00949   friend NVSG_API void GLTranslated( GLdouble x, GLdouble y, GLdouble z );
00950   friend NVSG_API void GLTranslatef( GLfloat x, GLfloat y, GLfloat z );
00951   friend NVSG_API void GLUnlockArrays();
00952   friend NVSG_API void GLUniform1f( GLint location, GLfloat v0 );
00953   friend NVSG_API void GLUniform1fv( GLint location, GLsizei count, const GLfloat *value );
00954   friend NVSG_API void GLUniform1i( GLint location, GLint v0 );
00955   friend NVSG_API void GLUniform1iv( GLint location, GLsizei count, const GLint *value );
00956   friend NVSG_API void GLUniform1ui( GLint location, GLuint v0 );
00957   friend NVSG_API void GLUniform1uiv( GLint location, GLsizei count, const GLuint *value );
00958   friend NVSG_API void GLUniform2f( GLint location, GLfloat v0, GLfloat v1 );
00959   friend NVSG_API void GLUniform2fv( GLint location, GLsizei count, const GLfloat *value );
00960   friend NVSG_API void GLUniform2i( GLint location, GLint v0, GLint v1 );
00961   friend NVSG_API void GLUniform2iv( GLint location, GLsizei count, const GLint *value );
00962   friend NVSG_API void GLUniform2ui( GLint location, GLuint v0, GLuint v1 );
00963   friend NVSG_API void GLUniform2uiv( GLint location, GLsizei count, const GLuint *value );
00964   friend NVSG_API void GLUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 );
00965   friend NVSG_API void GLUniform3fv( GLint location, GLsizei count, const GLfloat *value );
00966   friend NVSG_API void GLUniform3i( GLint location, GLint v0, GLint v1, GLint v2 );
00967   friend NVSG_API void GLUniform3iv( GLint location, GLsizei count, const GLint *value );
00968   friend NVSG_API void GLUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 );
00969   friend NVSG_API void GLUniform3uiv( GLint location, GLsizei count, const GLuint *value );
00970   friend NVSG_API void GLUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 );
00971   friend NVSG_API void GLUniform4fv( GLint location, GLsizei count, const GLfloat *value );
00972   friend NVSG_API void GLUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 );
00973   friend NVSG_API void GLUniform4iv( GLint location, GLsizei count, const GLint *value );
00974   friend NVSG_API void GLUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 );
00975   friend NVSG_API void GLUniform4uiv( GLint location, GLsizei count, const GLuint *value );
00976   friend NVSG_API void GLUniformBuffer( GLuint program, GLint location, GLuint buffer );
00977   friend NVSG_API void GLUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00978   friend NVSG_API void GLUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00979   friend NVSG_API void GLUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00980   friend NVSG_API void GLUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00981   friend NVSG_API void GLUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00982   friend NVSG_API void GLUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00983   friend NVSG_API void GLUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00984   friend NVSG_API void GLUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00985   friend NVSG_API void GLUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
00986   friend NVSG_API GLboolean GLUnmapBuffer( GLenum target );
00987   friend NVSG_API void GLUseProgram( GLuint program );
00988   friend NVSG_API void GLUseProgramObject( GLhandleARB programObj );
00989   friend NVSG_API GLboolean GLValidBackBufferHint( GLint x, GLint y, GLsizei width, GLsizei height );
00990   friend NVSG_API void GLValidateProgram( GLuint program );
00991   friend NVSG_API void GLVertex2d( GLdouble x, GLdouble y );
00992   friend NVSG_API void GLVertex2dv( const GLdouble *v );
00993   friend NVSG_API void GLVertex2f( GLfloat x, GLfloat y );
00994   friend NVSG_API void GLVertex2fv( const GLfloat *v );
00995   friend NVSG_API void GLVertex2h( GLhalf x, GLhalf y );
00996   friend NVSG_API void GLVertex2hv( const GLhalf *v );
00997   friend NVSG_API void GLVertex2i( GLint x, GLint y );
00998   friend NVSG_API void GLVertex2iv( const GLint *v );
00999   friend NVSG_API void GLVertex2s( GLshort x, GLshort y );
01000   friend NVSG_API void GLVertex2sv( const GLshort *v );
01001   friend NVSG_API void GLVertex3d( GLdouble x, GLdouble y, GLdouble z );
01002   friend NVSG_API void GLVertex3dv( const GLdouble *v );
01003   friend NVSG_API void GLVertex3f( GLfloat x, GLfloat y, GLfloat z );
01004   friend NVSG_API void GLVertex3fv( const GLfloat *v );
01005   friend NVSG_API void GLVertex3h( GLhalf x, GLhalf y, GLhalf z );
01006   friend NVSG_API void GLVertex3hv( const GLhalf *v );
01007   friend NVSG_API void GLVertex3i( GLint x, GLint y, GLint z );
01008   friend NVSG_API void GLVertex3iv( const GLint *v );
01009   friend NVSG_API void GLVertex3s( GLshort x, GLshort y, GLshort z );
01010   friend NVSG_API void GLVertex3sv( const GLshort *v );
01011   friend NVSG_API void GLVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
01012   friend NVSG_API void GLVertex4dv( const GLdouble *v );
01013   friend NVSG_API void GLVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
01014   friend NVSG_API void GLVertex4fv( const GLfloat *v );
01015   friend NVSG_API void GLVertex4h( GLhalf x, GLhalf y, GLhalf z, GLhalf w );
01016   friend NVSG_API void GLVertex4hv( const GLhalf *v );
01017   friend NVSG_API void GLVertex4i( GLint x, GLint y, GLint z, GLint w );
01018   friend NVSG_API void GLVertex4iv( const GLint *v );
01019   friend NVSG_API void GLVertex4s( GLshort x, GLshort y, GLshort z, GLshort w );
01020   friend NVSG_API void GLVertex4sv( const GLshort *v );
01021   friend NVSG_API void GLVertexArrayRange( GLsizei size, const GLvoid *pointer );
01022   friend NVSG_API void GLVertexAttrib1d( GLuint index, GLdouble x );
01023   friend NVSG_API void GLVertexAttrib1dv( GLuint index, const GLdouble *v );
01024   friend NVSG_API void GLVertexAttrib1f( GLuint index, GLfloat x );
01025   friend NVSG_API void GLVertexAttrib1fv( GLuint index, const GLfloat *v );
01026   friend NVSG_API void GLVertexAttrib1h( GLuint index, GLhalf x );
01027   friend NVSG_API void GLVertexAttrib1hv( GLuint index, const GLhalf *v );
01028   friend NVSG_API void GLVertexAttrib1s( GLuint index, GLshort x );
01029   friend NVSG_API void GLVertexAttrib1sv( GLuint index, const GLshort *v );
01030   friend NVSG_API void GLVertexAttrib2d( GLuint index, GLdouble x, GLdouble y );
01031   friend NVSG_API void GLVertexAttrib2dv( GLuint index, const GLdouble *v );
01032   friend NVSG_API void GLVertexAttrib2f( GLuint index, GLfloat x, GLfloat y );
01033   friend NVSG_API void GLVertexAttrib2fv( GLuint index, const GLfloat *v );
01034   friend NVSG_API void GLVertexAttrib2h( GLuint index, GLhalf x, GLhalf y );
01035   friend NVSG_API void GLVertexAttrib2hv( GLuint index, const GLhalf *v );
01036   friend NVSG_API void GLVertexAttrib2s( GLuint index, GLshort x, GLshort y );
01037   friend NVSG_API void GLVertexAttrib2sv( GLuint index, const GLshort *v );
01038   friend NVSG_API void GLVertexAttrib3d( GLuint index, GLdouble x, GLdouble y, GLdouble z );
01039   friend NVSG_API void GLVertexAttrib3dv( GLuint index, const GLdouble *v );
01040   friend NVSG_API void GLVertexAttrib3f( GLuint index, GLfloat x, GLfloat y, GLfloat z );
01041   friend NVSG_API void GLVertexAttrib3fv( GLuint index, const GLfloat *v );
01042   friend NVSG_API void GLVertexAttrib3h( GLuint index, GLhalf x, GLhalf y, GLhalf z );
01043   friend NVSG_API void GLVertexAttrib3hv( GLuint index, const GLhalf *v );
01044   friend NVSG_API void GLVertexAttrib3s( GLuint index, GLshort x, GLshort y, GLshort z );
01045   friend NVSG_API void GLVertexAttrib3sv( GLuint index, const GLshort *v );
01046   friend NVSG_API void GLVertexAttrib4bv( GLuint index, const GLbyte *v );
01047   friend NVSG_API void GLVertexAttrib4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
01048   friend NVSG_API void GLVertexAttrib4dv( GLuint index, const GLdouble *v );
01049   friend NVSG_API void GLVertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
01050   friend NVSG_API void GLVertexAttrib4fv( GLuint index, const GLfloat *v );
01051   friend NVSG_API void GLVertexAttrib4h( GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w );
01052   friend NVSG_API void GLVertexAttrib4hv( GLuint index, const GLhalf *v );
01053   friend NVSG_API void GLVertexAttrib4iv( GLuint index, const GLint *v );
01054   friend NVSG_API void GLVertexAttrib4s( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w );
01055   friend NVSG_API void GLVertexAttrib4sv( GLuint index, const GLshort *v );
01056   friend NVSG_API void GLVertexAttrib4ub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w );
01057   friend NVSG_API void GLVertexAttrib4ubv( GLuint index, const GLubyte *v );
01058   friend NVSG_API void GLVertexAttrib4uiv( GLuint index, const GLuint *v );
01059   friend NVSG_API void GLVertexAttrib4usv( GLuint index, const GLushort *v );
01060   friend NVSG_API void GLVertexAttrib4Nbv( GLuint index, const GLbyte *v );
01061   friend NVSG_API void GLVertexAttrib4Niv( GLuint index, const GLint *v );
01062   friend NVSG_API void GLVertexAttrib4Nsv( GLuint index, const GLshort *v );
01063   friend NVSG_API void GLVertexAttrib4Nub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w );
01064   friend NVSG_API void GLVertexAttrib4Nubv( GLuint index, const GLubyte *v );
01065   friend NVSG_API void GLVertexAttrib4Nuiv( GLuint index, const GLuint *v );
01066   friend NVSG_API void GLVertexAttrib4Nusv( GLuint index, const GLushort *v );
01067   friend NVSG_API void GLVertexAttribI1i( GLuint index, GLint x );
01068   friend NVSG_API void GLVertexAttribI1iv( GLuint index, const GLint *v );
01069   friend NVSG_API void GLVertexAttribI1ui( GLuint index, GLuint x );
01070   friend NVSG_API void GLVertexAttribI1uiv( GLuint index, const GLuint *v );
01071   friend NVSG_API void GLVertexAttribI2i( GLuint index, GLint x, GLint y );
01072   friend NVSG_API void GLVertexAttribI2iv( GLuint index, const GLint *v );
01073   friend NVSG_API void GLVertexAttribI2ui( GLuint index, GLuint x, GLuint y );
01074   friend NVSG_API void GLVertexAttribI2uiv( GLuint index, const GLuint *v );
01075   friend NVSG_API void GLVertexAttribI3i( GLuint index, GLint x, GLint y, GLint z );
01076   friend NVSG_API void GLVertexAttribI3iv( GLuint index, const GLint *v );
01077   friend NVSG_API void GLVertexAttribI3ui( GLuint index, GLuint x, GLuint y, GLuint z );
01078   friend NVSG_API void GLVertexAttribI3uiv( GLuint index, const GLuint *v );
01079   friend NVSG_API void GLVertexAttribI4bv( GLuint index, const GLbyte *v );
01080   friend NVSG_API void GLVertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w );
01081   friend NVSG_API void GLVertexAttribI4iv( GLuint index, const GLint *v );
01082   friend NVSG_API void GLVertexAttribI4sv( GLuint index, const GLshort *v );
01083   friend NVSG_API void GLVertexAttribI4ubv( GLuint index, const GLubyte *v );
01084   friend NVSG_API void GLVertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w );
01085   friend NVSG_API void GLVertexAttribI4uiv( GLuint index, const GLuint *v );
01086   friend NVSG_API void GLVertexAttribI4usv( GLuint index, const GLushort *v );
01087   friend NVSG_API void GLVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
01088   friend NVSG_API void GLVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalize, GLsizei stride, const GLvoid *pointer );
01089   friend NVSG_API void GLVertexAttribPointerNV( GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer );
01090   friend NVSG_API void GLVertexAttribs1dvNV( GLuint index, GLsizei count, const GLdouble *v );
01091   friend NVSG_API void GLVertexAttribs1fvNV( GLuint index, GLsizei count, const GLfloat *v );
01092   friend NVSG_API void GLVertexAttribs1hv( GLuint index, GLsizei count, const GLhalf *v );
01093   friend NVSG_API void GLVertexAttribs1svNV( GLuint index, GLsizei count, const GLshort *v );
01094   friend NVSG_API void GLVertexAttribs2dvNV( GLuint index, GLsizei count, const GLdouble *v );
01095   friend NVSG_API void GLVertexAttribs2fvNV( GLuint index, GLsizei count, const GLfloat *v );
01096   friend NVSG_API void GLVertexAttribs2hv( GLuint index, GLsizei count, const GLhalf *v );
01097   friend NVSG_API void GLVertexAttribs2svNV( GLuint index, GLsizei count, const GLshort *v );
01098   friend NVSG_API void GLVertexAttribs3dvNV( GLuint index, GLsizei count, const GLdouble *v );
01099   friend NVSG_API void GLVertexAttribs3fvNV( GLuint index, GLsizei count, const GLfloat *v );
01100   friend NVSG_API void GLVertexAttribs3hv( GLuint index, GLsizei count, const GLhalf *v );
01101   friend NVSG_API void GLVertexAttribs3svNV( GLuint index, GLsizei count, const GLshort *v );
01102   friend NVSG_API void GLVertexAttribs4dvNV( GLuint index, GLsizei count, const GLdouble *v );
01103   friend NVSG_API void GLVertexAttribs4fvNV( GLuint index, GLsizei count, const GLfloat *v );
01104   friend NVSG_API void GLVertexAttribs4hv( GLuint index, GLsizei count, const GLhalf *v );
01105   friend NVSG_API void GLVertexAttribs4svNV( GLuint index, GLsizei count, const GLshort *v );
01106   friend NVSG_API void GLVertexAttribs4ubvNV( GLuint index, GLsizei count, const GLubyte *v );
01107   friend NVSG_API void GLVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
01108   friend NVSG_API void GLViewport( GLint x, GLint y, GLsizei width, GLsizei height );
01109   friend NVSG_API void GLWindowBackBufferHint();
01110   friend NVSG_API void GLWindowPos2d( GLdouble x, GLdouble y );
01111   friend NVSG_API void GLWindowPos2dv( const GLdouble *p );
01112   friend NVSG_API void GLWindowPos2f( GLfloat x, GLfloat y );
01113   friend NVSG_API void GLWindowPos2fv( const GLfloat *p );
01114   friend NVSG_API void GLWindowPos2i( GLint x, GLint y );
01115   friend NVSG_API void GLWindowPos2iv( const GLint *p );
01116   friend NVSG_API void GLWindowPos2s( GLshort x, GLshort y );
01117   friend NVSG_API void GLWindowPos2sv( const GLshort *p );
01118   friend NVSG_API void GLWindowPos3d( GLdouble x, GLdouble y, GLdouble z );
01119   friend NVSG_API void GLWindowPos3dv( const GLdouble *p );
01120   friend NVSG_API void GLWindowPos3f( GLfloat x, GLfloat y, GLfloat z );
01121   friend NVSG_API void GLWindowPos3fv( const GLfloat *p );
01122   friend NVSG_API void GLWindowPos3i( GLint x, GLint y, GLint z );
01123   friend NVSG_API void GLWindowPos3iv( const GLint *p );
01124   friend NVSG_API void GLWindowPos3s( GLshort x, GLshort y, GLshort z );
01125   friend NVSG_API void GLWindowPos3sv( const GLshort *p );
01126   // EXT_framebuffer_object API
01127   friend NVSG_API GLboolean GLIsRenderbuffer(GLuint renderbuffer);
01128   friend NVSG_API void GLBindRenderbuffer(GLenum target, GLuint renderbuffer);
01129   friend NVSG_API void GLDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
01130   friend NVSG_API void GLGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
01131   friend NVSG_API void GLRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
01132   friend NVSG_API void GLRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
01133   friend NVSG_API void GLRenderbufferStorageMultisampleCoverage(GLenum target, GLsizei coverage, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
01134   friend NVSG_API void GLGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
01135   friend NVSG_API GLboolean GLIsFramebuffer(GLuint framebuffer);
01136   friend NVSG_API void GLBindFramebuffer(GLenum target, GLuint framebuffer);
01137   friend NVSG_API void GLDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
01138   friend NVSG_API void GLGenFramebuffers(GLsizei n, GLuint *framebuffers);
01139   friend NVSG_API GLenum GLCheckFramebufferStatus(GLenum target);
01140   friend NVSG_API void GLFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
01141   friend NVSG_API void GLFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
01142   friend NVSG_API void GLFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
01143   friend NVSG_API void GLFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
01144   friend NVSG_API void GLFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
01145   friend NVSG_API void GLGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
01146   friend NVSG_API void GLGenerateMipmap(GLenum target);
01147 #if defined(_WIN32)
01148   friend NVSG_API BOOL WGLBindTexImage( HPBUFFERARB hPbuffer, int iBuffer );
01149   friend NVSG_API BOOL WGLChoosePixelFormat( HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats );
01150   friend NVSG_API HGLRC WGLCreateContext( HDC hdc );
01151   friend NVSG_API HPBUFFERARB WGLCreatePbuffer( HDC hdc, int pixelFormat, int width, int height, const int *attribList );
01152   friend NVSG_API BOOL WGLDeleteContext( HGLRC hglrc );
01153   friend NVSG_API BOOL WGLDestroyPbuffer( HPBUFFERARB hPbuffer );
01154   friend NVSG_API HGLRC WGLGetCurrentContext(void);
01155   friend NVSG_API HDC WGLGetCurrentDC(void);
01156   friend NVSG_API BOOL WGLMakeCurrent( HDC hdc, HGLRC hglrc );
01157   friend NVSG_API HDC WGLGetPbufferDC( HPBUFFERARB hPbuffer );
01158   friend NVSG_API BOOL WGLQueryPbuffer( HPBUFFERARB hPbuffer, int attribute, int *value );
01159   friend NVSG_API int WGLReleasePbufferDC( HPBUFFERARB hPbuffer, HDC hdc );
01160   friend NVSG_API BOOL WGLReleaseTexImage( HPBUFFERARB hPbuffer, int iBuffer );
01161   friend NVSG_API BOOL WGLShareLists( HGLRC hglrc1, HGLRC hglrc2 );
01162   friend NVSG_API BOOL WGLJoinSwapGroupNV(HDC hDC, GLuint group);
01163   friend NVSG_API BOOL WGLBindSwapBarrierNV(GLuint group, GLuint barrier);
01164   friend NVSG_API BOOL WGLQuerySwapGroupNV(HDC hDC, GLuint * group, GLuint * barrier);
01165   friend NVSG_API BOOL WGLQueryMaxSwapGroupsNV(HDC hDC, GLuint * maxGroups, GLuint * maxBarriers);
01166   friend NVSG_API BOOL WGLQueryFrameCountNV(HDC hDC, GLuint * count);
01167   friend NVSG_API BOOL WGLResetFrameCountNV(HDC hDC);
01168   friend NVSG_API BOOL WGLEnumGpus(UINT iIndex, HGPUNV *hGpu);
01169   friend NVSG_API BOOL WGLEnumGpuDevices(HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice);
01170   friend NVSG_API HDC  WGLCreateAffinityDC(const HGPUNV *pGpuList);
01171   friend NVSG_API BOOL WGLEnumGpusFromAffinityDC(HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu);
01172   friend NVSG_API BOOL WGLDeleteDC(HDC hAffinityDC);
01173   // routines to handle bypassing of WGLCreateContext and WGLDeleteContext
01174   friend NVSG_API void WGLAttachContext(HDC, HGLRC);
01175   friend NVSG_API void WGLDetachContext(HGLRC);
01176 #endif
01177 #if defined(LINUX)
01178   friend NVSG_API GLXContext GLXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
01179   friend NVSG_API void GLXDestroyContext(Display *dpy, GLXContext ctx);
01180   friend NVSG_API GLXContext GLXGetCurrentContext();
01181   friend NVSG_API GLXDrawable GLXGetCurrentDrawable();
01182   friend NVSG_API Bool GLXMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx);
01183   // routines to handle bypassing of GLXCreateContext and GLXDestroyContext
01184   friend NVSG_API void GLXAttachContext(Display*, GLXContext);
01185   friend NVSG_API void GLXDetachContext(GLXContext);
01186
01187   // GLX_SGI_swap_control
01188   friend NVSG_API int GLXSwapInterval (int);
01189   // GLX_SGI_video_sync
01190   friend NVSG_API int GLXGetVideoSync (unsigned int *);
01191   friend NVSG_API int GLXWaitVideoSync (int, int, unsigned int *);
01192   // GLX_NV_swap_group
01193   friend NVSG_API Bool GLXJoinSwapGroup(Display *dpy, GLXDrawable drawable,
01194                                GLuint group);
01195   friend NVSG_API Bool GLXBindSwapBarrier(Display *dpy, GLuint group,
01196                                                               GLuint barrier);
01197   friend NVSG_API Bool GLXQuerySwapGroup(Display *dpy, GLXDrawable drawable,
01198                                 GLuint *group, GLuint *barrier);
01199   friend NVSG_API Bool GLXQueryMaxSwapGroups(Display *dpy, int screen,
01200                                     GLuint *maxGroups, GLuint *maxBarriers);
01201   friend NVSG_API Bool GLXQueryFrameCount(Display *dpy, int screen,
01202                                                               GLuint *count);
01203   friend NVSG_API Bool GLXResetFrameCount(Display *dpy, int screen);
01204
01205   // GLX_NV_video_out
01206   friend NVSG_API int GLXGetVideoDevice(Display *dpy, int screen,
01207                                 int numVideoDevices,
01208                                GLXVideoDeviceNV *pVideoDevice);
01209   friend NVSG_API int GLXReleaseVideoDevice(Display *dpy, int screen,
01210                                    GLXVideoDeviceNV VideoDevice);
01211   friend NVSG_API int GLXBindVideoImage(Display *dpy,
01212                                GLXVideoDeviceNV VideoDevice,
01213                                GLXPbuffer pbuf, int iVideoBuffer);
01214   friend NVSG_API int GLXReleaseVideoImage(Display *dpy, GLXPbuffer pbuf);
01215   friend NVSG_API int GLXSendPbufferToVideo(Display *dpy, GLXPbuffer pbuf,
01216                                    int iBufferType,
01217                                    unsigned long *pulCounterPbuffer,
01218                                    GLboolean bBlock);
01219   friend NVSG_API int GLXGetVideoInfo(Display *dpy, int screen,
01220                              GLXVideoDeviceNV VideoDevice,
01221                              unsigned long *pulCounterOutputVideo,
01222                              unsigned long *pulCounterOutputPbuffer);
01223   // GLX_EXT_texture_from_pixmap
01224   friend NVSG_API void GLXBindTexImage (Display *, GLXDrawable, int,
01225                                             const int *);
01226   friend NVSG_API void GLXReleaseTexImage (Display *, GLXDrawable, int);
01227 #endif
01228
01229   friend NVSG_API void GLResetAlphaFunc();
01230   friend NVSG_API void GLResetAlphaTest();
01231   friend NVSG_API void GLResetAutoNormal();
01232   friend NVSG_API void GLResetBlend();
01233   friend NVSG_API void GLResetBlendFunc();
01234   friend NVSG_API void GLResetBlendFuncSeparate();
01235   friend NVSG_API void GLResetClearColor();
01236   friend NVSG_API void GLResetClearDepth();
01237   friend NVSG_API void GLResetClearStencil();
01238   friend NVSG_API void GLResetClipPlane( GLenum plane );
01239   friend NVSG_API void GLResetClipPlaneEquation( GLenum plane );
01240   friend NVSG_API void GLResetColorLogicOp();
01241   friend NVSG_API void GLResetColorMask();
01242   friend NVSG_API void GLResetColorMaterial();
01243   friend NVSG_API void GLResetColorMaterialMode();
01244   friend NVSG_API void GLResetCullFace();
01245   friend NVSG_API void GLResetCullFaceMode();
01246   friend NVSG_API void GLResetDepthFunc();
01247   friend NVSG_API void GLResetDepthMask();
01248   friend NVSG_API void GLResetDepthRange();
01249   friend NVSG_API void GLResetDepthTest();
01250   friend NVSG_API void GLResetDither();
01251   friend NVSG_API void GLResetFog();
01252   friend NVSG_API void GLResetFogColor();
01253   friend NVSG_API void GLResetFogDensity();
01254   friend NVSG_API void GLResetFogEnd();
01255   friend NVSG_API void GLResetFogMode();
01256   friend NVSG_API void GLResetFogStart();
01257   friend NVSG_API void GLResetFrontFace();
01258   friend NVSG_API void GLResetLight( GLenum light );
01259   friend NVSG_API void GLResetLighting();
01260   friend NVSG_API void GLResetLightAmbient( GLenum light );
01261   friend NVSG_API void GLResetLightConstantAttenuation( GLenum light );
01262   friend NVSG_API void GLResetLightDiffuse( GLenum light );
01263   friend NVSG_API void GLResetLightLinearAttenuation( GLenum light );
01264   friend NVSG_API void GLResetLightModelAmbient();
01265   friend NVSG_API void GLResetLightModelLocalViewer();
01266   friend NVSG_API void GLResetLightModelTwoSide();
01267   friend NVSG_API void GLResetLightPosition( GLenum light );
01268   friend NVSG_API void GLResetLightQuadraticAttenuation( GLenum light );
01269   friend NVSG_API void GLResetLightSpecular( GLenum light );
01270   friend NVSG_API void GLResetLightSpotCutoff( GLenum light );
01271   friend NVSG_API void GLResetLightSpotDirection( GLenum light );
01272   friend NVSG_API void GLResetLightSpotExponent( GLenum light );
01273   friend NVSG_API void GLResetLineSmooth();
01274   friend NVSG_API void GLResetLineStipple();
01275   friend NVSG_API void GLResetLineStippleDefinition();
01276   friend NVSG_API void GLResetLineWidth();
01277   friend NVSG_API void GLResetLogicOp();
01278   friend NVSG_API void GLResetMaterialAmbientBack();
01279   friend NVSG_API void GLResetMaterialAmbientFront();
01280   friend NVSG_API void GLResetMaterialAmbientFrontAndBack();
01281   friend NVSG_API void GLResetMaterialDiffuseBack();
01282   friend NVSG_API void GLResetMaterialDiffuseFront();
01283   friend NVSG_API void GLResetMaterialDiffuseFrontAndBack();
01284   friend NVSG_API void GLResetMaterialEmissionBack();
01285   friend NVSG_API void GLResetMaterialEmissionFront();
01286   friend NVSG_API void GLResetMaterialEmissionFrontAndBack();
01287   friend NVSG_API void GLResetMaterialShininessBack();
01288   friend NVSG_API void GLResetMaterialShininessFront();
01289   friend NVSG_API void GLResetMaterialShininessFrontAndBack();
01290   friend NVSG_API void GLResetMaterialSpecularBack();
01291   friend NVSG_API void GLResetMaterialSpecularFront();
01292   friend NVSG_API void GLResetMaterialSpecularFrontAndBack();
01293   friend NVSG_API void GLResetNormalize();
01294   friend NVSG_API void GLResetPointSize();
01295   friend NVSG_API void GLResetPointSmooth();
01296   friend NVSG_API void GLResetPolygonModeBack();
01297   friend NVSG_API void GLResetPolygonModeFront();
01298   friend NVSG_API void GLResetPolygonModeFrontAndBack();
01299   friend NVSG_API void GLResetPolygonOffset();
01300   friend NVSG_API void GLResetPolygonOffsetFill();
01301   friend NVSG_API void GLResetPolygonOffsetLine();
01302   friend NVSG_API void GLResetPolygonOffsetPoint();
01303   friend NVSG_API void GLResetPolygonSmooth();
01304   friend NVSG_API void GLResetPolygonStipple();
01305   friend NVSG_API void GLResetScissor();
01306   friend NVSG_API void GLResetScissorTest();
01307   friend NVSG_API void GLResetShadeModel();
01308   friend NVSG_API void GLResetStencilFunc();
01309   friend NVSG_API void GLResetStencilMask();
01310   friend NVSG_API void GLResetStencilOp();
01311   friend NVSG_API void GLResetStencilTest();
01312   friend NVSG_API void GLResetTexture( GLenum target );
01313
01314   // effect methods
01315   friend NVSG_API void GLCgGLBindEffect( nvsg::CgFxEffect * effect );
01316   friend NVSG_API nvsg::CgFxEffect * GLCgGLGetEffect();
01317   friend NVSG_API void GLCgGLBindPass( nvsg::CgFxPass pass );
01318   friend NVSG_API nvsg::CgFxPass GLCgGLGetPass();
01319   friend NVSG_API void GLCgGLBindProgram( nvsg::CgFxProgram program );
01320   friend NVSG_API nvsg::CgFxProgram GLCgGLGetProgram();
01321   friend NVSG_API void GLCgGLApplyProgramSamplers();
01322
01323 #if !defined(DOXYGEN_IGNORE)
01324
01325   //  uncached versions of otherwise cached functions
01326   friend NVSG_API void _GLDisable( GLenum cap );
01327   friend NVSG_API void _GLDisableClientState( GLenum array );
01328   friend NVSG_API void _GLEnable( GLenum cap );
01329   friend NVSG_API void _GLEnableClientState( GLenum array );
01330   friend NVSG_API void _GLFogf( GLenum pname, GLfloat param );
01331   friend NVSG_API void _GLFogfv( GLenum pname, const GLfloat * params );
01332   friend NVSG_API void _GLFogi( GLenum pname, GLint param );
01333   friend NVSG_API void _GLFogiv( GLenum pname, const GLint * params );
01334   friend NVSG_API GLboolean _GLIsEnabled( GLenum cap );
01335   friend NVSG_API void _GLLightf( GLenum light, GLenum pname, GLfloat param );
01336   friend NVSG_API void _GLLightfv( GLenum light, GLenum pname, const GLfloat *params );
01337   friend NVSG_API void _GLLighti( GLenum light, GLenum pname, GLint param );
01338   friend NVSG_API void _GLLightiv( GLenum light, GLenum pname, GLint *params );
01339   friend NVSG_API void _GLLightModelf( GLenum pname, GLfloat param );
01340   friend NVSG_API void _GLLightModelfv( GLenum pname, const GLfloat *params );
01341   friend NVSG_API void _GLLightModeli( GLenum pname, GLint param );
01342   friend NVSG_API void _GLLightModeliv( GLenum pname, const GLint *params );
01343   friend NVSG_API void _GLMaterialf( GLenum face, GLenum pname, GLfloat param );
01344   friend NVSG_API void _GLMaterialfv( GLenum face, GLenum pname, const GLfloat *params );
01345   friend NVSG_API void _GLMateriali( GLenum face, GLenum pname, GLint param );
01346   friend NVSG_API void _GLMaterialiv( GLenum face, GLenum pname, const GLint *params );
01347   friend NVSG_API void _GLPolygonMode( GLenum face, GLenum mode );
01348   friend NVSG_API void _GLTexEnvf( GLenum target, GLenum pname, GLfloat param );
01349   friend NVSG_API void _GLTexEnvfv( GLenum target, GLenum pname, const GLfloat *params );
01350   friend NVSG_API void _GLTexEnvi( GLenum target, GLenum pname, GLint param );
01351   friend NVSG_API void _GLTexEnviv( GLenum target, GLenum pname, const GLint *params );
01352   friend NVSG_API void _GLTexParameterf( GLenum target, GLenum pname, GLfloat param );
01353   friend NVSG_API void _GLTexParameteri( GLenum target, GLenum pname, GLint param );
01354   friend NVSG_API void _GLTexParameterfv( GLenum target, GLenum pname, const GLfloat *params );
01355   friend NVSG_API void _GLTexParameteriv( GLenum target, GLenum pname, const GLint *params );
01356
01357 #if defined( GL_CACHING )
01358   friend NVSG_API void _GLUpdateActiveTexture( void );
01359   friend NVSG_API void _GLUpdateClientActiveTexture( void );
01360 #endif
01361
01362 #if !defined(NDEBUG)
01363   friend NVSG_API void ASSERT_GL_CURRENT_CONTEXT_CONFORMITY();
01364   friend NVSG_API void ASSERT_GL_ARRAY_BUFFER_BINDING();
01365   friend NVSG_API void ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
01366   friend NVSG_API void ASSERT_GL_PIXEL_PACK_BUFFER_BINDING();
01367   friend NVSG_API void ASSERT_GL_PIXEL_UNPACK_BUFFER_BINDING();
01368 #endif
01369
01370 #endif
01371
01372   friend NVSG_API void GLGenDisplayListCache(nvsg::DALHost * host, GLDisplayListCache *& cache);
01373   friend NVSG_API void GLDeleteDisplayListCaches();
01374   friend NVSG_API void GLGenArrayBufferCache(nvsg::DALHost * host, GLArrayBufferCache *& cache);
01375   friend NVSG_API void GLGenElementArrayBufferCache(nvsg::DALHost * host, GLElementArrayBufferCache *& cache);
01376   friend NVSG_API void GLGenPixelBufferCache(nvsg::DALHost * host, GLPixelBufferCache *& cache);
01377   friend NVSG_API void GLDeleteBufferCaches();
01378   friend NVSG_API void GLGenTextureCache(nvsg::DALHost * host, GLTextureCache *& cache);
01379   friend NVSG_API void GLGenTextureCache(nvsg::DALHost * host, GLTextureCache *& cache, GLuint texture, GLenum target);
01380   friend NVSG_API void GLDeleteTextureCaches();
01381
01382   friend NVSG_API bool GLIsValidDisplayListCache(const GLDisplayListCache * cache);
01383   friend NVSG_API bool GLIsValidArrayBufferCache(const GLArrayBufferCache * cache);
01384   friend NVSG_API bool GLIsValidElementArrayBufferCache(const GLElementArrayBufferCache * cache);
01385   friend NVSG_API bool GLIsValidPixelBufferCache(const GLPixelBufferCache * cache);
01386   friend NVSG_API bool GLIsValidTextureCache(const GLTextureCache * cache);
01387
01404   friend NVSG_API bool GLGetTexImageFmt( GLTexImageFmt & tfmt,
01405                 nvsg::Image::PixelFormat fmt, nvsg::Image::PixelDataType type,
01406                 nvsg::TextureImage::TextureGPUFormat gpuFmt =
01407                                             nvsg::TextureImage::TGF_DEFAULT );
01408
01409   friend NVSG_API void GLUploadTexImage1D(GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage*, GLTextureCache*);
01410   friend NVSG_API void GLUploadTexImage2D(GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage*, GLTextureCache*);
01411   friend NVSG_API void GLUploadTexImage3D(GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage*, GLTextureCache*);
01412   friend NVSG_API void GLUploadTexImageCube(GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage*, GLTextureCache*);
01413   friend NVSG_API void GLUploadTexImage1DArray(GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage*, GLTextureCache*);
01414   friend NVSG_API void GLUploadTexImage2DArray(GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage*, GLTextureCache*);
01415   friend NVSG_API void GLUploadTexImageRectangle(GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage*, GLTextureCache*);
01416
01417   friend NVSG_API GLenum GLGetTexWrapMode( nvsg::TextureWrapMode twm );
01418
01419 public:  // public interface
01420 #if defined(LINUX)
01421
01423   inline Display* getDisplay() { return m_dpy; }  // public access to the Display
01424 #endif
01425
01426 private: // private interface
01427
01428 #if defined(_WIN32)
01429   GLContext(HDC hdc, HGLRC hglrc);
01430 #elif defined(LINUX)
01431   GLContext(Display *dpy, GLXContext ctx);
01432 #endif
01433   ~GLContext();
01434
01435 #if defined(_WIN32)
01436   void init(); // init function pointers and caches
01437 #elif defined(LINUX)
01438   void init(GLXDrawable drw);
01439 #endif
01440   void exit(); // cleanup when context dies
01441
01442   void deleteGLObjects(); // deletes all GLObjects
01443   void deleteSharedGLObjects(); // deletes only shared GLObjects
01444
01445   // Share sharable GL objects with the GLContext referenced through \a source.
01446   void share(const GLContext& source);
01447
01448   // helper
01449
01450   void addBuffers(GLsizei n, const GLuint * names);
01451   void removeBuffers(GLsizei n, const GLuint * names);
01452   ConstNameSetIter firstBuffer() const;
01453   ConstNameSetIter lastBuffer() const;
01454   bool isBuffer(GLuint name) const;
01455   void releaseBuffers();
01456
01457   void addLists(GLsizei n, GLuint first);
01458   void removeLists(GLsizei n, GLuint first);
01459   ConstNameSetIter firstList() const;
01460   ConstNameSetIter lastList() const;
01461   bool isList(GLuint name) const;
01462   void releaseLists();
01463
01464   void addPrograms(GLsizei n, const GLuint * names);
01465   void removePrograms(GLsizei n, const GLuint * names);
01466   ConstNameSetIter firstProgram() const;
01467   ConstNameSetIter lastProgram() const;
01468   bool isProgram(GLuint name) const;
01469   void releasePrograms();
01470
01471   void addTextures(GLsizei n, const GLuint * names);
01472   void removeTextures(GLsizei n, const GLuint * names);
01473   ConstNameSetIter firstTexture() const;
01474   ConstNameSetIter lastTexture() const;
01475   bool isTexture(GLuint name) const;
01476   void releaseTextures();
01477
01478   void addOcclusionQueries(GLsizei n, const GLuint * names);
01479   void removeOcclusionQueries(GLsizei n, const GLuint * names);
01480   ConstNameSetIter firstOcclusionQuery() const;
01481   ConstNameSetIter lastOcclusionQuery() const;
01482   bool isOcclusionQuery(GLuint name) const;
01483   void releaseOcclusionQueries();
01484
01485   void addQueries(GLsizei n, const GLuint * names);
01486   void removeQueries(GLsizei n, const GLuint * names);
01487   ConstNameSetIter firstQuery() const;
01488   ConstNameSetIter lastQuery() const;
01489   bool isQuery(GLuint name) const;
01490   void releaseQueries();
01491
01492   void genTextureCache(nvsg::DALHost * host, GLTextureCache *& cache);
01493   void genTextureCache(nvsg::DALHost * host, GLTextureCache *& cache, GLuint texture, GLenum target);
01494   void deleteTextureCaches();
01495   void genDisplayListCache(nvsg::DALHost * host, GLDisplayListCache *& cache);
01496   void deleteDisplayListCaches();
01497   void genElementArrayBufferCache(nvsg::DALHost * host, GLElementArrayBufferCache *& cache);
01498   void genArrayBufferCache(nvsg::DALHost * host, GLArrayBufferCache *& cache);
01499   void genPixelBufferCache(nvsg::DALHost * host, GLPixelBufferCache *& cache);
01500   void deleteBufferCaches();
01501
01502   bool isValidDisplayListCache(const GLDisplayListCache * cache) const;
01503   bool isValidArrayBufferCache(const GLArrayBufferCache * cache) const;
01504   bool isValidElementArrayBufferCache(const GLElementArrayBufferCache * cache) const;
01505   bool isValidPixelBufferCache(const GLPixelBufferCache * cache) const;
01506   bool isValidTextureCache(const GLTextureCache * cache) const;
01507
01508 private:  //  private members
01509 #if defined( GL_CACHING )
01510   // helper struct to enable a GLint[2] to be stored in a STL container
01511   template <int I>
01512   struct BufferBinding
01513   {
01514     GLint& operator[] (int i) { NVSG_ASSERT(0<=i && i<I); return m_bindings[i]; }
01515     const GLint& operator[] (int i) const { NVSG_ASSERT(0<=i && i<I); return m_bindings[i]; }
01516     GLint m_bindings[I];
01517   };
01518   // and more expressive typedefs
01519   typedef BufferBinding<NVSG_NUM_VERTEX_BUFFERS> VertexBufferBinding;
01520   typedef BufferBinding<NVSG_NUM_PIXEL_BUFFERS> PixelBufferBinding;
01521
01522   class BufferBindingAttributes
01523   {
01524   public:
01525
01526     BufferBindingAttributes() {
01527       // init bindings to non-specified
01528       memset(m_bindings, 0, NVSG_NUM_BUFFERS * sizeof(GLint));
01529     }
01530
01531     // map GL buffer target to zero-based
01532     GLint& operator[] (GLenum target) {
01533       NVSG_ASSERT(  target==GL_ARRAY_BUFFER_ARB
01534                  || target==GL_ELEMENT_ARRAY_BUFFER_ARB
01535                  || target==GL_PIXEL_PACK_BUFFER_ARB
01536                  || target==GL_PIXEL_UNPACK_BUFFER_ARB );
01537       switch ( target )
01538       {
01539       case GL_ARRAY_BUFFER_ARB:         return m_bindings[NVSG_ARRAY_BUFFER];
01540       case GL_ELEMENT_ARRAY_BUFFER_ARB: return m_bindings[NVSG_ELEMENT_ARRAY_BUFFER];
01541       case GL_PIXEL_PACK_BUFFER_ARB:    return m_bindings[NVSG_PIXEL_PACK_BUFFER];
01542       case GL_PIXEL_UNPACK_BUFFER_ARB:  return m_bindings[NVSG_PIXEL_UNPACK_BUFFER];
01543       default : NVSG_ASSERT(!"unknown buffer target"); // undefined behavior if this fires!
01544       }
01545       return m_bindings[NVSG_ARRAY_BUFFER]; // return array buffer binding in case of error?!
01546                                        // don't know better
01547     }
01548
01549     void setVertexBufferBinding(const VertexBufferBinding& binding) {
01550       m_bindings[NVSG_ARRAY_BUFFER] = binding[0];
01551       m_bindings[NVSG_ELEMENT_ARRAY_BUFFER] = binding[1];
01552     }
01553
01554     const VertexBufferBinding& getVertexBufferBinding() const {
01555       return *((VertexBufferBinding *)&m_bindings[NVSG_FIRST_VERTEX_BUFFER]);
01556     }
01557
01558     void setPixelBufferBinding(const PixelBufferBinding& binding) {
01559       m_bindings[NVSG_PIXEL_PACK_BUFFER] = binding[0];
01560       m_bindings[NVSG_PIXEL_UNPACK_BUFFER] = binding[1];
01561     }
01562
01563     const PixelBufferBinding& getPixelBufferBinding() const {
01564       return *((PixelBufferBinding *)&m_bindings[NVSG_FIRST_PIXEL_BUFFER]);
01565     }
01566
01567   private:
01568     GLint m_bindings[NVSG_NUM_BUFFERS];
01569   };
01570
01571   class ColorBufferAttributes
01572   {
01573     public:
01574       ColorBufferAttributes( void )
01575         : m_alphaFunc(GL_ALWAYS)
01576         , m_alphaRef(0.0f)
01577         , m_blendSrcRGB(GL_ONE)
01578         , m_blendSrcAlpha(GL_ONE)
01579         , m_blendDstRGB(GL_ZERO)
01580         , m_blendDstAlpha(GL_ZERO)
01581         , m_clearColor(0.0f,0.0f,0.0f,0.0f)
01582       {
01583         for ( size_t i=0 ; i<4 ; i++ )
01584         {
01585           m_colorWriteMask[i] = GL_TRUE;
01586         }
01587       }
01588
01589     public:
01590       GLenum        m_alphaFunc;
01591       GLclampf      m_alphaRef;
01592       GLboolean     m_colorWriteMask[4];
01593       GLenum        m_blendSrcRGB;
01594       GLenum        m_blendSrcAlpha;
01595       GLenum        m_blendDstRGB;
01596       GLenum        m_blendDstAlpha;
01597       nvmath::Vec4f m_clearColor;
01598   };
01599
01600   class ColorBufferEnableAttributes
01601   {
01602     public:
01603       ColorBufferEnableAttributes( void )
01604         : m_alphaTest(GL_FALSE)
01605         , m_blend(GL_FALSE)
01606         , m_colorLogicOp(GL_FALSE)
01607         , m_dither(GL_TRUE)
01608         , m_logicOp(GL_FALSE)
01609       {}
01610
01611     public:
01612       GLboolean m_alphaTest;
01613       GLboolean m_blend;
01614       GLboolean m_colorLogicOp;
01615       GLboolean m_dither;
01616       GLboolean m_logicOp;
01617   };
01618
01619   class DepthBufferAttributes
01620   {
01621     public:
01622       DepthBufferAttributes( void )
01623         : m_depthClearValue(1.0f)
01624         , m_depthFunc(GL_LESS)
01625         , m_depthWriting(GL_TRUE)
01626       {}
01627
01628     public:
01629       GLclampd  m_depthClearValue;
01630       GLenum    m_depthFunc;
01631       GLboolean m_depthWriting;
01632   };
01633
01634   class DepthBufferEnableAttributes
01635   {
01636     public:
01637       DepthBufferEnableAttributes( void )
01638         : m_depthTesting(GL_FALSE)
01639       {}
01640
01641     public:
01642       GLboolean m_depthTesting;
01643   };
01644
01645   class EvalAttributes
01646   {
01647     public:
01648       EvalAttributes( void )
01649         : m_autoNormal(GL_FALSE)
01650       {}
01651
01652     public:
01653       GLboolean m_autoNormal;
01654   };
01655
01656   class FogAttributes
01657   {
01658     public:
01659       FogAttributes()
01660         : m_color(0.0f,0.0f,0.0f,0.0f)
01661         , m_density(1.0f)
01662         , m_end(1.0f)
01663         , m_mode(GL_EXP)
01664         , m_start(0.0f)
01665       {}
01666
01667     public:
01668       nvmath::Vec4f m_color;
01669       GLfloat       m_density;
01670       GLfloat       m_end;
01671       GLenum        m_mode;
01672       GLfloat       m_start;
01673   };
01674
01675   class FogEnableAttributes
01676   {
01677     public:
01678       FogEnableAttributes( void )
01679         : m_fog(GL_FALSE)
01680       {}
01681
01682     public:
01683       GLboolean m_fog;
01684   };
01685
01686   class LightParameters
01687   {
01688     public:
01689       LightParameters( void )
01690         : m_ambient(0.0f,0.0f,0.0f,1.0f)
01691         , m_attenuation(1.0f,0.0f,0.0f)
01692         , m_diffuse(0.0f,0.0f,0.0f,1.0f)
01693         , m_position(0.0f,0.0f,1.0f,0.0f)
01694         , m_specular(0.0f,0.0f,0.0f,1.0f)
01695         , m_spotCutoff(180.0f)
01696         , m_spotDirection(0.0f,0.0f,-1.0f,0.0f)
01697         , m_spotExponent(0.0f)
01698       {}
01699
01700     public:
01701       nvmath::Vec4f m_ambient;
01702       nvmath::Vec3f m_attenuation;
01703       nvmath::Vec4f m_diffuse;
01704       nvmath::Vec4f m_position;
01705       nvmath::Vec4f m_specular;
01706       float         m_spotCutoff;
01707       nvmath::Vec4f m_spotDirection;
01708       float         m_spotExponent;
01709   };
01710
01711   class LightingAttributes
01712   {
01713     public:
01714       LightingAttributes( void )
01715         : m_colorMaterial(GL_FALSE)
01716         , m_colorMaterialFace(GL_FRONT_AND_BACK)
01717         , m_colorMaterialMode(GL_AMBIENT_AND_DIFFUSE)
01718         , m_lightModelLocalViewer(GL_FALSE)
01719         , m_lightModelTwoSide(GL_FALSE)
01720         , m_lightModelAmbient(0.2f,0.2f,0.2f,1.0f)
01721         , m_shadeModel(GL_SMOOTH)
01722       {
01723         m_materialAmbient[NVSG_CACHE_FRONT]   = m_materialAmbient[NVSG_CACHE_BACK]   = nvmath::Vec4f( 0.2f, 0.2f, 0.2f, 1.0f );
01724         m_materialDiffuse[NVSG_CACHE_FRONT]   = m_materialDiffuse[NVSG_CACHE_BACK]   = nvmath::Vec4f( 0.8f, 0.8f, 0.8f, 1.0f );
01725         m_materialSpecular[NVSG_CACHE_FRONT]  = m_materialSpecular[NVSG_CACHE_BACK]  = nvmath::Vec4f( 0.0f, 0.0f, 0.0f, 1.0f );
01726         m_materialEmission[NVSG_CACHE_FRONT]  = m_materialEmission[NVSG_CACHE_BACK]  = nvmath::Vec4f( 0.0f, 0.0f, 0.0f, 1.0f );
01727         m_materialShininess[NVSG_CACHE_FRONT] = m_materialShininess[NVSG_CACHE_BACK] = 0.0f;
01728       }
01729
01730     public:
01731       GLboolean                     m_colorMaterial;
01732       GLenum                        m_colorMaterialFace;
01733       GLenum                        m_colorMaterialMode;
01734       GLboolean                     m_lightModelLocalViewer;
01735       GLboolean                     m_lightModelTwoSide;
01736       nvmath::Vec4f                 m_lightModelAmbient;
01737       std::vector<LightParameters>  m_lightParameters;
01738       nvmath::Vec4f                 m_materialAmbient[2];
01739       nvmath::Vec4f                 m_materialDiffuse[2];
01740       nvmath::Vec4f                 m_materialSpecular[2];
01741       nvmath::Vec4f                 m_materialEmission[2];
01742       float                         m_materialShininess[2];
01743       GLenum                        m_shadeModel;
01744   };
01745
01746   class LightingEnableAttributes
01747   {
01748     public:
01749       LightingEnableAttributes( void )
01750         : m_lighting(GL_FALSE)
01751       {}
01752
01753     public:
01754       std::vector<GLboolean>  m_lights;
01755       GLboolean               m_lighting;
01756   };
01757
01758   class LineAttributes
01759   {
01760     public:
01761       LineAttributes( void )
01762         : m_width(1.0f)
01763         , m_stipplePattern(0xFFFF)
01764         , m_stippleRepeat(1)
01765       {}
01766
01767     public:
01768       float     m_width;
01769       GLushort  m_stipplePattern;
01770       GLint     m_stippleRepeat;
01771   };
01772
01773   class LineEnableAttributes
01774   {
01775     public:
01776       LineEnableAttributes( void )
01777         : m_smooth(GL_FALSE)
01778         , m_stipple(GL_FALSE)
01779       {}
01780
01781     public:
01782       GLboolean m_smooth;
01783       GLboolean m_stipple;
01784   };
01785
01786   class PointAttributes
01787   {
01788     public:
01789       PointAttributes( void )
01790         : m_size(1.0f)
01791       {}
01792
01793     public:
01794       float m_size;
01795   };
01796
01797   class PointEnableAttributes
01798   {
01799     public:
01800       PointEnableAttributes( void )
01801         : m_smooth(GL_FALSE)
01802       {}
01803
01804     public:
01805       GLboolean m_smooth;
01806   };
01807
01808   class PolygonAttributes
01809   {
01810     public:
01811       PolygonAttributes( void )
01812         : m_cullFaceMode(GL_BACK)
01813         , m_frontFaceMode(GL_CCW)
01814         , m_offsetFactor(0.0f)
01815         , m_offsetBias(0.0f)
01816       {
01817         m_rasterMode[NVSG_CACHE_FRONT] = m_rasterMode[NVSG_CACHE_BACK] = GL_FILL;
01818       }
01819
01820
01821     public:
01822       GLenum  m_cullFaceMode;
01823       GLenum  m_frontFaceMode;
01824       GLenum  m_rasterMode[2];
01825       GLfloat m_offsetFactor;
01826       GLfloat m_offsetBias;
01827   };
01828
01829   class PolygonEnableAttributes
01830   {
01831     public:
01832       PolygonEnableAttributes( void )
01833         : m_cullFace(GL_FALSE)
01834         , m_offsetFill(GL_FALSE)
01835         , m_offsetLine(GL_FALSE)
01836         , m_offsetPoint(GL_FALSE)
01837         , m_smooth(GL_FALSE)
01838         , m_stipple(GL_FALSE)
01839       {}
01840
01841     public:
01842       GLboolean m_cullFace;
01843       GLboolean m_offsetFill;
01844       GLboolean m_offsetLine;
01845       GLboolean m_offsetPoint;
01846       GLboolean m_smooth;
01847       GLboolean m_stipple;
01848   };
01849
01850   class ScissorAttributes
01851   {
01852     public:
01853       GLint   m_x;
01854       GLint   m_y;
01855       GLsizei m_width;
01856       GLsizei m_height;
01857   };
01858
01859   class ScissorEnableAttributes
01860   {
01861     public:
01862       ScissorEnableAttributes()
01863         : m_scissorTest(GL_FALSE)
01864       {}
01865
01866     public:
01867       GLboolean m_scissorTest;
01868   };
01869
01870   class StencilBufferAttributes
01871   {
01872     public:
01873       StencilBufferAttributes( void )
01874         : m_stencilClearValue(0)
01875         , m_stencilFail(GL_KEEP)
01876         , m_stencilFunc(GL_ALWAYS)
01877         , m_stencilPassDepthFail(GL_KEEP)
01878         , m_stencilPassDepthPass(GL_KEEP)
01879         , m_stencilRef(0)
01880         , m_stencilWriteMask(0xFFFFFFFF)
01881         , m_stencilValueMask(0xFFFFFFFF)
01882       {}
01883
01884     public:
01885       GLint   m_stencilClearValue;
01886       GLenum  m_stencilFail;
01887       GLenum  m_stencilFunc;
01888       GLenum  m_stencilPassDepthFail;
01889       GLenum  m_stencilPassDepthPass;
01890       GLint   m_stencilRef;
01891       GLuint  m_stencilWriteMask;
01892       GLuint  m_stencilValueMask;
01893   };
01894
01895   class StencilBufferEnableAttributes
01896   {
01897     public:
01898       StencilBufferEnableAttributes()
01899         :m_stencilTest(GL_FALSE)
01900       {}
01901
01902     public:
01903       GLboolean m_stencilTest;
01904   };
01905
01906   class TextureAttributesPerUnit
01907   {
01908     public:
01909       TextureAttributesPerUnit( void )
01910         : m_envColor(0.0f,0.0f,0.0f,0.0f)
01911         , m_envMode(GL_MODULATE)
01912       {}
01913
01914     public:
01915       nvmath::Vec4f                       m_envColor;
01916       GLenum                              m_envMode;
01917   };
01918
01919   class TextureAttributes
01920   {
01921     public:
01922       TextureAttributes( void )
01923         : m_active(0)
01924         , m_toActivate(0)
01925       {}
01926
01927     public:
01928       std::vector<TextureAttributesPerUnit> m_unit;
01929       GLenum                                m_active;
01930       GLenum                                m_toActivate;
01931   };
01932
01933   class TextureEnableParameters
01934   {
01935     public:
01936       TextureEnableParameters( void )
01937       {
01938         for ( size_t i=0 ; i<4 ; i++ )
01939         {
01940           m_gen[i] = GL_FALSE;
01941         }
01942       }
01943
01944     public:
01945       std::map<GLenum,GLboolean>  m_texture;  // texture enable per target
01946       GLboolean                   m_gen[4];
01947   };
01948
01949   class TextureEnableAttributes
01950   {
01951     public:
01952       std::vector<TextureEnableParameters> m_unit;
01953   };
01954
01955   class TransformAttributes
01956   {
01957     public:
01958       TransformAttributes( void )
01959         : m_matrixMode(GL_MODELVIEW)
01960       {}
01961
01962     public:
01963       std::vector<nvmath::Vec4d>  m_clipPlaneEquations;
01964       GLenum                      m_matrixMode;
01965   };
01966
01967   class TransformEnableAttributes
01968   {
01969     public:
01970       TransformEnableAttributes( void )
01971         : m_normalize(GL_FALSE)
01972       {}
01973
01974     public:
01975       std::vector<GLboolean>  m_clipPlanes;
01976       GLboolean               m_normalize;
01977   };
01978
01979   class VertexArrayAttributes
01980   {
01981     public:
01982       VertexArrayAttributes( void )
01983         : m_vertexArray(GL_FALSE)
01984         , m_normalArray(GL_FALSE)
01985         , m_colorArray(GL_FALSE)
01986         , m_secondaryColorArray(GL_FALSE)
01987         , m_fogCoordArray(GL_FALSE)
01988         , m_primitiveRestartIndex(0)
01989         , m_clientTextureActive(0)
01990         , m_clientTextureToActivate(0)
01991       {}
01992
01993     public:
01994       GLboolean                           m_vertexArray;
01995       GLboolean                           m_normalArray;
01996       GLboolean                           m_colorArray;
01997       GLboolean                           m_secondaryColorArray;
01998       GLboolean                           m_fogCoordArray;
01999       std::vector<GLboolean>              m_textureCoordArray;
02000       std::vector<GLboolean>              m_vertexAttribArray;
02001       GLuint                              m_primitiveRestartIndex;
02002       GLenum                              m_clientTextureActive;
02003       GLenum                              m_clientTextureToActivate;
02004   };
02005
02006   class ViewportAttributes
02007   {
02008     public:
02009       ViewportAttributes( void )
02010         : m_depthRangeFar(1.0)
02011         , m_depthRangeNear(0.0)
02012       {}
02013
02014     public:
02015       GLclampd  m_depthRangeFar;
02016       GLclampd  m_depthRangeNear;
02017   };
02018
02019   BufferBindingAttributes       m_bufferBindingAttributes; // vertex and pixel buffer binding states
02020   ColorBufferAttributes         m_colorBufferAttributes;
02021   ColorBufferEnableAttributes   m_colorBufferEnableAttributes;
02022   DepthBufferAttributes         m_depthBufferAttributes;
02023   DepthBufferEnableAttributes   m_depthBufferEnableAttributes;
02024   EvalAttributes                m_evalAttributes;
02025   FogAttributes                 m_fogAttributes;
02026   FogEnableAttributes           m_fogEnableAttributes;
02027   LightingAttributes            m_lightingAttributes;
02028   LightingEnableAttributes      m_lightingEnableAttributes;
02029   LineAttributes                m_lineAttributes;
02030   LineEnableAttributes          m_lineEnableAttributes;
02031   PointAttributes               m_pointAttributes;
02032   PointEnableAttributes         m_pointEnableAttributes;
02033   PolygonAttributes             m_polygonAttributes;
02034   PolygonEnableAttributes       m_polygonEnableAttributes;
02035   ScissorAttributes             m_scissorAttributes;
02036   ScissorEnableAttributes       m_scissorEnableAttributes;
02037   StencilBufferAttributes       m_stencilBufferAttributes;
02038   StencilBufferEnableAttributes m_stencilBufferEnableAttributes;
02039   TextureAttributes             m_textureAttributes;
02040   TextureEnableAttributes       m_textureEnableAttributes;
02041   TransformAttributes           m_transformAttributes;
02042   TransformEnableAttributes     m_transformEnableAttributes;
02043   VertexArrayAttributes         m_vertexArrayAttributes;
02044   ViewportAttributes            m_viewportAttributes;
02045
02046   std::stack<GLbitfield>                    m_pushMasks;
02047   std::stack<GLbitfield>                    m_clientPushMasks;
02048   std::stack<ColorBufferAttributes>         m_colorBufferAttributesStack;
02049   std::stack<ColorBufferEnableAttributes>   m_colorBufferEnableAttributesStack;
02050   std::stack<DepthBufferAttributes>         m_depthBufferAttributesStack;
02051   std::stack<DepthBufferEnableAttributes>   m_depthBufferEnableAttributesStack;
02052   std::stack<EvalAttributes>                m_evalAttributesStack;
02053   std::stack<FogAttributes>                 m_fogAttributesStack;
02054   std::stack<FogEnableAttributes>           m_fogEnableAttributesStack;
02055   std::stack<LightingAttributes>            m_lightingAttributesStack;
02056   std::stack<LightingEnableAttributes>      m_lightingEnableAttributesStack;
02057   std::stack<LineAttributes>                m_lineAttributesStack;
02058   std::stack<LineEnableAttributes>          m_lineEnableAttributesStack;
02059   std::stack<PointAttributes>               m_pointAttributesStack;
02060   std::stack<PointEnableAttributes>         m_pointEnableAttributesStack;
02061   std::stack<PolygonAttributes>             m_polygonAttributesStack;
02062   std::stack<PolygonEnableAttributes>       m_polygonEnableAttributesStack;
02063   std::stack<ScissorAttributes>             m_scissorAttributesStack;
02064   std::stack<ScissorEnableAttributes>       m_scissorEnableAttributesStack;
02065   std::stack<StencilBufferAttributes>       m_stencilBufferAttributesStack;
02066   std::stack<StencilBufferEnableAttributes> m_stencilBufferEnableAttributesStack;
02067   std::stack<TextureAttributes>             m_textureAttributesStack;
02068   std::stack<TextureEnableAttributes>       m_textureEnableAttributesStack;
02069   std::stack<TransformAttributes>           m_transformAttributesStack;
02070   std::stack<TransformEnableAttributes>     m_transformEnableAttributesStack;
02071   std::stack<VertexArrayAttributes>         m_vertexArrayAttributesStack;
02072   std::stack<ViewportAttributes>            m_viewportAttributesStack;
02073   std::stack<VertexBufferBinding>           m_vertexBufferBindingAttributesStack;
02074   std::stack<PixelBufferBinding>            m_pixelBufferBindingAttributesStack;
02075
02076 # if defined(GL_SUPPORT_RESET)
02077   class PreviousAttributes
02078   {
02079     public:
02080       PreviousAttributes()
02081         : m_alphaFunc(GL_ALWAYS)
02082         , m_alphaRef(0.0f)
02083         , m_alphaTest(GL_FALSE)
02084         , m_autoNormal(GL_FALSE)
02085         , m_blend(GL_FALSE)
02086         , m_blendSrcRGB(GL_ONE)
02087         , m_blendSrcAlpha(GL_ONE)
02088         , m_blendDstRGB(GL_ZERO)
02089         , m_blendDstAlpha(GL_ZERO)
02090         , m_clearColor(0.0f,0.0f,0.0f,0.0f)
02091         , m_colorLogicOp(GL_FALSE)
02092         , m_colorMaterial(GL_FALSE)
02093         , m_colorMaterialFace(GL_FRONT_AND_BACK)
02094         , m_colorMaterialMode(GL_AMBIENT_AND_DIFFUSE)
02095         , m_cullFace(GL_FALSE)
02096         , m_cullFaceMode(GL_BACK)
02097         , m_depthClearValue(1.0f)
02098         , m_depthFunc(GL_LESS)
02099         , m_depthRangeFar(1.0)
02100         , m_depthRangeNear(0.0)
02101         , m_depthTesting(GL_FALSE)
02102         , m_depthWriting(GL_TRUE)
02103         , m_dither(GL_TRUE)
02104         , m_fog(GL_FALSE)
02105         , m_fogColor(0.0f,0.0f,0.0f,0.0f)
02106         , m_fogDensity(1.0f)
02107         , m_fogEnd(1.0f)
02108         , m_fogMode(GL_EXP)
02109         , m_fogStart(0.0f)
02110         , m_frontFaceMode(GL_CCW)
02111         , m_lighting(GL_FALSE)
02112         , m_lightModelAmbient(0.2f,0.2f,0.2f,1.0f)
02113         , m_lightModelLocalViewer(GL_FALSE)
02114         , m_lightModelTwoSide(GL_FALSE)
02115         , m_lineSmooth(GL_FALSE)
02116         , m_lineStipple(GL_FALSE)
02117         , m_lineStipplePattern(0xFFFF)
02118         , m_lineStippleRepeat(1)
02119         , m_lineWidth(1.0f)
02120         , m_logicOp(GL_FALSE)
02121         , m_normalize(GL_FALSE)
02122         , m_pointSize(1.0f)
02123         , m_pointSmooth(GL_FALSE)
02124         , m_polygonOffsetFactor(0.0f)
02125         , m_polygonOffsetBias(0.0f)
02126         , m_polygonSmooth(GL_FALSE)
02127         , m_polygonStipple(GL_FALSE)
02128         , m_offsetFill(GL_FALSE)
02129         , m_offsetLine(GL_FALSE)
02130         , m_offsetPoint(GL_FALSE)
02131         , m_scissorTest(GL_FALSE)
02132         , m_shadeModel(GL_SMOOTH)
02133         , m_stencilClearValue(0)
02134         , m_stencilFail(GL_KEEP)
02135         , m_stencilFunc(GL_ALWAYS)
02136         , m_stencilPassDepthFail(GL_KEEP)
02137         , m_stencilPassDepthPass(GL_KEEP)
02138         , m_stencilRef(0)
02139         , m_stencilTest(GL_FALSE)
02140         , m_stencilValueMask(0xFFFFFFFF)
02141         , m_stencilWriteMask(0xFFFFFFFF)
02142       {
02143         for ( size_t i=0 ; i<4 ; i++ )
02144         {
02145           m_colorWriteMask[i] = GL_TRUE;
02146         }
02147         m_materialAmbient[NVSG_CACHE_FRONT]   = m_materialAmbient[NVSG_CACHE_BACK]   = nvmath::Vec4f( 0.2f, 0.2f, 0.2f, 1.0f );
02148         m_materialDiffuse[NVSG_CACHE_FRONT]   = m_materialDiffuse[NVSG_CACHE_BACK]   = nvmath::Vec4f( 0.8f, 0.8f, 0.8f, 1.0f );
02149         m_materialSpecular[NVSG_CACHE_FRONT]  = m_materialSpecular[NVSG_CACHE_BACK]  = nvmath::Vec4f( 0.0f, 0.0f, 0.0f, 1.0f );
02150         m_materialEmission[NVSG_CACHE_FRONT]  = m_materialEmission[NVSG_CACHE_BACK]  = nvmath::Vec4f( 0.0f, 0.0f, 0.0f, 1.0f );
02151         m_materialShininess[NVSG_CACHE_FRONT] = m_materialShininess[NVSG_CACHE_BACK] = 0.0f;
02152         m_rasterMode[NVSG_CACHE_FRONT] = m_rasterMode[NVSG_CACHE_BACK] = GL_FILL;
02153       }
02154
02155     public:
02156       GLenum                                m_alphaFunc;
02157       GLclampf                              m_alphaRef;
02158       GLboolean                             m_alphaTest;
02159       GLboolean                             m_autoNormal;
02160       GLboolean                             m_blend;
02161       GLenum                                m_blendSrcRGB;
02162       GLenum                                m_blendSrcAlpha;
02163       GLenum                                m_blendDstRGB;
02164       GLenum                                m_blendDstAlpha;
02165       nvmath::Vec4f                         m_clearColor;
02166       std::vector<GLboolean>                m_clipPlanes;
02167       std::vector<nvmath::Vec4d>            m_clipPlaneEquations;
02168       GLboolean                             m_colorLogicOp;
02169       GLboolean                             m_colorMaterial;
02170       GLenum                                m_colorMaterialFace;
02171       GLenum                                m_colorMaterialMode;
02172       GLboolean                             m_colorWriteMask[4];
02173       GLboolean                             m_cullFace;
02174       GLenum                                m_cullFaceMode;
02175       GLclampd                              m_depthClearValue;
02176       GLenum                                m_depthFunc;
02177       GLclampd                              m_depthRangeFar;
02178       GLclampd                              m_depthRangeNear;
02179       GLboolean                             m_depthTesting;
02180       GLboolean                             m_depthWriting;
02181       GLboolean                             m_dither;
02182       GLboolean                             m_fog;
02183       nvmath::Vec4f                         m_fogColor;
02184       GLfloat                               m_fogDensity;
02185       GLfloat                               m_fogEnd;
02186       GLenum                                m_fogMode;
02187       GLfloat                               m_fogStart;
02188       GLenum                                m_frontFaceMode;
02189       GLboolean                             m_lighting;
02190       std::vector<GLboolean>                m_lights;
02191       nvmath::Vec4f                         m_lightModelAmbient;
02192       std::vector<LightParameters>          m_lightParameters;
02193       GLboolean                             m_lightModelLocalViewer;
02194       GLboolean                             m_lightModelTwoSide;
02195       GLboolean                             m_lineSmooth;
02196       GLboolean                             m_lineStipple;
02197       GLushort                              m_lineStipplePattern;
02198       GLint                                 m_lineStippleRepeat;
02199       GLfloat                               m_lineWidth;
02200       GLboolean                             m_logicOp;
02201       nvmath::Vec4f                         m_materialAmbient[2];
02202       nvmath::Vec4f                         m_materialDiffuse[2];
02203       nvmath::Vec4f                         m_materialSpecular[2];
02204       nvmath::Vec4f                         m_materialEmission[2];
02205       float                                 m_materialShininess[2];
02206       GLboolean                             m_normalize;
02207       GLfloat                               m_pointSize;
02208       GLboolean                             m_pointSmooth;
02209       GLfloat                               m_polygonOffsetFactor;
02210       GLfloat                               m_polygonOffsetBias;
02211       GLboolean                             m_polygonSmooth;
02212       GLboolean                             m_polygonStipple;
02213       GLboolean                             m_offsetFill;
02214       GLboolean                             m_offsetLine;
02215       GLboolean                             m_offsetPoint;
02216       GLenum                                m_rasterMode[2];
02217       GLsizei                               m_scissorHeight;
02218       GLboolean                             m_scissorTest;
02219       GLsizei                               m_scissorWidth;
02220       GLint                                 m_scissorX;
02221       GLint                                 m_scissorY;
02222       GLenum                                m_shadeModel;
02223       GLint                                 m_stencilClearValue;
02224       GLenum                                m_stencilFail;
02225       GLenum                                m_stencilFunc;
02226       GLenum                                m_stencilPassDepthFail;
02227       GLenum                                m_stencilPassDepthPass;
02228       GLint                                 m_stencilRef;
02229       GLboolean                             m_stencilTest;
02230       GLuint                                m_stencilValueMask;
02231       GLuint                                m_stencilWriteMask;
02232       std::vector<TextureEnableParameters>  m_textureEnables;
02233   };
02234
02235   PreviousAttributes  m_previousAttributes;
02236 # endif // GL_SUPPORT_RESET
02237
02238 #endif // GL_CACHING
02239   GLObjects     * m_glObjects;    // managing shareable and non-shareable objects
02240
02241   // effect interface data
02242   struct
02243   {
02244     nvsg::CgFxEffect * effect;  // to access the CgFxEffect interface
02245     nvsg::CgFxPass     pass;    // currently applied pass
02246     nvsg::CgFxProgram  program; // currently applied program
02247   } m_cgBinding;
02248
02249   class GLLocks
02250   {
02251     public:
02252       GLLocks( void );
02253
02254     public:
02255       bool  m_cullFace;
02256       bool  m_cullFaceMode;
02257       bool  m_lighting;
02258       bool  m_lightModelTwoSide;
02259       bool  m_polygonMode;
02260   };
02261
02262   GLLocks         m_locks;
02263
02264 #if defined(_WIN32)
02265   HDC             m_hdc;        // Handle to the corresponding device context
02266   HGLRC           m_hglrc;      // Handle of the corresponding GL render context
02267 #elif defined(LINUX)
02268   static Display * m_dpy;       // Handle to corresponding X display
02269   GLXContext       m_ctx;       // Handle to corresponding X render context
02270   GLXDrawable      m_drawable;  // Handle to corresponding X drawable
02271 #endif
02272
02273   GLFunctions   * m_glFunctions;  // Pointer to OpenGL functions wrapper object
02274   GLint           m_maxVertexAttribs; // Maximal number of vertex attributes supported
02275   GLint           m_maxTexCoords; // Maximal number of supported client texture slots on this HW
02276   GLint           m_maxTexUnits;  // Maximal number of supported texture slots on this HW
02277   GLint           m_maxTexImageUnits;  // Maximal number of supported texture image units on this HW
02278
02279   // Table of texture image formats mapping given PixelFormat and PixelDataType descriptors to a
02280   // 'best match' GL format. This table will be initialized at GLContext construction.
02281   NVSGTexImageFmt m_glTexImageFmts[nvsg::Image::IMG_NUM_FORMATS][nvsg::Image::IMG_NUM_TYPES];
02282
02283   // Table of texture wrap modes mapping from nvsg specific to a 'best match' GL specific.
02284   GLenum        m_glTexWrapModes[nvsg::TWM_MIRROR_CLAMP_TO_BORDER+1];
02285
02286 #if !defined(NDEBUG)
02287   bool            m_inBeginEndLoop;  // \c true, when inside a glBegin/glEnd loop, otherwise \c false
02288 #endif
02289 #if defined( GL_STATISTICS )
02290   GLStatistics  * m_glStats;
02291 #endif
02292 };
02293
02294 } // namespace nvgl
02295
02296 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
02297 // inline implementations
02298 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
02299
02300 // need defines now with implementing
02301 #include "nvgl/GLFunctions.h"
02302 #include "nvgl/GLObjects.h"
02303
02304 namespace nvgl
02305 {
02306 inline void GLContext::addBuffers(GLsizei n, const GLuint * names)
02307 {
02308   NVSG_TRACE();
02309   NVSG_ASSERT(n>0 && names);
02310   m_glObjects->m_shareables->m_buffers.insert(&names[0], &names[n]);
02311 }
02312
02313 inline void GLContext::removeBuffers(GLsizei n, const GLuint * names)
02314 {
02315   NVSG_TRACE();
02316   NVSG_ASSERT(n>0 && names);
02317   for( GLsizei i=0; i<n; ++i )
02318   {
02319     m_glObjects->m_shareables->m_buffers.erase(names[i]);
02320   }
02321 }
02322
02323 inline void GLContext::addLists(GLsizei n, GLuint first)
02324 {
02325   NVSG_TRACE();
02326   NVSG_ASSERT(n>0 && first>0);
02327   for( GLuint i=first; i<first+n; ++i )
02328   {
02329     m_glObjects->m_shareables->m_lists.insert(i);
02330   }
02331 }
02332
02333 inline void GLContext::removeLists(GLsizei n, GLuint first)
02334 {
02335   NVSG_TRACE();
02336   NVSG_ASSERT(n>0 && first>0);
02337   for( GLuint i=first; i<first+n; ++i )
02338   {
02339     m_glObjects->m_shareables->m_lists.erase(i);
02340   }
02341 }
02342
02343 inline void GLContext::addPrograms(GLsizei n, const GLuint * names)
02344 {
02345   NVSG_TRACE();
02346   NVSG_ASSERT(n>0 && names);
02347   m_glObjects->m_shareables->m_programs.insert(&names[0], &names[n]);
02348 }
02349
02350 inline void GLContext::removePrograms(GLsizei n, const GLuint * names)
02351 {
02352   NVSG_TRACE();
02353   NVSG_ASSERT(n>0 && names);
02354   for( GLsizei i=0; i<n; ++i )
02355   {
02356     m_glObjects->m_shareables->m_programs.erase(names[i]);
02357   }
02358 }
02359
02360 inline void GLContext::addTextures(GLsizei n, const GLuint * names)
02361 {
02362   NVSG_TRACE();
02363   NVSG_ASSERT(n>0 && names);
02364   m_glObjects->m_shareables->m_textures.insert(&names[0], &names[n]);
02365 }
02366
02367 inline void GLContext::removeTextures(GLsizei n, const GLuint * names)
02368 {
02369   NVSG_TRACE();
02370   NVSG_ASSERT(n>0 && names);
02371   for( GLsizei i=0; i<n; ++i )
02372   {
02373     m_glObjects->m_shareables->m_textures.erase(names[i]);
02374   }
02375 }
02376
02377 inline void GLContext::addOcclusionQueries(GLsizei n, const GLuint * names)
02378 {
02379   NVSG_TRACE();
02380   NVSG_ASSERT(n>0 && names);
02381   m_glObjects->m_occlusionQueries.insert(&names[0], &names[n]);
02382 }
02383
02384 inline void GLContext::removeOcclusionQueries(GLsizei n, const GLuint * names)
02385
02386 {
02387   NVSG_TRACE();
02388   NVSG_ASSERT(n>0 && names);
02389   for( GLsizei i=0; i<n; ++i )
02390   {
02391     m_glObjects->m_occlusionQueries.erase(names[i]);
02392   }
02393 }
02394
02395 inline void GLContext::addQueries(GLsizei n, const GLuint * names)
02396 {
02397   NVSG_TRACE();
02398   NVSG_ASSERT(n>0 && names);
02399   m_glObjects->m_queries.insert(&names[0], &names[n]);
02400 }
02401
02402 inline void GLContext::removeQueries(GLsizei n, const GLuint * names)
02403 {
02404   NVSG_TRACE();
02405   NVSG_ASSERT(n>0 && names);
02406   for( GLsizei i=0; i<n; ++i )
02407   {
02408     m_glObjects->m_queries.erase(names[i]);
02409   }
02410 }
02411
02418 inline GLContext * glContext()
02419 {
02420 #if defined(_WIN32)
02421   NVSG_ASSERT(glContextTlsIdx!=TLS_OUT_OF_INDEXES);
02422   return (GLContext*)TlsGetValue(glContextTlsIdx);
02423 #elif defined(LINUX)
02424   return (GLContext*)pthread_getspecific(glContextKey);
02425 #else
02426 #error Unsupported Operating System!
02427 #endif
02428 }
02429
02431 #if !defined(DOXYGEN_IGNORE)
02432 # if !defined(NDEBUG)
02433 inline void ASSERT_GL_CURRENT_CONTEXT_CONFORMITY()
02434 {
02435 #  if defined(_WIN32)
02436   HGLRC hglrc = wglGetCurrentContext();
02437   NVSG_ASSERT((glContext()!=NULL)==(hglrc!=NULL));
02438   NVSG_ASSERT(!glContext()||glContext()->m_hglrc==hglrc);
02439 #  elif defined(LINUX)
02440   GLXContext ctx = glXGetCurrentContext();
02441   NVSG_ASSERT((glContext()!=NULL)==(ctx!=NULL));
02442   NVSG_ASSERT(!glContext()||glContext()->m_ctx==ctx);
02443 #  else // unsupported OS
02444 #  endif
02445 }
02446 # else
02447 # define ASSERT_GL_CURRENT_CONTEXT_CONFORMITY() static_cast<void*>(0)
02448 # endif
02449
02450 # if !defined(NDEBUG) && defined(GL_CACHING)
02451
02452 inline void ASSERT_GL_ARRAY_BUFFER_BINDING()
02453 {
02454   GLContext * ctx = glContext();
02455   GLint name;
02456   GLGetIntegerv(GL_ARRAY_BUFFER_BINDING_ARB, &name);
02457   NVSG_ASSERT(ctx->m_bufferBindingAttributes[GL_ARRAY_BUFFER_ARB]==name);
02458 }
02459
02460 inline void ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING()
02461 {
02462   GLContext * ctx = glContext();
02463   GLint name;
02464   GLGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, &name);
02465   NVSG_ASSERT(ctx->m_bufferBindingAttributes[GL_ELEMENT_ARRAY_BUFFER_ARB]==name);
02466 }
02467
02468 inline void ASSERT_GL_PIXEL_PACK_BUFFER_BINDING()
02469 {
02470   GLContext * ctx = glContext();
02471   GLint name;
02472   GLGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB, &name);
02473   NVSG_ASSERT(ctx->m_bufferBindingAttributes[GL_PIXEL_PACK_BUFFER_ARB]==name);
02474 }
02475
02476 inline void ASSERT_GL_PIXEL_UNPACK_BUFFER_BINDING()
02477 {
02478   GLContext * ctx = glContext();
02479   GLint name;
02480   GLGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING_ARB, &name);
02481   NVSG_ASSERT(ctx->m_bufferBindingAttributes[GL_PIXEL_UNPACK_BUFFER_ARB]==name);
02482 }
02483
02484 # else
02485
02486 # define ASSERT_GL_ARRAY_BUFFER_BINDING()         static_cast<void*>(0)
02487 # define ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING() static_cast<void*>(0)
02488 # define ASSERT_GL_PIXEL_PACK_BUFFER_BINDING()    static_cast<void*>(0)
02489 # define ASSERT_GL_PIXEL_UNPACK_BUFFER_BINDING()  static_cast<void*>(0)
02490
02491 # endif
02492 #endif //DOXYGEN_IGNORE
02493
02495 inline bool equalf(GLfloat a, GLfloat b)
02496 {
02497   return (*((int*)&a) == *((int*)&b));
02498 }
02500 inline bool equal3f(GLfloat a1, GLfloat a2, GLfloat a3, const GLfloat *b)
02501 {
02502   return (  *((int*)&a1) == *((int*)&b[0])
02503          && *((int*)&a2) == *((int*)&b[1])
02504          && *((int*)&a3) == *((int*)&b[2]));
02505 }
02507 inline bool equal3fv(const GLfloat *a, const GLfloat *b)
02508 {
02509   return (  *((int*)&a[0]) == *((int*)&b[0])
02510          && *((int*)&a[1]) == *((int*)&b[1])
02511          && *((int*)&a[2]) == *((int*)&b[2]));
02512 }
02514 inline bool equal4f(GLfloat a1, GLfloat a2, GLfloat a3, GLfloat a4, const GLfloat *b)
02515 {
02516   return (  *((int*)&a1) == *((int*)&b[0])
02517          && *((int*)&a2) == *((int*)&b[1])
02518          && *((int*)&a3) == *((int*)&b[2])
02519          && *((int*)&a4) == *((int*)&b[3]));
02520 }
02522 inline bool equal4fv(const GLfloat *a, const GLfloat *b)
02523 {
02524   return (  *((int*)&a[0]) == *((int*)&b[0])
02525          && *((int*)&a[1]) == *((int*)&b[1])
02526          && *((int*)&a[2]) == *((int*)&b[2])
02527          && *((int*)&a[3]) == *((int*)&b[3]));
02528 }
02529
02531
02533
02534 inline void  GLAccum( GLenum op, GLfloat value )
02535 {
02536   NVSG_GL_STATS_FCT_COUNT();
02537   glAccum( op, value );
02538   ASSERT_GL_NO_ERROR;
02539 }
02540
02542
02543 inline  void  GLActiveStencilFace( GLenum face )
02544 {
02545   NVSG_GL_STATS_FCT_COUNT();
02546   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glActiveStencilFaceEXT );
02547   glContext()->m_glFunctions->glActiveStencilFaceEXT( face );
02548   ASSERT_GL_NO_ERROR;
02549 }
02550
02552
02553 inline  void  GLActiveTexture( GLenum texture )
02554 {
02555 #if defined( GL_CACHING )
02556   glContext()->m_textureAttributes.m_toActivate = texture - GL_TEXTURE0;
02557 #else
02558   NVSG_GL_STATS_ACTIVE_TEXTURE( texture );
02559   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glActiveTexture );
02560   glContext()->m_glFunctions->glActiveTexture(texture);
02561   ASSERT_GL_NO_ERROR;
02562 #endif
02563 }
02564
02566
02567 inline  void  GLActiveVarying( GLuint program, const GLchar *name )
02568 {
02569   NVSG_GL_STATS_FCT_COUNT();
02570   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glActiveVaryingNV );
02571   glContext()->m_glFunctions->glActiveVaryingNV( program, name );
02572   ASSERT_GL_NO_ERROR;
02573 }
02574
02576
02577 inline  void  GLAddSwapHintRect( GLint x, GLint y, GLsizei width, GLsizei height )
02578 {
02579   NVSG_GL_STATS_FCT_COUNT();
02580   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glAddSwapHintRectWin );
02581   glContext()->m_glFunctions->glAddSwapHintRectWin( x, y, width, height );
02582   ASSERT_GL_NO_ERROR;
02583 }
02584
02586
02587 inline  void  GLAlphaFunc( GLenum func, GLclampf ref )
02588 {
02589 #if defined(GL_CACHING)
02590   GLContext * ctx = glContext();
02591 # if defined(GL_SUPPORT_RESET)
02592   ctx->m_previousAttributes.m_alphaFunc = ctx->m_colorBufferAttributes.m_alphaFunc;
02593   ctx->m_previousAttributes.m_alphaRef  = ctx->m_colorBufferAttributes.m_alphaRef;
02594 # endif
02595   if (    ( ctx->m_colorBufferAttributes.m_alphaFunc != func )
02596       ||  ( ctx->m_colorBufferAttributes.m_alphaRef  != ref ) )
02597 #endif
02598   {
02599     NVSG_GL_STATS_FCT_COUNT();
02600     glAlphaFunc( func, ref );
02601     ASSERT_GL_NO_ERROR;
02602 #if defined(GL_CACHING)
02603     ctx->m_colorBufferAttributes.m_alphaFunc = func;
02604     ctx->m_colorBufferAttributes.m_alphaRef  = ref;
02605 #endif
02606   }
02607 }
02608
02614 inline void GLResetAlphaFunc()
02615 {
02616 #if defined(GL_SUPPORT_RESET)
02617   GLContext * ctx = glContext();
02618   GLAlphaFunc( ctx->m_previousAttributes.m_alphaFunc, ctx->m_previousAttributes.m_alphaRef );
02619 #else
02620   GLAlphaFunc( GL_ALWAYS, 0.0f );
02621 #endif
02622 }
02623
02625
02626 inline  GLboolean GLAreProgramsResident( GLsizei n, const GLuint *programs, GLboolean *residences )
02627 {
02628   NVSG_GL_STATS_FCT_COUNT();
02629   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glAreProgramsResidentNV );
02630   GLboolean ok = glContext()->m_glFunctions->glAreProgramsResidentNV( n, programs, residences );
02631   ASSERT_GL_NO_ERROR;
02632   return( ok );
02633 }
02634
02636
02637 inline  GLboolean GLAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )
02638 {
02639   NVSG_GL_STATS_FCT_COUNT();
02640   GLboolean ok = glAreTexturesResident( n, textures, residences );
02641   ASSERT_GL_NO_ERROR;
02642   return( ok );
02643 }
02644
02646
02647 inline  void  GLArrayElement( GLint i )
02648 {
02649   NVSG_GL_STATS_FCT_COUNT();
02650   glArrayElement( i );
02651   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
02652 }
02653
02655
02656 inline  void  GLAttachObject( GLhandleARB containerObj, GLhandleARB attachedObj )
02657 {
02658   NVSG_GL_STATS_FCT_COUNT();
02659   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glAttachObjectARB );
02660   glContext()->m_glFunctions->glAttachObjectARB( containerObj, attachedObj );
02661   ASSERT_GL_NO_ERROR;
02662 }
02663
02665
02666 inline  void  GLAttachShader( GLuint program, GLuint shader )
02667 {
02668   NVSG_GL_STATS_FCT_COUNT();
02669   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glAttachShader );
02670   glContext()->m_glFunctions->glAttachShader( program, shader );
02671   ASSERT_GL_NO_ERROR;
02672 }
02673
02675
02676 inline  void  GLBegin( GLenum mode )
02677 {
02678   NVSG_GL_STATS_FCT_COUNT();
02679   glBegin( mode );
02680 #if !defined(NDEBUG)
02681   glContext()->m_inBeginEndLoop = true;
02682 #endif
02683 }
02684
02686
02687 inline  void  GLBeginOcclusionQuery( GLuint id )
02688 {
02689   NVSG_GL_STATS_FCT_COUNT();
02690   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBeginOcclusionQueryNV );
02691   glContext()->m_glFunctions->glBeginOcclusionQueryNV( id );
02692   ASSERT_GL_NO_ERROR;
02693 }
02694
02696
02697 inline  void  GLBeginQuery( GLenum target, GLuint id )
02698 {
02699   NVSG_GL_STATS_FCT_COUNT();
02700   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBeginQuery );
02701   glContext()->m_glFunctions->glBeginQuery( target, id );
02702   ASSERT_GL_NO_ERROR;
02703 }
02704
02706 inline  void  GLBeginTransformFeedback( GLenum primitiveMode )
02707 {
02708   NVSG_GL_STATS_FCT_COUNT();
02709   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBeginTransformFeedbackNV );
02710   glContext()->m_glFunctions->glBeginTransformFeedbackNV( primitiveMode );
02711   ASSERT_GL_NO_ERROR;
02712 }
02713
02715 inline  void  GLBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
02716 {
02717   NVSG_GL_STATS_FCT_COUNT();
02718   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBlendColor );
02719   glContext()->m_glFunctions->glBlendColor( red, green, blue, alpha );
02720   ASSERT_GL_NO_ERROR;
02721 }
02722
02724 inline  void  GLBindArraySet( GLuint buffer )
02725 {
02726   NVSG_GL_STATS_FCT_COUNT();
02727   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBindArraySetARB );
02728   glContext()->m_glFunctions->glBindArraySetARB( buffer );
02729   ASSERT_GL_NO_ERROR;
02730 }
02731
02733 inline  void  GLBindAttribLocation( GLuint program, GLuint index, const GLchar *name )
02734 {
02735   NVSG_GL_STATS_FCT_COUNT();
02736   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBindAttribLocation );
02737   glContext()->m_glFunctions->glBindAttribLocation( program, index, name );
02738   ASSERT_GL_NO_ERROR;
02739 }
02740
02742
02743 inline  void  GLBindBuffer( GLenum target, GLuint id )
02744 {
02745   GLContext * ctx = glContext();
02746 #if defined( GL_CACHING )
02747   NVSG_ASSERT(  ( target == GL_ARRAY_BUFFER_ARB )
02748              || ( target == GL_ELEMENT_ARRAY_BUFFER_ARB )
02749              || ( target == GL_PIXEL_PACK_BUFFER_ARB )
02750              || ( target == GL_PIXEL_UNPACK_BUFFER_ARB ) );
02751
02752   if ( ctx->m_bufferBindingAttributes[target] != id )
02753 #endif
02754   {
02755     NVSG_GL_STATS_BIND_BUFFER( target, id );
02756     NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glBindBuffer );
02757     ctx->m_glFunctions->glBindBuffer( target, id );
02758     ASSERT_GL_NO_ERROR;
02759 #if defined( GL_CACHING )
02760     ctx->m_bufferBindingAttributes[target] = id;
02761 #endif
02762   }
02763 }
02764
02766
02767 inline  void  GLBindBufferBase( GLenum target, GLuint index, GLuint buffer )
02768 {
02769   NVSG_GL_STATS_FCT_COUNT();
02770   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBindBufferBaseNV );
02771   glContext()->m_glFunctions->glBindBufferBaseNV( target, index, buffer );
02772   ASSERT_GL_NO_ERROR;
02773 }
02774
02776
02777 inline  void  GLBindBufferOffset( GLenum target, GLuint index, GLuint buffer, GLintptr offset )
02778 {
02779   NVSG_GL_STATS_FCT_COUNT();
02780   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBindBufferOffsetNV );
02781   glContext()->m_glFunctions->glBindBufferOffsetNV( target, index, buffer, offset );
02782   ASSERT_GL_NO_ERROR;
02783 }
02784
02786
02787 inline  void  GLBindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
02788 {
02789   NVSG_GL_STATS_FCT_COUNT();
02790   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBindBufferRangeNV );
02791   glContext()->m_glFunctions->glBindBufferRangeNV( target, index, buffer, offset, size );
02792   ASSERT_GL_NO_ERROR;
02793 }
02794
02796
02797 inline  void  GLBufferData( GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage )
02798 {
02799   NVSG_GL_STATS_BUFFER_DATA( target, size, data, usage );
02800   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBufferData );
02801   glContext()->m_glFunctions->glBufferData( target, size, data, usage );
02802   ASSERT_GL_NO_ERROR;
02803 }
02804
02806
02807 inline  void  GLBufferSubData( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data )
02808 {
02809   NVSG_GL_STATS_FCT_COUNT();
02810   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBufferSubData );
02811   glContext()->m_glFunctions->glBufferSubData( target, offset, size, data );
02812   ASSERT_GL_NO_ERROR;
02813 }
02814
02816
02817 inline  void  GLDeleteArraySets( GLsizei n, const GLuint *buffers )
02818 {
02819   NVSG_GL_STATS_FCT_COUNT();
02820   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDeleteArraySetsARB );
02821   glContext()->m_glFunctions->glDeleteArraySetsARB( n, buffers );
02822   ASSERT_GL_NO_ERROR;
02823 }
02824
02826
02827 inline  void  GLDeleteBuffers(GLsizei n, const GLuint *buffers)
02828 {
02829   NVSG_GL_STATS_DELETE_BUFFERS( n, buffers );
02830   GLContext * ctx = glContext();
02831   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteBuffers );
02832 #if defined(GL_CACHING)
02833   for ( GLsizei i=0; i<n; ++i )
02834   {
02835 #define CHECK_UNBIND_BUFFER(t) \
02836     if (  ctx->m_bufferBindingAttributes[t] == buffers[i] ) { \
02837       GLBindBuffer(t, 0); \
02838     }
02839     CHECK_UNBIND_BUFFER(GL_ARRAY_BUFFER_ARB)
02840     CHECK_UNBIND_BUFFER(GL_ELEMENT_ARRAY_BUFFER_ARB)
02841     CHECK_UNBIND_BUFFER(GL_PIXEL_PACK_BUFFER_ARB)
02842     CHECK_UNBIND_BUFFER(GL_PIXEL_UNPACK_BUFFER_ARB)
02843 #undef CHECK_UNBIND_BUFFER
02844   }
02845 #endif
02846   ctx->m_glFunctions->glDeleteBuffers( n, buffers );
02847   ctx->removeBuffers(n, buffers);
02848   ASSERT_GL_NO_ERROR;
02849 }
02850
02852 inline  void  GLDeleteFences( GLsizei n, const GLuint *fences )
02853 {
02854   NVSG_GL_STATS_FCT_COUNT();
02855   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDeleteFences );
02856   glContext()->m_glFunctions->glDeleteFences( n, fences );
02857   ASSERT_GL_NO_ERROR;
02858 }
02859
02861 inline  void  GLGenArraySets( GLsizei n, GLuint *buffers )
02862 {
02863   NVSG_GL_STATS_FCT_COUNT();
02864   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGenArraySetsARB );
02865   glContext()->m_glFunctions->glGenArraySetsARB( n, buffers );
02866   ASSERT_GL_NO_ERROR;
02867 }
02868
02870
02871 inline  void  GLGenBuffers(GLsizei n, GLuint *buffers)
02872 {
02873   NVSG_GL_STATS_GEN_BUFFERS( n, buffers );
02874   GLContext * ctx = glContext();
02875   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glGenBuffers );
02876   ctx->m_glFunctions->glGenBuffers( n, buffers );
02877   ctx->addBuffers(n, buffers);
02878   ASSERT_GL_NO_ERROR;
02879 }
02880
02882 inline  void  GLGenFences( GLsizei n, GLuint *fences )
02883 {
02884   NVSG_GL_STATS_FCT_COUNT();
02885   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGenFences );
02886   glContext()->m_glFunctions->glGenFences( n, fences );
02887   ASSERT_GL_NO_ERROR;
02888 }
02889
02891
02893 inline  GLvoid*  GLMapBuffer( GLenum target, GLenum access )
02894 {
02895   NVSG_GL_STATS_FCT_COUNT();
02896   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMapBuffer );
02897   GLvoid * p = glContext()->m_glFunctions->glMapBuffer( target, access );
02898   ASSERT_GL_NO_ERROR;
02899   return p;
02900 }
02901
02903
02904 inline  void  GLUnlockArrays()
02905 {
02906   NVSG_GL_STATS_FCT_COUNT();
02907   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUnlockArrays );
02908   glContext()->m_glFunctions->glUnlockArrays();
02909   ASSERT_GL_NO_ERROR;
02910 }
02911
02913
02914 inline  void  GLUniform1f( GLint location, GLfloat v0 )
02915 {
02916   NVSG_GL_STATS_FCT_COUNT();
02917   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform1f );
02918   glContext()->m_glFunctions->glUniform1f( location, v0 );
02919   ASSERT_GL_NO_ERROR;
02920 }
02921
02923
02924 inline  void  GLUniform1fv( GLint location, GLsizei count, const GLfloat *value )
02925 {
02926   NVSG_GL_STATS_FCT_COUNT();
02927   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform1fv );
02928   glContext()->m_glFunctions->glUniform1fv( location, count, value );
02929   ASSERT_GL_NO_ERROR;
02930 }
02931
02933
02934 inline  void  GLUniform1i( GLint location, GLint v0 )
02935 {
02936   NVSG_GL_STATS_FCT_COUNT();
02937   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform1i );
02938   glContext()->m_glFunctions->glUniform1i( location, v0 );
02939   ASSERT_GL_NO_ERROR;
02940 }
02941
02943
02944 inline  void  GLUniform1iv( GLint location, GLsizei count, const GLint *value )
02945 {
02946   NVSG_GL_STATS_FCT_COUNT();
02947   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform1iv );
02948   glContext()->m_glFunctions->glUniform1iv( location, count, value );
02949   ASSERT_GL_NO_ERROR;
02950 }
02951
02953
02954 inline  void  GLUniform1ui( GLint location, GLuint v0 )
02955 {
02956   NVSG_GL_STATS_FCT_COUNT();
02957   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform1ui );
02958   glContext()->m_glFunctions->glUniform1ui( location, v0 );
02959   ASSERT_GL_NO_ERROR;
02960 }
02961
02963
02964 inline  void  GLUniform1uiv( GLint location, GLsizei count, const GLuint *value )
02965 {
02966   NVSG_GL_STATS_FCT_COUNT();
02967   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform1uiv );
02968   glContext()->m_glFunctions->glUniform1uiv( location, count, value );
02969   ASSERT_GL_NO_ERROR;
02970 }
02971
02973
02974 inline  void  GLUniform2f( GLint location, GLfloat v0, GLfloat v1 )
02975 {
02976   NVSG_GL_STATS_FCT_COUNT();
02977   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform2f );
02978   glContext()->m_glFunctions->glUniform2f( location, v0, v1 );
02979   ASSERT_GL_NO_ERROR;
02980 }
02981
02983
02984 inline  void  GLUniform2fv( GLint location, GLsizei count, const GLfloat *value )
02985 {
02986   NVSG_GL_STATS_FCT_COUNT();
02987   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform2fv );
02988   glContext()->m_glFunctions->glUniform2fv( location, count, value );
02989   ASSERT_GL_NO_ERROR;
02990 }
02991
02993
02994 inline  void  GLUniform2i( GLint location, GLint v0, GLint v1 )
02995 {
02996   NVSG_GL_STATS_FCT_COUNT();
02997   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform2i );
02998   glContext()->m_glFunctions->glUniform2i( location, v0, v1 );
02999   ASSERT_GL_NO_ERROR;
03000 }
03001
03003
03004 inline  void  GLUniform2iv( GLint location, GLsizei count, const GLint *value )
03005 {
03006   NVSG_GL_STATS_FCT_COUNT();
03007   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform2iv );
03008   glContext()->m_glFunctions->glUniform2iv( location, count, value );
03009   ASSERT_GL_NO_ERROR;
03010 }
03011
03013
03014 inline  void  GLUniform2ui( GLint location, GLuint v0, GLuint v1 )
03015 {
03016   NVSG_GL_STATS_FCT_COUNT();
03017   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform2ui );
03018   glContext()->m_glFunctions->glUniform2ui( location, v0, v1 );
03019   ASSERT_GL_NO_ERROR;
03020 }
03021
03023
03024 inline  void  GLUniform2uiv( GLint location, GLsizei count, const GLuint *value )
03025 {
03026   NVSG_GL_STATS_FCT_COUNT();
03027   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform2uiv );
03028   glContext()->m_glFunctions->glUniform2uiv( location, count, value );
03029   ASSERT_GL_NO_ERROR;
03030 }
03031
03033
03034 inline  void  GLUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
03035 {
03036   NVSG_GL_STATS_FCT_COUNT();
03037   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform3f );
03038   glContext()->m_glFunctions->glUniform3f( location, v0, v1, v2 );
03039   ASSERT_GL_NO_ERROR;
03040 }
03041
03043
03044 inline  void  GLUniform3fv( GLint location, GLsizei count, const GLfloat *value )
03045 {
03046   NVSG_GL_STATS_FCT_COUNT();
03047   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform3fv );
03048   glContext()->m_glFunctions->glUniform3fv( location, count, value );
03049   ASSERT_GL_NO_ERROR;
03050 }
03051
03053
03054 inline  void  GLUniform3i( GLint location, GLint v0, GLint v1, GLint v2 )
03055 {
03056   NVSG_GL_STATS_FCT_COUNT();
03057   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform3i );
03058   glContext()->m_glFunctions->glUniform3i( location, v0, v1, v2 );
03059   ASSERT_GL_NO_ERROR;
03060 }
03061
03063
03064 inline  void  GLUniform3iv( GLint location, GLsizei count, const GLint *value )
03065 {
03066   NVSG_GL_STATS_FCT_COUNT();
03067   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform3iv );
03068   glContext()->m_glFunctions->glUniform3iv( location, count, value );
03069   ASSERT_GL_NO_ERROR;
03070 }
03071
03073
03074 inline  void  GLUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 )
03075 {
03076   NVSG_GL_STATS_FCT_COUNT();
03077   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform3ui );
03078   glContext()->m_glFunctions->glUniform3ui( location, v0, v1, v2 );
03079   ASSERT_GL_NO_ERROR;
03080 }
03081
03083
03084 inline  void  GLUniform3uiv( GLint location, GLsizei count, const GLuint *value )
03085 {
03086   NVSG_GL_STATS_FCT_COUNT();
03087   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform3uiv );
03088   glContext()->m_glFunctions->glUniform3uiv( location, count, value );
03089   ASSERT_GL_NO_ERROR;
03090 }
03091
03093
03094 inline  void  GLUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
03095 {
03096   NVSG_GL_STATS_FCT_COUNT();
03097   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform4f );
03098   glContext()->m_glFunctions->glUniform4f( location, v0, v1, v2, v3 );
03099   ASSERT_GL_NO_ERROR;
03100 }
03101
03103
03104 inline  void  GLUniform4fv( GLint location, GLsizei count, const GLfloat *value )
03105 {
03106   NVSG_GL_STATS_FCT_COUNT();
03107   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform4fv );
03108   glContext()->m_glFunctions->glUniform4fv( location, count, value );
03109   ASSERT_GL_NO_ERROR;
03110 }
03111
03113
03114 inline  void  GLUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
03115 {
03116   NVSG_GL_STATS_FCT_COUNT();
03117   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform4i );
03118   glContext()->m_glFunctions->glUniform4i( location, v0, v1, v2, v3 );
03119   ASSERT_GL_NO_ERROR;
03120 }
03121
03123
03124 inline  void  GLUniform4iv( GLint location, GLsizei count, const GLint *value )
03125 {
03126   NVSG_GL_STATS_FCT_COUNT();
03127   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform4iv );
03128   glContext()->m_glFunctions->glUniform4iv( location, count, value );
03129   ASSERT_GL_NO_ERROR;
03130 }
03131
03133
03134 inline  void  GLUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
03135 {
03136   NVSG_GL_STATS_FCT_COUNT();
03137   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform4ui );
03138   glContext()->m_glFunctions->glUniform4ui( location, v0, v1, v2, v3 );
03139   ASSERT_GL_NO_ERROR;
03140 }
03141
03143
03144 inline  void  GLUniform4uiv( GLint location, GLsizei count, const GLuint *value )
03145 {
03146   NVSG_GL_STATS_FCT_COUNT();
03147   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniform4uiv );
03148   glContext()->m_glFunctions->glUniform4uiv( location, count, value );
03149   ASSERT_GL_NO_ERROR;
03150 }
03151
03153
03154 inline  void  GLUniformBuffer( GLuint program, GLint location, GLuint buffer )
03155 {
03156   NVSG_GL_STATS_FCT_COUNT();
03157   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformBuffer );
03158   glContext()->m_glFunctions->glUniformBuffer( program, location, buffer );
03159   ASSERT_GL_NO_ERROR;
03160 }
03161
03163
03164 inline  void  GLUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03165 {
03166   NVSG_GL_STATS_FCT_COUNT();
03167   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix2fv );
03168   glContext()->m_glFunctions->glUniformMatrix2fv( location, count, transpose, value );
03169   ASSERT_GL_NO_ERROR;
03170 }
03171
03173
03174 inline  void  GLUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03175 {
03176   NVSG_GL_STATS_FCT_COUNT();
03177   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix2x3fv );
03178   glContext()->m_glFunctions->glUniformMatrix2x3fv( location, count, transpose, value );
03179   ASSERT_GL_NO_ERROR;
03180 }
03181
03183
03184 inline  void  GLUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03185 {
03186   NVSG_GL_STATS_FCT_COUNT();
03187   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix2x4fv );
03188   glContext()->m_glFunctions->glUniformMatrix2x4fv( location, count, transpose, value );
03189   ASSERT_GL_NO_ERROR;
03190 }
03191
03193
03194 inline  void  GLUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03195 {
03196   NVSG_GL_STATS_FCT_COUNT();
03197   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix3fv );
03198   glContext()->m_glFunctions->glUniformMatrix3fv( location, count, transpose, value );
03199   ASSERT_GL_NO_ERROR;
03200 }
03201
03203
03204 inline  void  GLUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03205 {
03206   NVSG_GL_STATS_FCT_COUNT();
03207   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix3x2fv );
03208   glContext()->m_glFunctions->glUniformMatrix3x2fv( location, count, transpose, value );
03209   ASSERT_GL_NO_ERROR;
03210 }
03211
03213
03214 inline  void  GLUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03215 {
03216   NVSG_GL_STATS_FCT_COUNT();
03217   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix3x4fv );
03218   glContext()->m_glFunctions->glUniformMatrix3x4fv( location, count, transpose, value );
03219   ASSERT_GL_NO_ERROR;
03220 }
03221
03223
03224 inline  void  GLUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03225 {
03226   NVSG_GL_STATS_FCT_COUNT();
03227   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix4fv );
03228   glContext()->m_glFunctions->glUniformMatrix4fv( location, count, transpose, value );
03229   ASSERT_GL_NO_ERROR;
03230 }
03231
03233
03234 inline  void  GLUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03235 {
03236   NVSG_GL_STATS_FCT_COUNT();
03237   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix4x2fv );
03238   glContext()->m_glFunctions->glUniformMatrix4x2fv( location, count, transpose, value );
03239   ASSERT_GL_NO_ERROR;
03240 }
03241
03243
03244 inline  void  GLUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
03245 {
03246   NVSG_GL_STATS_FCT_COUNT();
03247   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUniformMatrix4x3fv );
03248   glContext()->m_glFunctions->glUniformMatrix4x3fv( location, count, transpose, value );
03249   ASSERT_GL_NO_ERROR;
03250 }
03251
03253
03254 inline  GLboolean  GLUnmapBuffer( GLenum target )
03255 {
03256   NVSG_GL_STATS_FCT_COUNT();
03257   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUnmapBuffer );
03258   GLboolean b = glContext()->m_glFunctions->glUnmapBuffer( target );
03259   ASSERT_GL_NO_ERROR;
03260   return b;
03261 }
03262
03264
03265 inline  void  GLUseProgram( GLuint program )
03266 {
03267   NVSG_GL_STATS_FCT_COUNT();
03268   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUseProgram );
03269   glContext()->m_glFunctions->glUseProgram( program );
03270   ASSERT_GL_NO_ERROR;
03271 }
03272
03274
03275 inline  void  GLUseProgramObject( GLhandleARB programObj )
03276 {
03277   NVSG_GL_STATS_FCT_COUNT();
03278   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUseProgramObjectARB );
03279   glContext()->m_glFunctions->glUseProgramObjectARB( programObj );
03280   ASSERT_GL_NO_ERROR;
03281 }
03282
03284
03285 inline  void  GLValidateProgram( GLuint program )
03286 {
03287   NVSG_GL_STATS_FCT_COUNT();
03288   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glValidateProgram );
03289   glContext()->m_glFunctions->glValidateProgram( program );
03290   ASSERT_GL_NO_ERROR;
03291 }
03292
03294
03295 inline  GLboolean  GLIsArraySet( GLuint name )
03296 {
03297   NVSG_GL_STATS_FCT_COUNT();
03298   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glIsArraySetARB );
03299   GLboolean ok = glContext()->m_glFunctions->glIsArraySetARB( name );
03300   ASSERT_GL_NO_ERROR;
03301   return( ok );
03302 }
03303
03305
03306 inline  GLboolean  GLIsBuffer( GLuint name )
03307 {
03308   NVSG_GL_STATS_FCT_COUNT();
03309   NVSG_ASSERT(glContext()->m_glFunctions && glContext()->m_glFunctions->glIsBuffer);
03310   NVSG_ASSERT(!!glContext()->isBuffer(name)==!!glContext()->m_glFunctions->glIsBuffer(name));
03311   return glContext()->isBuffer(name);
03312 }
03313
03315
03316 inline  void  GLBindFragDataLocation( GLuint program, GLuint color, const GLchar *name )
03317 {
03318   NVSG_GL_STATS_FCT_COUNT();
03319   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBindFragDataLocation );
03320   glContext()->m_glFunctions->glBindFragDataLocation( program, color, name );
03321   ASSERT_GL_NO_ERROR;
03322 }
03323
03325
03327 inline  void  GLBindProgram( GLenum target, GLuint id )
03328 {
03329   NVSG_GL_STATS_FCT_COUNT();
03330   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBindProgramNV );
03331   glContext()->m_glFunctions->glBindProgramNV( target, id );
03332   ASSERT_GL_NO_ERROR;
03333 }
03334
03336
03337 inline  void  GLBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
03338 {
03339   NVSG_GL_STATS_FCT_COUNT();
03340   glBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
03341   ASSERT_GL_NO_ERROR;
03342 }
03343
03345
03346 inline  void  GLBlendEquation( GLenum mode )
03347 {
03348   NVSG_GL_STATS_FCT_COUNT();
03349   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBlendEquation );
03350   glContext()->m_glFunctions->glBlendEquation( mode );
03351   ASSERT_GL_NO_ERROR;
03352 }
03353
03355
03356 inline  void  GLBlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha )
03357 {
03358   NVSG_GL_STATS_FCT_COUNT();
03359   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBlendEquationSeparate );
03360   glContext()->m_glFunctions->glBlendEquationSeparate( modeRGB, modeAlpha );
03361   ASSERT_GL_NO_ERROR;
03362 }
03363
03365
03366 inline  void  GLBlendFunc( GLenum sfactor, GLenum dfactor )
03367 {
03368 #if defined(GL_CACHING)
03369   GLContext * ctx = glContext();
03370 # if defined(GL_SUPPORT_RESET)
03371   ctx->m_previousAttributes.m_blendSrcRGB   = ctx->m_colorBufferAttributes.m_blendSrcRGB;
03372   ctx->m_previousAttributes.m_blendSrcAlpha = ctx->m_colorBufferAttributes.m_blendSrcAlpha;
03373   ctx->m_previousAttributes.m_blendDstRGB   = ctx->m_colorBufferAttributes.m_blendDstRGB;
03374   ctx->m_previousAttributes.m_blendDstAlpha = ctx->m_colorBufferAttributes.m_blendDstAlpha;
03375 # endif
03376   if (    ( ctx->m_colorBufferAttributes.m_blendSrcRGB   != sfactor )
03377       ||  ( ctx->m_colorBufferAttributes.m_blendSrcAlpha != sfactor )
03378       ||  ( ctx->m_colorBufferAttributes.m_blendDstRGB   != dfactor )
03379       ||  ( ctx->m_colorBufferAttributes.m_blendDstAlpha != dfactor ) )
03380 #endif
03381   {
03382     NVSG_GL_STATS_BLEND_FUNC( sfactor, dfactor );
03383     glBlendFunc( sfactor, dfactor );
03384     ASSERT_GL_NO_ERROR;
03385 #if defined(GL_CACHING)
03386     ctx->m_colorBufferAttributes.m_blendSrcRGB   = sfactor;
03387     ctx->m_colorBufferAttributes.m_blendSrcAlpha = sfactor;
03388     ctx->m_colorBufferAttributes.m_blendDstRGB   = dfactor;
03389     ctx->m_colorBufferAttributes.m_blendDstAlpha = dfactor;
03390 #endif
03391   }
03392 }
03393
03399 inline void GLResetBlendFunc()
03400 {
03401 #if defined(GL_SUPPORT_RESET)
03402   GLContext * ctx = glContext();
03403   if (    ( ctx->m_previousAttributes.m_blendSrcAlpha != ctx->m_previousAttributes.m_blendSrcRGB )
03404       ||  ( ctx->m_previousAttributes.m_blendDstAlpha != ctx->m_previousAttributes.m_blendDstRGB ) )
03405   {
03406     GLBlendFuncSeparate( ctx->m_previousAttributes.m_blendSrcRGB
03407                        , ctx->m_previousAttributes.m_blendDstRGB
03408                        , ctx->m_previousAttributes.m_blendSrcAlpha
03409                        , ctx->m_previousAttributes.m_blendDstAlpha );
03410   }
03411   else
03412   {
03413     GLBlendFunc( ctx->m_previousAttributes.m_blendSrcRGB, ctx->m_previousAttributes.m_blendDstRGB );
03414   }
03415 #else
03416   GLBlendFunc( GL_ONE, GL_ZERO );
03417 #endif
03418 }
03419
03421
03422 inline  void  GLBlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
03423 {
03424   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_blend_func_separate"));
03425 #if defined(GL_CACHING)
03426   GLContext * ctx = glContext();
03427 # if defined(GL_SUPPORT_RESET)
03428   ctx->m_previousAttributes.m_blendSrcRGB   = ctx->m_colorBufferAttributes.m_blendSrcRGB;
03429   ctx->m_previousAttributes.m_blendSrcAlpha = ctx->m_colorBufferAttributes.m_blendSrcAlpha;
03430   ctx->m_previousAttributes.m_blendDstRGB   = ctx->m_colorBufferAttributes.m_blendDstRGB;
03431   ctx->m_previousAttributes.m_blendDstAlpha = ctx->m_colorBufferAttributes.m_blendDstAlpha;
03432 # endif
03433   if (    ( ctx->m_colorBufferAttributes.m_blendSrcRGB   != sfactorRGB )
03434       ||  ( ctx->m_colorBufferAttributes.m_blendSrcAlpha != sfactorAlpha )
03435       ||  ( ctx->m_colorBufferAttributes.m_blendDstRGB   != dfactorRGB )
03436       ||  ( ctx->m_colorBufferAttributes.m_blendDstAlpha != dfactorAlpha ) )
03437 #endif
03438   {
03439     NVSG_GL_STATS_FCT_COUNT();
03440     NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBlendFuncSeparate );
03441     glContext()->m_glFunctions->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
03442     ASSERT_GL_NO_ERROR;
03443 #if defined(GL_CACHING)
03444     ctx->m_colorBufferAttributes.m_blendSrcRGB   = sfactorRGB;
03445     ctx->m_colorBufferAttributes.m_blendSrcAlpha = sfactorAlpha;
03446     ctx->m_colorBufferAttributes.m_blendDstRGB   = dfactorRGB;
03447     ctx->m_colorBufferAttributes.m_blendDstAlpha = dfactorAlpha;
03448 #endif
03449   }
03450 }
03451
03457 inline void GLResetBlendFuncSeparate()
03458 {
03459 #if defined(GL_SUPPORT_RESET)
03460   GLContext * ctx = glContext();
03461   GLBlendFuncSeparate( ctx->m_previousAttributes.m_blendSrcRGB
03462                      , ctx->m_previousAttributes.m_blendDstRGB
03463                      , ctx->m_previousAttributes.m_blendSrcAlpha
03464                      , ctx->m_previousAttributes.m_blendDstAlpha );
03465 #else
03466   GLBlendFuncSeparate( GL_ONE, GL_ZERO, GL_ONE, GL_ZERO );
03467 #endif
03468 }
03469
03485 inline void GLBlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
03486 {
03487   NVSG_GL_STATS_FCT_COUNT();
03488   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBlitFramebuffer );
03489   glContext()->m_glFunctions->glBlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
03490   ASSERT_GL_NO_ERROR;
03491 }
03492
03493
03495
03496 inline  void  GLBindTexture( GLenum target, GLuint texture )
03497 {
03498 #if defined( GL_CACHING )
03499   _GLUpdateActiveTexture();
03500 #endif
03501   NVSG_GL_STATS_BIND_TEXTURE( target, texture );
03502   glBindTexture( target, texture );
03503   ASSERT_GL_NO_ERROR;
03504 }
03505
03507
03508 inline  void  GLCallList( GLuint list )
03509 {
03510   NVSG_GL_STATS_CALL_LIST( list );
03511   glCallList( list );
03512   ASSERT_GL_NO_ERROR;
03513 }
03514
03516
03517 inline  void  GLCallLists( GLsizei n, GLenum type, const GLvoid *lists )
03518 {
03519   NVSG_GL_STATS_FCT_COUNT();
03520   glCallLists( n, type, lists );
03521   ASSERT_GL_NO_ERROR;
03522 }
03523
03525
03526 inline  void  GLClampColor( GLenum target, GLenum clamp )
03527 {
03528   NVSG_GL_STATS_FCT_COUNT();
03529   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glClampColor );
03530   glContext()->m_glFunctions->glClampColor( target, clamp );
03531   ASSERT_GL_NO_ERROR;
03532 }
03533
03535
03536 inline  void  GLClear( GLbitfield mask )
03537 {
03538   NVSG_GL_STATS_CLEAR( mask );
03539   glClear( mask );
03540   ASSERT_GL_NO_ERROR;
03541 }
03542
03544
03545 inline  void  GLClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
03546 {
03547   NVSG_GL_STATS_FCT_COUNT();
03548   glClearAccum( red, green, blue, alpha );
03549   ASSERT_GL_NO_ERROR;
03550 }
03551
03553
03554 inline  void  GLClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
03555 {
03556 #if defined( GL_CACHING )
03557   GLContext * ctx = glContext();
03558 # if defined(GL_SUPPORT_RESET)
03559   ctx->m_previousAttributes.m_clearColor = ctx->m_colorBufferAttributes.m_clearColor;
03560 # endif
03561   if ( ! equal4f( red, green, blue, alpha, &ctx->m_colorBufferAttributes.m_clearColor[0] ) )
03562 #endif
03563   {
03564     NVSG_GL_STATS_CLEAR_COLOR( red, green, blue, alpha );
03565     glClearColor(red, green, blue, alpha);
03566     ASSERT_GL_NO_ERROR;
03567 #if defined( GL_CACHING )
03568     ctx->m_colorBufferAttributes.m_clearColor[0] = red;
03569     ctx->m_colorBufferAttributes.m_clearColor[1] = green;
03570     ctx->m_colorBufferAttributes.m_clearColor[2] = blue;
03571     ctx->m_colorBufferAttributes.m_clearColor[3] = alpha;
03572 #endif
03573   }
03574 }
03575
03577
03578 inline  void  GLClearColorIi( GLint red, GLint green, GLint blue, GLint alpha )
03579 {
03580   NVSG_GL_STATS_FCT_COUNT();
03581   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glClearColorIi );
03582   glContext()->m_glFunctions->glClearColorIi( red, green, blue, alpha );
03583   ASSERT_GL_NO_ERROR;
03584 }
03585
03587
03588 inline  void  GLClearColorIui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
03589 {
03590   NVSG_GL_STATS_FCT_COUNT();
03591   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glClearColorIui );
03592   glContext()->m_glFunctions->glClearColorIui( red, green, blue, alpha );
03593   ASSERT_GL_NO_ERROR;
03594 }
03595
03600 inline void GLResetClearColor()
03601 {
03602 #if defined(GL_SUPPORT_RESET)
03603   GLContext * ctx = glContext();
03604   GLClearColor( ctx->m_previousAttributes.m_clearColor[0]
03605               , ctx->m_previousAttributes.m_clearColor[1]
03606               , ctx->m_previousAttributes.m_clearColor[2]
03607               , ctx->m_previousAttributes.m_clearColor[3] );
03608 #else
03609   GLClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
03610 #endif
03611 }
03612
03614
03615 inline  void  GLClearDepth( GLclampd depth )
03616 {
03617 #if defined( GL_CACHING )
03618   GLContext * ctx = glContext();
03619 # if defined(GL_SUPPORT_RESET)
03620   ctx->m_previousAttributes.m_depthClearValue = ctx->m_depthBufferAttributes.m_depthClearValue;
03621 # endif
03622   if ( ctx->m_depthBufferAttributes.m_depthClearValue != depth )
03623 #endif
03624   {
03625     NVSG_GL_STATS_FCT_COUNT();
03626     glClearDepth( depth );
03627     ASSERT_GL_NO_ERROR;
03628 #if defined( GL_CACHING )
03629     ctx->m_depthBufferAttributes.m_depthClearValue = depth;
03630 #endif
03631   }
03632 }
03633
03635
03636 inline  void  GLClearDepthd( GLdouble depth )
03637 {
03638   NVSG_GL_STATS_FCT_COUNT();
03639   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glClearDepthd );
03640   glContext()->m_glFunctions->glClearDepthd( depth );
03641   ASSERT_GL_NO_ERROR;
03642 }
03643
03648 inline void GLResetClearDepth()
03649 {
03650 #if defined(GL_SUPPORT_RESET)
03651   GLClearDepth( glContext()->m_previousAttributes.m_depthClearValue );
03652 #else
03653   GLClearDepth( 1.0 );
03654 #endif
03655 }
03656
03658
03659 inline  void  GLClearIndex( GLfloat c )
03660 {
03661   NVSG_GL_STATS_FCT_COUNT();
03662   glClearIndex( c );
03663   ASSERT_GL_NO_ERROR;
03664 }
03665
03667
03668 inline  void  GLClearStencil( GLint s )
03669 {
03670 #if defined( GL_CACHING )
03671   GLContext * ctx = glContext();
03672 # if defined(GL_SUPPORT_RESET)
03673   ctx->m_previousAttributes.m_stencilClearValue = ctx->m_stencilBufferAttributes.m_stencilClearValue;
03674 # endif
03675   if ( ctx->m_stencilBufferAttributes.m_stencilClearValue != s )
03676 #endif
03677   {
03678     NVSG_GL_STATS_FCT_COUNT();
03679     glClearStencil( s );
03680     ASSERT_GL_NO_ERROR;
03681 #if defined( GL_CACHING )
03682     ctx->m_stencilBufferAttributes.m_stencilClearValue = s;
03683 #endif
03684   }
03685 }
03686
03691 inline void GLResetClearStencil()
03692 {
03693 #if defined(GL_SUPPORT_RESET)
03694   GLClearStencil( glContext()->m_previousAttributes.m_stencilClearValue );
03695 #else
03696   GLClearStencil( 0 );
03697 #endif
03698 }
03699
03701
03702 inline  void  GLClientActiveTexture( GLenum texture )
03703 {
03704 #if defined( GL_CACHING )
03705   glContext()->m_vertexArrayAttributes.m_clientTextureToActivate = texture - GL_TEXTURE0;
03706 #else
03707   NVSG_GL_STATS_CLIENT_ACTIVE_TEXTURE( texture );
03708   glContext()->m_glFunctions->glClientActiveTexture( texture );
03709   ASSERT_GL_NO_ERROR;
03710 #endif
03711 }
03712
03714
03715 inline  void  GLClipPlane( GLenum plane, const GLdouble *equation )
03716 {
03717   //  NOTE: clip planes can't be cached !
03718   NVSG_GL_STATS_FCT_COUNT();
03719 #if defined( GL_SUPPORT_RESET )
03720   GLContext * ctx = glContext();
03721   size_t idx = plane - GL_CLIP_PLANE0;
03722   NVSG_ASSERT(    ( idx < ctx->m_previousAttributes.m_clipPlaneEquations.size() )
03723               &&  ( idx < ctx->m_transformAttributes.m_clipPlaneEquations.size() ) );
03724   ctx->m_previousAttributes.m_clipPlaneEquations[idx] = ctx->m_transformAttributes.m_clipPlaneEquations[idx];
03725   memcpy( &ctx->m_transformAttributes.m_clipPlaneEquations[idx][0], equation, 4*sizeof(GLdouble) );
03726 #endif
03727   glClipPlane(plane, equation);
03728   ASSERT_GL_NO_ERROR;
03729 }
03730
03737 inline void GLResetClipPlaneEquation( GLenum plane )
03738 {
03739 #if defined( GL_SUPPORT_RESET )
03740   GLClipPlane( plane, &glContext()->m_previousAttributes.m_clipPlaneEquations[plane-GL_CLIP_PLANE0][0] );
03741 #else
03742   static nvmath::Vec4d(0.0, 0.0, 0.0, 0.0);
03743   GLClipPlane( plane, zeroPlane );
03744 #endif
03745 }
03746
03748
03749 inline  void  GLColor3b( GLbyte red, GLbyte green, GLbyte blue )
03750 {
03751   NVSG_GL_STATS_COLOR3B( red, green, blue );
03752   glColor3b( red, green, blue );
03753   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03754 }
03755
03757
03758 inline  void  GLColor3bv( const GLbyte *v )
03759 {
03760   NVSG_GL_STATS_COLOR3BV( v );
03761   glColor3bv( v );
03762   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03763 }
03764
03766
03767 inline  void  GLColor3d( GLdouble red, GLdouble green, GLdouble blue )
03768 {
03769   NVSG_GL_STATS_COLOR3D( red, green, blue );
03770   glColor3d( red, green, blue );
03771   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03772 }
03773
03775
03776 inline  void  GLColor3dv( const GLdouble *v )
03777 {
03778   NVSG_GL_STATS_COLOR3DV( v );
03779   glColor3dv( v );
03780   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03781 }
03782
03784
03785 inline  void  GLColor3f( GLfloat red, GLfloat green, GLfloat blue )
03786 {
03787   NVSG_GL_STATS_COLOR3F( red, green, blue );
03788   glColor3f( red, green, blue );
03789   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03790 }
03791
03793
03794 inline  void  GLColor3fv( const GLfloat * v )
03795 {
03796   NVSG_GL_STATS_COLOR3FV( v );
03797   glColor3fv( v );
03798   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03799 }
03800
03802
03803 inline  void  GLColor3h( GLhalf red, GLhalf green, GLhalf blue )
03804 {
03805   NVSG_GL_STATS_FCT_COUNT();
03806   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColor3h );
03807   glContext()->m_glFunctions->glColor3h( red, green, blue );
03808   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03809 }
03810
03812
03813 inline  void  GLColor3hv( const GLhalf *v )
03814 {
03815   NVSG_GL_STATS_FCT_COUNT();
03816   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColor3hv );
03817   glContext()->m_glFunctions->glColor3hv( v );
03818   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03819 }
03820
03822
03823 inline  void  GLColor3i( GLint red, GLint green, GLint blue )
03824 {
03825   NVSG_GL_STATS_COLOR3I( red, green, blue );
03826   glColor3i( red, green, blue );
03827   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03828 }
03829
03831
03832 inline  void  GLColor3iv( const GLint * v )
03833 {
03834   NVSG_GL_STATS_COLOR3IV( v );
03835   glColor3iv( v );
03836   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03837 }
03838
03840
03841 inline  void  GLColor3s( GLshort red, GLshort green, GLshort blue )
03842 {
03843   NVSG_GL_STATS_COLOR3S( red, green, blue );
03844   glColor3s( red, green, blue );
03845   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03846 }
03847
03849
03850 inline  void  GLColor3sv( const GLshort * v )
03851 {
03852   NVSG_GL_STATS_COLOR3SV( v );
03853   glColor3sv( v );
03854   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03855 }
03856
03858
03859 inline  void  GLColor3ub( GLubyte red, GLubyte green, GLubyte blue )
03860 {
03861   NVSG_GL_STATS_COLOR3UB( red, green, blue );
03862   glColor3ub( red, green, blue );
03863   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03864 }
03865
03867
03868 inline  void  GLColor3ubv( const GLubyte * v )
03869 {
03870   NVSG_GL_STATS_COLOR3UBV( v );
03871   glColor3ubv( v );
03872   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03873 }
03874
03876
03877 inline  void  GLColor3ui( GLuint red, GLuint green, GLuint blue )
03878 {
03879   NVSG_GL_STATS_COLOR3UI( red, green, blue );
03880   glColor3ui( red, green, blue );
03881   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03882 }
03883
03885
03886 inline  void  GLColor3uiv( const GLuint * v )
03887 {
03888   NVSG_GL_STATS_COLOR3UIV( v );
03889   glColor3uiv( v );
03890   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03891 }
03892
03894
03895 inline  void  GLColor3us( GLushort red, GLushort green, GLushort blue )
03896 {
03897   NVSG_GL_STATS_COLOR3US( red, green, blue );
03898   glColor3us( red, green, blue );
03899   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03900 }
03901
03903
03904 inline  void  GLColor3usv( const GLushort * v )
03905 {
03906   NVSG_GL_STATS_COLOR3USV( v );
03907   glColor3usv( v );
03908   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03909 }
03910
03912
03913 inline  void  GLColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
03914 {
03915   NVSG_GL_STATS_COLOR4B( red, green, blue, alpha );
03916   glColor4b( red, green, blue, alpha );
03917   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03918 }
03919
03921
03922 inline  void  GLColor4bv( const GLbyte * v )
03923 {
03924   NVSG_GL_STATS_COLOR4BV( v );
03925   glColor4bv( v );
03926   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03927 }
03928
03930
03931 inline  void  GLColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
03932 {
03933   NVSG_GL_STATS_COLOR4D( red, green, blue, alpha );
03934   glColor4d( red, green, blue, alpha );
03935   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03936 }
03937
03939
03940 inline  void  GLColor4dv( const GLdouble * v )
03941 {
03942   NVSG_GL_STATS_COLOR4DV( v );
03943   glColor4dv( v );
03944   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03945 }
03946
03948
03949 inline  void  GLColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
03950 {
03951   NVSG_GL_STATS_COLOR4F( red, green, blue, alpha );
03952   glColor4f( red, green, blue, alpha );
03953   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03954 }
03955
03957
03958 inline  void  GLColor4fv( const GLfloat * v )
03959 {
03960   NVSG_GL_STATS_COLOR4FV( v );
03961   glColor4fv( v );
03962   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03963 }
03964
03966
03967 inline  void  GLColor4h( GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha )
03968 {
03969   NVSG_GL_STATS_FCT_COUNT();
03970   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColor4h );
03971   glContext()->m_glFunctions->glColor4h( red, green, blue, alpha );
03972   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03973 }
03974
03976
03977 inline  void  GLColor4hv( const GLhalf *v )
03978 {
03979   NVSG_GL_STATS_FCT_COUNT();
03980   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColor4hv );
03981   glContext()->m_glFunctions->glColor4hv( v );
03982   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03983 }
03984
03986
03987 inline  void  GLColor4i( GLint red, GLint green, GLint blue, GLint alpha )
03988 {
03989   NVSG_GL_STATS_COLOR4I( red, green, blue, alpha );
03990   glColor4i( red, green, blue, alpha );
03991   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03992 }
03993
03995
03996 inline  void  GLColor4iv( const GLint * v )
03997 {
03998   NVSG_GL_STATS_COLOR4IV( v );
03999   glColor4iv( v );
04000   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04001 }
04002
04004
04005 inline  void  GLColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
04006 {
04007   NVSG_GL_STATS_COLOR4S( red, green, blue, alpha );
04008   glColor4s( red, green, blue, alpha );
04009   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04010 }
04011
04013
04014 inline  void  GLColor4sv( const GLshort * v )
04015 {
04016   NVSG_GL_STATS_COLOR4SV( v );
04017   glColor4sv( v );
04018   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04019 }
04020
04022
04023 inline  void  GLColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
04024 {
04025   NVSG_GL_STATS_COLOR4UB( red, green, blue, alpha );
04026   glColor4ub( red, green, blue, alpha );
04027   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04028 }
04029
04031
04032 inline  void  GLColor4ubv( const GLubyte * v )
04033 {
04034   NVSG_GL_STATS_COLOR4UBV( v );
04035   glColor4ubv( v );
04036   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04037 }
04038
04040
04041 inline  void  GLColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
04042 {
04043   NVSG_GL_STATS_COLOR4UI( red, green, blue, alpha );
04044   glColor4ui( red, green, blue, alpha );
04045   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04046 }
04047
04049
04050 inline  void  GLColor4uiv( const GLuint * v )
04051 {
04052   NVSG_GL_STATS_COLOR4UIV( v );
04053   glColor4uiv( v );
04054   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04055 }
04056
04058
04059 inline  void  GLColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
04060 {
04061   NVSG_GL_STATS_COLOR4US( red, green, blue, alpha );
04062   glColor4us( red, green, blue, alpha );
04063   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04064 }
04065
04067
04068 inline  void  GLColor4usv( const GLushort * v )
04069 {
04070   NVSG_GL_STATS_COLOR4USV( v );
04071   glColor4usv( v );
04072   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
04073 }
04074
04076
04077 inline  void  GLColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
04078 {
04079 #if defined( GL_CACHING )
04080   GLContext * ctx = glContext();
04081 # if defined(GL_SUPPORT_RESET)
04082   memcpy( &ctx->m_previousAttributes.m_colorWriteMask[0]
04083         , &ctx->m_colorBufferAttributes.m_colorWriteMask[0], 4*sizeof(GLboolean) );
04084 # endif
04085   if (    ( ctx->m_colorBufferAttributes.m_colorWriteMask[0] != red )
04086       ||  ( ctx->m_colorBufferAttributes.m_colorWriteMask[1] != green )
04087       ||  ( ctx->m_colorBufferAttributes.m_colorWriteMask[2] != blue )
04088       ||  ( ctx->m_colorBufferAttributes.m_colorWriteMask[3] != alpha ) )
04089 #endif
04090   {
04091     NVSG_GL_STATS_FCT_COUNT();
04092     glColorMask( red, green, blue, alpha );
04093     ASSERT_GL_NO_ERROR;
04094 #if defined( GL_CACHING )
04095     ctx->m_colorBufferAttributes.m_colorWriteMask[0] = red;
04096     ctx->m_colorBufferAttributes.m_colorWriteMask[1] = green;
04097     ctx->m_colorBufferAttributes.m_colorWriteMask[2] = blue;
04098     ctx->m_colorBufferAttributes.m_colorWriteMask[3] = alpha;
04099 #endif
04100   }
04101 }
04102
04104
04105 inline  void  GLColorMaskIndexed( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a )
04106 {
04107   NVSG_GL_STATS_FCT_COUNT();
04108   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColorMaskIndexed );
04109   glContext()->m_glFunctions->glColorMaskIndexed( index, r, b, g, a );
04110   ASSERT_GL_NO_ERROR;
04111 }
04112
04117 inline void GLResetColorMask()
04118 {
04119 #if defined(GL_SUPPORT_RESET)
04120   GLContext * ctx = glContext();
04121   GLColorMask( ctx->m_previousAttributes.m_colorWriteMask[0]
04122              , ctx->m_previousAttributes.m_colorWriteMask[1]
04123              , ctx->m_previousAttributes.m_colorWriteMask[2]
04124              , ctx->m_previousAttributes.m_colorWriteMask[3] );
04125 #else
04126   GLColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
04127 #endif
04128 }
04129
04131
04132 inline  void  GLColorMaterial( GLenum face, GLenum mode )
04133 {
04134 #if defined( GL_CACHING )
04135   GLContext * ctx = glContext();
04136 # if defined(GL_SUPPORT_RESET)
04137   ctx->m_previousAttributes.m_colorMaterialFace = ctx->m_lightingAttributes.m_colorMaterialFace;
04138   ctx->m_previousAttributes.m_colorMaterialMode = ctx->m_lightingAttributes.m_colorMaterialMode;
04139 # endif
04140   if (    ( ctx->m_lightingAttributes.m_colorMaterialFace != face )
04141       ||  ( ctx->m_lightingAttributes.m_colorMaterialMode != mode ) )
04142 #endif
04143   {
04144     NVSG_GL_STATS_FCT_COUNT();
04145     glColorMaterial( face, mode );
04146     ASSERT_GL_NO_ERROR;
04147 #if defined( GL_CACHING )
04148     ctx->m_lightingAttributes.m_colorMaterialFace = face;
04149     ctx->m_lightingAttributes.m_colorMaterialMode = mode;
04150 #endif
04151   }
04152 }
04153
04159 inline void GLResetColorMaterialMode()
04160 {
04161 #if defined(GL_SUPPORT_RESET)
04162   GLContext * ctx = glContext();
04163   GLColorMaterial( ctx->m_previousAttributes.m_colorMaterialFace
04164                  , ctx->m_previousAttributes.m_colorMaterialMode );
04165 #else
04166   GLColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
04167 #endif
04168 }
04169
04171
04172 inline  void  GLColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
04173 {
04174   NVSG_GL_STATS_FCT_COUNT();
04175   glColorPointer( size, type, stride, pointer );
04176   ASSERT_GL_NO_ERROR;
04177 }
04178
04180
04181 inline  void  GLColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data )
04182 {
04183   NVSG_GL_STATS_FCT_COUNT();
04184   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColorSubTable );
04185   glContext()->m_glFunctions->glColorSubTable( target, start, count, format, type, data );
04186   ASSERT_GL_NO_ERROR;
04187 }
04188
04190
04191 inline  void  GLColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table )
04192 {
04193   NVSG_GL_STATS_FCT_COUNT();
04194   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColorTable );
04195   glContext()->m_glFunctions->glColorTable( target, internalformat, width, format, type, table );
04196   ASSERT_GL_NO_ERROR;
04197 }
04198
04200
04201 inline  void  GLColorTableParameterfv( GLenum target, GLenum pname, const GLfloat *params )
04202 {
04203   NVSG_GL_STATS_FCT_COUNT();
04204   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColorTableParameterfv );
04205   glContext()->m_glFunctions->glColorTableParameterfv( target, pname, params );
04206   ASSERT_GL_NO_ERROR;
04207 }
04208
04210
04211 inline  void  GLColorTableParameteriv( GLenum target, GLenum pname, const GLint *params )
04212 {
04213   NVSG_GL_STATS_FCT_COUNT();
04214   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glColorTableParameteriv );
04215   glContext()->m_glFunctions->glColorTableParameteriv( target, pname, params );
04216   ASSERT_GL_NO_ERROR;
04217 }
04218
04220
04221 inline  void  GLCombinerInput( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage )
04222 {
04223   NVSG_GL_STATS_FCT_COUNT();
04224   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCombinerInput );
04225   glContext()->m_glFunctions->glCombinerInput( stage, portion, variable, input, mapping, componentUsage );
04226   ASSERT_GL_NO_ERROR;
04227 }
04228
04230
04231 inline  void  GLCombinerOutput( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum )
04232 {
04233   NVSG_GL_STATS_FCT_COUNT();
04234   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCombinerOutput );
04235   glContext()->m_glFunctions->glCombinerOutput( stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum );
04236   ASSERT_GL_NO_ERROR;
04237 }
04238
04240
04241 inline  void  GLCombinerParameterf( GLenum pname, GLfloat param )
04242 {
04243   NVSG_GL_STATS_FCT_COUNT();
04244   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCombinerParameterf );
04245   glContext()->m_glFunctions->glCombinerParameterf( pname, param );
04246   ASSERT_GL_NO_ERROR;
04247 }
04248
04250
04251 inline  void  GLCombinerParameterfv( GLenum pname, const GLfloat *params )
04252 {
04253   NVSG_GL_STATS_FCT_COUNT();
04254   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCombinerParameterfv );
04255   glContext()->m_glFunctions->glCombinerParameterfv( pname, params );
04256   ASSERT_GL_NO_ERROR;
04257 }
04258
04260
04261 inline  void  GLCombinerParameteri( GLenum pname, GLint param )
04262 {
04263   NVSG_GL_STATS_FCT_COUNT();
04264   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCombinerParameteri );
04265   glContext()->m_glFunctions->glCombinerParameteri( pname, param );
04266   ASSERT_GL_NO_ERROR;
04267 }
04268
04270
04271 inline  void  GLCombinerParameteriv( GLenum pname, const GLint *params )
04272 {
04273   NVSG_GL_STATS_FCT_COUNT();
04274   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCombinerParameteriv );
04275   glContext()->m_glFunctions->glCombinerParameteriv( pname, params );
04276   ASSERT_GL_NO_ERROR;
04277 }
04278
04280
04281 inline  void  GLCombinerStageParameterfv( GLenum stage, GLenum pname, const GLfloat *params )
04282 {
04283   NVSG_GL_STATS_FCT_COUNT();
04284   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCombinerStageParameterfv );
04285   glContext()->m_glFunctions->glCombinerStageParameterfv( stage, pname, params );
04286   ASSERT_GL_NO_ERROR;
04287 }
04288
04290
04291 inline  void  GLCompileShader( GLuint shader )
04292 {
04293   NVSG_GL_STATS_FCT_COUNT();
04294   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompileShader );
04295   glContext()->m_glFunctions->glCompileShader( shader );
04296   ASSERT_GL_NO_ERROR;
04297 }
04298
04300
04302 inline  void  GLCompressedTexImage1D( GLenum target, int level, GLenum internalformat, GLsizei width, int border, GLsizei imageSize, const void *data )
04303 {
04304 #if defined(GL_CACHING)
04305   _GLUpdateActiveTexture();
04306 #endif
04307   NVSG_GL_STATS_FCT_COUNT();
04308   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexImage1D );
04309   glContext()->m_glFunctions->glCompressedTexImage1D( target, level, internalformat, width, border, imageSize, data );
04310   ASSERT_GL_NO_ERROR;
04311 }
04312
04314
04316 inline  void  GLCompressedTexImage2D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, int border, GLsizei imageSize, const void *data )
04317 {
04318 #if defined(GL_CACHING)
04319   _GLUpdateActiveTexture();
04320 #endif
04321   NVSG_GL_STATS_FCT_COUNT();
04322   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexImage2D );
04323   glContext()->m_glFunctions->glCompressedTexImage2D( target, level, internalformat, width, height, border, imageSize, data );
04324   ASSERT_GL_NO_ERROR;
04325 }
04326
04328
04330 inline  void  GLCompressedTexImage3D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLsizei imageSize, const void *data )
04331 {
04332 #if defined(GL_CACHING)
04333   _GLUpdateActiveTexture();
04334 #endif
04335   NVSG_GL_STATS_FCT_COUNT();
04336   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexImage3D );
04337   glContext()->m_glFunctions->glCompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data );
04338   ASSERT_GL_NO_ERROR;
04339 }
04340
04342
04343 inline  void  GLCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data )
04344 {
04345 #if defined(GL_CACHING)
04346   _GLUpdateActiveTexture();
04347 #endif
04348   NVSG_GL_STATS_FCT_COUNT();
04349   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexSubImage1D );
04350   glContext()->m_glFunctions->glCompressedTexSubImage1D( target, level, xoffset, width, format, imageSize, data );
04351   ASSERT_GL_NO_ERROR;
04352 }
04353
04355
04356 inline  void  GLCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data )
04357 {
04358 #if defined(GL_CACHING)
04359   _GLUpdateActiveTexture();
04360 #endif
04361   NVSG_GL_STATS_FCT_COUNT();
04362   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexSubImage2D );
04363   glContext()->m_glFunctions->glCompressedTexSubImage2D( target, level, xoffset, yoffset, width, height, format, imageSize, data );
04364   ASSERT_GL_NO_ERROR;
04365 }
04366
04368
04369 inline  void  GLCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data )
04370 {
04371 #if defined(GL_CACHING)
04372   _GLUpdateActiveTexture();
04373 #endif
04374   NVSG_GL_STATS_FCT_COUNT();
04375   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexSubImage3D );
04376   glContext()->m_glFunctions->glCompressedTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
04377   ASSERT_GL_NO_ERROR;
04378 }
04379
04381
04382 inline  void  GLConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image )
04383 {
04384   NVSG_GL_STATS_FCT_COUNT();
04385   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glConvolutionFilter1D );
04386   glContext()->m_glFunctions->glConvolutionFilter1D( target, internalformat, width, format, type, image );
04387   ASSERT_GL_NO_ERROR;
04388 }
04389
04391
04392 inline  void  GLConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image )
04393 {
04394   NVSG_GL_STATS_FCT_COUNT();
04395   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glConvolutionFilter2D );
04396   glContext()->m_glFunctions->glConvolutionFilter2D( target, internalformat, width, height, format, type, image );
04397   ASSERT_GL_NO_ERROR;
04398 }
04399
04401
04402 inline  void  GLConvolutionParameterf( GLenum target, GLenum pname, GLfloat params )
04403 {
04404   NVSG_GL_STATS_FCT_COUNT();
04405   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glConvolutionParameterf );
04406   glContext()->m_glFunctions->glConvolutionParameterf( target, pname, params );
04407   ASSERT_GL_NO_ERROR;
04408 }
04409
04411
04412 inline  void  GLConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params )
04413 {
04414   NVSG_GL_STATS_FCT_COUNT();
04415   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glConvolutionParameterfv );
04416   glContext()->m_glFunctions->glConvolutionParameterfv( target, pname, params );
04417   ASSERT_GL_NO_ERROR;
04418 }
04419
04421
04422 inline  void  GLConvolutionParameteri( GLenum target, GLenum pname, GLint params )
04423 {
04424   NVSG_GL_STATS_FCT_COUNT();
04425   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glConvolutionParameteri );
04426   glContext()->m_glFunctions->glConvolutionParameteri( target, pname, params );
04427   ASSERT_GL_NO_ERROR;
04428 }
04429
04431
04432 inline  void  GLConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params )
04433 {
04434   NVSG_GL_STATS_FCT_COUNT();
04435   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glConvolutionParameteriv );
04436   glContext()->m_glFunctions->glConvolutionParameteriv( target, pname, params );
04437   ASSERT_GL_NO_ERROR;
04438 }
04439
04441
04442 inline  void  GLCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width )
04443 {
04444   NVSG_GL_STATS_FCT_COUNT();
04445   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCopyColorSubTable );
04446   glContext()->m_glFunctions->glCopyColorSubTable( target, start, x, y, width );
04447   ASSERT_GL_NO_ERROR;
04448 }
04449
04451
04452 inline  void  GLCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
04453 {
04454   NVSG_GL_STATS_FCT_COUNT();
04455   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCopyColorTable );
04456   glContext()->m_glFunctions->glCopyColorTable( target, internalformat, x, y, width );
04457   ASSERT_GL_NO_ERROR;
04458 }
04459
04461
04462 inline  void  GLCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
04463 {
04464   NVSG_GL_STATS_FCT_COUNT();
04465   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCopyConvolutionFilter1D );
04466   glContext()->m_glFunctions->glCopyConvolutionFilter1D( target, internalformat, x, y, width );
04467   ASSERT_GL_NO_ERROR;
04468 }
04469
04471
04472 inline  void  GLCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height )
04473 {
04474   NVSG_GL_STATS_FCT_COUNT();
04475   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCopyConvolutionFilter2D );
04476   glContext()->m_glFunctions->glCopyConvolutionFilter2D( target, internalformat, x, y, width, height );
04477   ASSERT_GL_NO_ERROR;
04478 }
04479
04481
04482 inline  void  GLCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
04483 {
04484   NVSG_GL_STATS_FCT_COUNT();
04485   glCopyPixels( x, y, width, height, type );
04486   ASSERT_GL_NO_ERROR;
04487 }
04488
04490
04491 inline  void  GLCopyTexImage1D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border )
04492 {
04493 #if defined(GL_CACHING)
04494   _GLUpdateActiveTexture();
04495 #endif
04496   NVSG_GL_STATS_FCT_COUNT();
04497   glCopyTexImage1D( target, level, internalFormat, x, y, width, border );
04498   ASSERT_GL_NO_ERROR;
04499 }
04500
04502
04503 inline  void  GLCopyTexImage2D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
04504 {
04505 #if defined(GL_CACHING)
04506   _GLUpdateActiveTexture();
04507 #endif
04508   NVSG_GL_STATS_FCT_COUNT();
04509   glCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );
04510   ASSERT_GL_NO_ERROR;
04511 }
04512
04514
04515 inline  void  GLCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
04516 {
04517 #if defined(GL_CACHING)
04518   _GLUpdateActiveTexture();
04519 #endif
04520   NVSG_GL_STATS_FCT_COUNT();
04521   glCopyTexSubImage1D( target,level, xoffset, x, y, width );
04522   ASSERT_GL_NO_ERROR;
04523 }
04524
04526
04527 inline  void  GLCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
04528 {
04529 #if defined(GL_CACHING)
04530   _GLUpdateActiveTexture();
04531 #endif
04532   NVSG_GL_STATS_FCT_COUNT();
04533   glCopyTexSubImage2D( target,level, xoffset, yoffset, x, y, width, height );
04534   ASSERT_GL_NO_ERROR;
04535 }
04536
04538
04539 inline  void  GLCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
04540 {
04541 #if defined(GL_CACHING)
04542   _GLUpdateActiveTexture();
04543 #endif
04544   NVSG_GL_STATS_FCT_COUNT();
04545   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCopyTexSubImage3D );
04546   glContext()->m_glFunctions->glCopyTexSubImage3D( target,level, xoffset, yoffset, zoffset, x, y, width, height );
04547   ASSERT_GL_NO_ERROR;
04548 }
04549
04551
04552 inline  GLuint  GLCreateProgram()
04553 {
04554   NVSG_GL_STATS_FCT_COUNT();
04555   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCreateProgram );
04556   GLuint prg = glContext()->m_glFunctions->glCreateProgram();
04557   ASSERT_GL_NO_ERROR;
04558   return( prg );
04559 }
04560
04562
04563 inline  GLhandleARB GLCreateProgramObject()
04564 {
04565   NVSG_GL_STATS_FCT_COUNT();
04566   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCreateProgramObjectARB );
04567   GLhandleARB hdl = glContext()->m_glFunctions->glCreateProgramObjectARB();
04568   ASSERT_GL_NO_ERROR;
04569   return( hdl );
04570 }
04571
04573
04574 inline  GLuint  GLCreateShader( GLenum type )
04575 {
04576   NVSG_GL_STATS_FCT_COUNT();
04577   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCreateShader );
04578   GLuint sh = glContext()->m_glFunctions->glCreateShader( type );
04579   ASSERT_GL_NO_ERROR;
04580   return( sh );
04581 }
04582
04584
04585 inline  GLhandleARB GLCreateShaderObject( GLenum shaderType )
04586 {
04587   NVSG_GL_STATS_FCT_COUNT();
04588   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCreateShaderObjectARB );
04589   GLhandleARB hdl = glContext()->m_glFunctions->glCreateShaderObjectARB( shaderType );
04590   ASSERT_GL_NO_ERROR;
04591   return( hdl );
04592 }
04593
04595
04596 inline  void  GLCullFace( GLenum mode )
04597 {
04598   GLContext * ctx = glContext();
04599 #if defined( GL_CACHING )
04600 # if defined(GL_SUPPORT_RESET)
04601   ctx->m_previousAttributes.m_cullFaceMode = ctx->m_polygonAttributes.m_cullFaceMode;
04602 # endif
04603   if ( ctx->m_polygonAttributes.m_cullFaceMode != mode )
04604 #endif
04605   {
04606     if ( ! ctx->m_locks.m_cullFaceMode )
04607     {
04608       NVSG_GL_STATS_FCT_COUNT();
04609       glCullFace( mode );
04610       ASSERT_GL_NO_ERROR;
04611 #if defined( GL_CACHING )
04612       ctx->m_polygonAttributes.m_cullFaceMode = mode;
04613 #endif
04614     }
04615   }
04616 }
04617
04622 inline void GLResetCullFaceMode()
04623 {
04624 #if defined(GL_SUPPORT_RESET)
04625   GLCullFace( glContext()->m_previousAttributes.m_cullFaceMode );
04626 #else
04627   GLCullFace( GL_BACK );
04628 #endif
04629 }
04630
04636 inline void GLCullFaceLock( GLenum mode )
04637 {
04638   NVSG_ASSERT( ! glContext()->m_locks.m_cullFaceMode );
04639   GLCullFace( mode );
04640   glContext()->m_locks.m_cullFaceMode = true;
04641 }
04642
04648 inline void GLCullFaceUnlock( GLenum mode )
04649 {
04650   glContext()->m_locks.m_cullFaceMode = false;
04651   GLCullFace( mode );
04652 }
04653
04655
04656 inline  void  GLDeleteLists( GLuint list, GLsizei range )
04657 {
04658   NVSG_GL_STATS_DELETE_LISTS( list, range );
04659   glContext()->removeLists(range, list);
04660   glDeleteLists( list, range );
04661   ASSERT_GL_NO_ERROR;
04662 }
04663
04665
04666 inline  void  GLDeleteObject( GLhandleARB obj )
04667 {
04668   NVSG_GL_STATS_FCT_COUNT();
04669   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDeleteObjectARB );
04670   glContext()->m_glFunctions->glDeleteObjectARB( obj );
04671   ASSERT_GL_NO_ERROR;
04672 }
04673
04675
04676 inline  void  GLDeleteOcclusionQueries( GLsizei n, const GLuint *ids )
04677 {
04678   NVSG_GL_STATS_FCT_COUNT();
04679   GLContext * ctx = glContext();
04680   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteOcclusionQueriesNV );
04681   ctx->removeOcclusionQueries(n, ids);
04682   ctx->m_glFunctions->glDeleteOcclusionQueriesNV( n, ids );
04683   ASSERT_GL_NO_ERROR;
04684 }
04685
04687
04688 inline  void  GLDeleteProgram( GLuint program )
04689 {
04690   NVSG_GL_STATS_FCT_COUNT();
04691   GLContext * ctx = glContext();
04692   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteProgram );
04693   ctx->removePrograms(1, &program);
04694   ctx->m_glFunctions->glDeleteProgram( program );
04695   ASSERT_GL_NO_ERROR;
04696 }
04697
04699
04701 inline  void  GLDeletePrograms( GLsizei n, const GLuint *ids )
04702 {
04703   NVSG_GL_STATS_FCT_COUNT();
04704   GLContext * ctx = glContext();
04705   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteProgramsNV );
04706   ctx->removePrograms(n, ids);
04707   ctx->m_glFunctions->glDeleteProgramsNV( n, ids );
04708   ASSERT_GL_NO_ERROR;
04709 }
04710
04712
04713 inline  void  GLDeleteQueries( GLsizei n, const GLuint *ids )
04714 {
04715   NVSG_GL_STATS_FCT_COUNT();
04716   GLContext * ctx = glContext();
04717   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteQueries );
04718   ctx->removeQueries( n, ids );
04719   ctx->m_glFunctions->glDeleteQueries( n, ids );
04720   ASSERT_GL_NO_ERROR;
04721 }
04722
04724
04725 inline  void  GLDeleteShader( GLuint shader )
04726 {
04727   NVSG_GL_STATS_FCT_COUNT();
04728   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDeleteShader );
04729   glContext()->m_glFunctions->glDeleteShader( shader );
04730   ASSERT_GL_NO_ERROR;
04731 }
04732
04734
04735 inline  void  GLDeleteTextures( GLsizei n, const GLuint *textures )
04736 {
04737   NVSG_GL_STATS_DELETE_TEXTURES( n, textures );
04738   GLContext * ctx = glContext();
04739   ctx->removeTextures(n, textures);
04740   glDeleteTextures( n, textures );
04741   ASSERT_GL_NO_ERROR;
04742 }
04743
04745
04746 inline  void  GLDepthBounds( GLclampd zmin, GLclampd zmax )
04747 {
04748   NVSG_GL_STATS_FCT_COUNT();
04749   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDepthBounds );
04750   glContext()->m_glFunctions->glDepthBounds( zmin, zmax );
04751   ASSERT_GL_NO_ERROR;
04752 }
04753
04755
04756 inline  void  GLDepthBoundsd( GLdouble zmin, GLdouble zmax )
04757 {
04758   NVSG_GL_STATS_FCT_COUNT();
04759   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDepthBoundsd );
04760   glContext()->m_glFunctions->glDepthBoundsd( zmin, zmax );
04761   ASSERT_GL_NO_ERROR;
04762 }
04763
04765
04766 inline  void  GLDepthFunc( GLenum func )
04767 {
04768 #if defined( GL_CACHING )
04769   GLContext * ctx = glContext();
04770 # if defined(GL_SUPPORT_RESET)
04771   ctx->m_previousAttributes.m_depthFunc = ctx->m_depthBufferAttributes.m_depthFunc;
04772 # endif
04773   if ( ctx->m_depthBufferAttributes.m_depthFunc != func )
04774 #endif
04775   {
04776     NVSG_GL_STATS_DEPTH_FUNC( func );
04777     glDepthFunc( func );
04778     ASSERT_GL_NO_ERROR;
04779 #if defined( GL_CACHING )
04780     ctx->m_depthBufferAttributes.m_depthFunc = func;
04781 #endif
04782   }
04783 }
04784
04789 inline void GLResetDepthFunc()
04790 {
04791 #if defined(GL_SUPPORT_RESET)
04792   GLDepthFunc( glContext()->m_previousAttributes.m_depthFunc );
04793 #else
04794   GLDepthFunc( GL_LESS );
04795 #endif
04796 }
04797
04799
04800 inline  void  GLDepthMask( GLboolean flag )
04801 {
04802 #if defined( GL_CACHING )
04803   GLContext * ctx = glContext();
04804 # if defined(GL_SUPPORT_RESET)
04805   ctx->m_previousAttributes.m_depthWriting = ctx->m_depthBufferAttributes.m_depthWriting;
04806 # endif
04807   if ( ctx->m_depthBufferAttributes.m_depthWriting != flag )
04808 #endif
04809   {
04810     NVSG_GL_STATS_DEPTH_MASK( flag );
04811     glDepthMask( flag );
04812     ASSERT_GL_NO_ERROR;
04813 #if defined( GL_CACHING )
04814     ctx->m_depthBufferAttributes.m_depthWriting = flag;
04815 #endif
04816   }
04817 }
04818
04823 inline void GLResetDepthMask()
04824 {
04825 #if defined(GL_SUPPORT_RESET)
04826   GLDepthMask( glContext()->m_previousAttributes.m_depthWriting );
04827 #else
04828   GLDepthMask( GL_TRUE );
04829 #endif
04830 }
04831
04833
04834 inline  void  GLDepthRange( GLclampd znear, GLclampd zfar )
04835 {
04836 #if defined( GL_CACHING )
04837   GLContext * ctx = glContext();
04838 # if defined(GL_SUPPORT_RESET)
04839   ctx->m_previousAttributes.m_depthRangeNear = ctx->m_viewportAttributes.m_depthRangeNear;
04840   ctx->m_previousAttributes.m_depthRangeFar  = ctx->m_viewportAttributes.m_depthRangeFar;
04841 # endif
04842   if (    ( ctx->m_viewportAttributes.m_depthRangeNear != znear )
04843       ||  ( ctx->m_viewportAttributes.m_depthRangeFar  != zfar ) )
04844 #endif
04845   {
04846     NVSG_GL_STATS_FCT_COUNT();
04847     glDepthRange( znear, zfar );
04848     ASSERT_GL_NO_ERROR;
04849 #if defined( GL_CACHING )
04850     ctx->m_viewportAttributes.m_depthRangeNear = znear;
04851     ctx->m_viewportAttributes.m_depthRangeFar  = zfar;
04852 #endif
04853   }
04854 }
04855
04857
04858 inline  void  GLDepthRanged( GLdouble zNear, GLdouble zFar )
04859 {
04860   NVSG_GL_STATS_FCT_COUNT();
04861   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDepthRanged );
04862   glContext()->m_glFunctions->glDepthRanged( zNear, zFar );
04863   ASSERT_GL_NO_ERROR;
04864 }
04865
04870 inline void GLResetDepthRange()
04871 {
04872 #if defined(GL_SUPPORT_RESET)
04873   GLContext * ctx = glContext();
04874   GLDepthRange( ctx->m_previousAttributes.m_depthRangeNear
04875               , ctx->m_previousAttributes.m_depthRangeFar );
04876 #else
04877   GLDepthRange( 0.0, 1.0 );
04878 #endif
04879 }
04880
04882 inline  void  GLDetachObject( GLhandleARB containerObj, GLhandleARB attachedObj )
04883 {
04884   NVSG_GL_STATS_FCT_COUNT();
04885   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDetachObjectARB );
04886   glContext()->m_glFunctions->glDetachObjectARB( containerObj, attachedObj );
04887   ASSERT_GL_NO_ERROR;
04888 }
04889
04891 inline  void  GLDetachShader( GLuint program, GLuint shader )
04892 {
04893   NVSG_GL_STATS_FCT_COUNT();
04894   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDetachShader );
04895   glContext()->m_glFunctions->glDetachShader( program, shader );
04896   ASSERT_GL_NO_ERROR;
04897 }
04898
04899 #if !defined(DOXYGEN_IGNORE)  // no need to document internal helper functions/macros
04900 #if defined( GL_CACHING )
04901 inline void _GLDisableCached( GLenum cap, GLboolean * cache )
04902 {
04903   if ( *cache )
04904   {
04905     NVSG_ASSERT( glIsEnabled( cap ) );
04906     _GLDisable( cap );
04907     *cache = GL_FALSE;
04908   }
04909 }
04910 inline void _GLEnableCached( GLenum cap, GLboolean * cache )
04911 {
04912   if ( !*cache )
04913   {
04914     NVSG_ASSERT( ! glIsEnabled( cap ) );
04915     _GLEnable( cap );
04916     *cache = GL_TRUE;
04917   }
04918 }
04919 inline GLboolean _GLIsEnabledCached( GLenum cap, GLboolean cache )
04920 {
04921   NVSG_ASSERT( cache == glIsEnabled( cap ) );
04922   return( cache );
04923 }
04924 # if defined(GL_SUPPORT_RESET)
04925 inline void _GLEnableCached( GLenum cap, GLboolean * cache, GLboolean * prev )
04926 {
04927   *prev = *cache;
04928   _GLEnableCached( cap, cache );
04929 }
04930 inline void _GLDisableCached( GLenum cap, GLboolean * cache, GLboolean * prev )
04931 {
04932   *prev = *cache;
04933   _GLDisableCached( cap, cache );
04934 }
04935 #  define GL_DISABLE( cap, cache, prev )  _GLDisableCached( cap, cache, prev )
04936 #  define GL_ENABLE( cap, cache, prev )   _GLEnableCached( cap, cache, prev )
04937 #  define GL_IS_ENABLED( cap, cache )      _GLIsEnabledCached( cap, cache )
04938 # else
04939 #  define GL_DISABLE( cap, cache, prev )   _GLDisable( cap )
04940 #  define GL_ENABLE( cap, cache, prev )    _GLEnable( cap )
04941 #  define GL_IS_ENABLED( cap, cache )      _GLIsEnabled( cap )
04942 # endif
04943 #else
04944 # define GL_DISABLE( cap, cache, prev )  _GLDisable( cap )
04945 # define GL_ENABLE( cap, cache, prev )   _GLEnable( cap )
04946 #endif
04947
04948 #if defined(GL_SUPPORT_RESET)
04949 # define GL_RESET( cap, cache, prev ) ( prev ? _GLEnableCached( cap, cache ) : _GLDisableCached( cap, cache ) )
04950 #else
04951 # define GL_RESET( cap, cache, prev ) _GLDisable( cap );
04952 #endif
04953 #endif // DOXYGEN_IGNORE
04954
04955
04957
04959 inline  void  GLDisableAlphaTest( void )
04960 {
04961   GL_DISABLE( GL_ALPHA_TEST, &glContext()->m_colorBufferEnableAttributes.m_alphaTest
04962             , &glContext()->m_previousAttributes.m_alphaTest );
04963 }
04964
04966
04968 inline  void  GLDisableAutoNormal( void )
04969 {
04970   GL_DISABLE( GL_AUTO_NORMAL, &glContext()->m_evalAttributes.m_autoNormal
04971             , &glContext()->m_previousAttributes.m_autoNormal );
04972 }
04973
04975
04977 inline  void  GLDisableBlend( void )
04978 {
04979   GL_DISABLE( GL_BLEND, &glContext()->m_colorBufferEnableAttributes.m_blend
04980             , &glContext()->m_previousAttributes.m_blend );
04981 }
04982
04984
04986 inline  void  GLDisableClipPlane( GLenum plane )
04987 {
04988 #if defined( GL_CACHING )
04989   NVSG_ASSERT( plane-GL_CLIP_PLANE0 < glContext()->m_transformEnableAttributes.m_clipPlanes.size() );
04990 #endif
04991   GL_DISABLE( plane, &glContext()->m_transformEnableAttributes.m_clipPlanes[plane-GL_CLIP_PLANE0]
04992             , &glContext()->m_previousAttributes.m_clipPlanes[plane-GL_CLIP_PLANE0] );
04993 }
04994
04996
04998 inline  void  GLDisableColorLogicOp( void )
04999 {
05000   GL_DISABLE( GL_COLOR_LOGIC_OP, &glContext()->m_colorBufferEnableAttributes.m_colorLogicOp
05001             , &glContext()->m_previousAttributes.m_colorLogicOp );
05002 }
05003
05005
05007 inline  void  GLDisableColorMaterial( void )
05008 {
05009 #if defined( GL_CACHING )
05010   GLContext * ctx = glContext();
05011 # if defined(GL_SUPPORT_RESET)
05012   ctx->m_previousAttributes.m_colorMaterial = ctx->m_lightingAttributes.m_colorMaterial;
05013 # endif
05014   if ( ctx->m_lightingAttributes.m_colorMaterial )
05015   {
05016     NVSG_ASSERT( glIsEnabled( GL_COLOR_MATERIAL ) );
05017 #endif
05018     _GLDisable( GL_COLOR_MATERIAL );
05019 #if defined( GL_CACHING )
05020     ctx->m_lightingAttributes.m_colorMaterial = GL_FALSE;
05021     glGetMaterialfv( GL_BACK, GL_AMBIENT, &ctx->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_BACK][0] );
05022     glGetMaterialfv( GL_FRONT, GL_AMBIENT, &ctx->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0] );
05023     glGetMaterialfv( GL_BACK, GL_DIFFUSE, &ctx->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0] );
05024     glGetMaterialfv( GL_FRONT, GL_DIFFUSE, &ctx->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0] );
05025   }
05026 #endif
05027 }
05028
05030
05032 inline  void  GLDisableCullFace( void )
05033 {
05034   GLContext * ctx = glContext();
05035 #if defined( GL_CACHING )
05036 # if defined(GL_SUPPORT_RESET)
05037   ctx->m_previousAttributes.m_cullFace = ctx->m_polygonEnableAttributes.m_cullFace;
05038 # endif
05039   if ( ctx->m_polygonEnableAttributes.m_cullFace )
05040 #endif
05041   {
05042     if ( ! ctx->m_locks.m_cullFace )
05043     {
05044 #if defined( GL_CACHING )
05045       NVSG_ASSERT( glIsEnabled( GL_CULL_FACE ) );
05046 #endif
05047       _GLDisable( GL_CULL_FACE );
05048 #if defined( GL_CACHING )
05049       ctx->m_polygonEnableAttributes.m_cullFace = GL_FALSE;
05050 #endif
05051     }
05052   }
05053 }
05054
05060 inline void GLDisableCullFaceLock( void )
05061 {
05062   NVSG_ASSERT( ! glContext()->m_locks.m_cullFace );
05063   GLDisableCullFace();
05064   glContext()->m_locks.m_cullFace = true;
05065 }
05066
05070 inline void GLDisableCullFaceUnlock( void )
05071 {
05072   NVSG_ASSERT( glContext()->m_locks.m_cullFace );
05073   glContext()->m_locks.m_cullFace = false;
05074   GLDisableCullFace();
05075 }
05076
05078
05080 inline  void  GLDisableDepthTest( void )
05081 {
05082   GL_DISABLE( GL_DEPTH_TEST, &glContext()->m_depthBufferEnableAttributes.m_depthTesting
05083             , &glContext()->m_previousAttributes.m_depthTesting );
05084 }
05085
05087
05089 inline  void  GLDisableDither( void )
05090 {
05091   GL_DISABLE( GL_DITHER, &glContext()->m_colorBufferEnableAttributes.m_dither
05092             , &glContext()->m_previousAttributes.m_dither );
05093 }
05094
05096
05098 inline  void  GLDisableFog( void )
05099 {
05100   GL_DISABLE( GL_FOG, &glContext()->m_fogEnableAttributes.m_fog
05101             , &glContext()->m_previousAttributes.m_fog );
05102 }
05103
05105
05106 inline  void  GLDisableIndexed( GLenum target, GLuint index )
05107 {
05108   NVSG_GL_STATS_FCT_COUNT();
05109   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDisableIndexed );
05110   glContext()->m_glFunctions->glDisableIndexed( target, index );
05111   ASSERT_GL_NO_ERROR;
05112 }
05113
05115
05117 inline  void  GLDisableLight( GLenum light )
05118 {
05119 #if defined( GL_CACHING )
05120   NVSG_ASSERT( light-GL_LIGHT0 < glContext()->m_lightingEnableAttributes.m_lights.size() );
05121 #endif
05122   GL_DISABLE( light, &glContext()->m_lightingEnableAttributes.m_lights[light-GL_LIGHT0]
05123             , &glContext()->m_previousAttributes.m_lights[light-GL_LIGHT0] );
05124 }
05125
05127
05129 inline  void  GLDisableLighting( void )
05130 {
05131   GLContext * ctx = glContext();
05132 #if defined( GL_CACHING )
05133 # if defined(GL_SUPPORT_RESET)
05134   ctx->m_previousAttributes.m_lighting = ctx->m_lightingEnableAttributes.m_lighting;
05135 # endif
05136   if ( ctx->m_lightingEnableAttributes.m_lighting )
05137 #endif
05138   {
05139     if ( ! ctx->m_locks.m_lighting )
05140     {
05141 #if defined( GL_CACHING )
05142       NVSG_ASSERT( glIsEnabled( GL_LIGHTING ) );
05143 #endif
05144       _GLDisable( GL_LIGHTING );
05145 #if defined( GL_CACHING )
05146       ctx->m_lightingEnableAttributes.m_lighting = GL_FALSE;
05147 #endif
05148     }
05149   }
05150 }
05151
05157 inline void GLDisableLightingLock( void )
05158 {
05159   NVSG_ASSERT( ! glContext()->m_locks.m_lighting );
05160   GLDisableLighting();
05161   glContext()->m_locks.m_lighting = true;
05162 }
05163
05167 inline void GLDisableLightingUnlock( void )
05168 {
05169   NVSG_ASSERT( glContext()->m_locks.m_lighting );
05170   glContext()->m_locks.m_lighting = false;
05171   GLDisableLighting();
05172 }
05173
05175
05177 inline  void  GLDisableLineSmooth( void )
05178 {
05179   GL_DISABLE( GL_LINE_SMOOTH, &glContext()->m_lineEnableAttributes.m_smooth
05180             , &glContext()->m_previousAttributes.m_lineSmooth );
05181 }
05182
05184
05186 inline  void  GLDisableLineStipple( void )
05187 {
05188   GL_DISABLE( GL_LINE_STIPPLE, &glContext()->m_lineEnableAttributes.m_stipple
05189             , &glContext()->m_previousAttributes.m_lineStipple );
05190 }
05191
05193
05195 inline  void  GLDisableLogicOp( void )
05196 {
05197   GL_DISABLE( GL_LOGIC_OP, &glContext()->m_colorBufferEnableAttributes.m_logicOp
05198             , &glContext()->m_previousAttributes.m_logicOp );
05199 }
05200
05202
05204 inline  void  GLDisableNormalize( void )
05205 {
05206   GL_DISABLE( GL_NORMALIZE, &glContext()->m_transformEnableAttributes.m_normalize
05207             , &glContext()->m_previousAttributes.m_normalize );
05208 }
05209
05211
05213 inline  void  GLDisablePointSmooth( void )
05214 {
05215   GL_DISABLE( GL_POINT_SMOOTH, &glContext()->m_pointEnableAttributes.m_smooth
05216             , &glContext()->m_previousAttributes.m_pointSmooth );
05217 }
05218
05220
05222 inline  void  GLDisablePolygonOffsetFill( void )
05223 {
05224   GL_DISABLE( GL_POLYGON_OFFSET_FILL, &glContext()->m_polygonEnableAttributes.m_offsetFill
05225             , &glContext()->m_previousAttributes.m_offsetFill );
05226 }
05227
05229
05231 inline  void  GLDisablePolygonOffsetLine( void )
05232 {
05233   GL_DISABLE( GL_POLYGON_OFFSET_LINE, &glContext()->m_polygonEnableAttributes.m_offsetLine
05234             , &glContext()->m_previousAttributes.m_offsetLine );
05235 }
05236
05238
05240 inline  void  GLDisablePolygonOffsetPoint( void )
05241 {
05242   GL_DISABLE( GL_POLYGON_OFFSET_POINT, &glContext()->m_polygonEnableAttributes.m_offsetPoint
05243             , &glContext()->m_previousAttributes.m_offsetPoint );
05244 }
05245
05247
05249 inline  void  GLDisablePolygonSmooth( void )
05250 {
05251   GL_DISABLE( GL_POLYGON_SMOOTH, &glContext()->m_polygonEnableAttributes.m_smooth
05252             , &glContext()->m_previousAttributes.m_polygonSmooth );
05253 }
05254
05256
05258 inline  void  GLDisablePolygonStipple( void )
05259 {
05260   GL_DISABLE( GL_POLYGON_STIPPLE, &glContext()->m_polygonEnableAttributes.m_stipple
05261             , &glContext()->m_previousAttributes.m_polygonStipple );
05262 }
05263
05265
05267 inline  void  GLDisableScissorTest( void )
05268 {
05269   GL_DISABLE( GL_SCISSOR_TEST, &glContext()->m_scissorEnableAttributes.m_scissorTest
05270             , &glContext()->m_previousAttributes.m_scissorTest );
05271 }
05272
05274
05276 inline  void  GLDisableStencilTest( void )
05277 {
05278   GL_DISABLE( GL_STENCIL_TEST, &glContext()->m_stencilBufferEnableAttributes.m_stencilTest
05279             , &glContext()->m_previousAttributes.m_stencilTest );
05280 }
05281
05284
05286 inline void GLDisableTexture( GLenum target )
05287 {
05288 #if defined( GL_CACHING )
05289   GLContext * ctx = glContext();
05290   NVSG_ASSERT(   ( target == GL_TEXTURE_1D ) || ( target == GL_TEXTURE_2D ) || ( target == GL_TEXTURE_3D )
05291              ||  ( target == GL_TEXTURE_CUBE_MAP ) || ( target == GL_TEXTURE_RECTANGLE_NV )
05292              ||  ( target == GL_TEXTURE_2D_ARRAY_EXT ) || ( target == GL_TEXTURE_1D_ARRAY_EXT ) );
05293   if ( ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_texture[target] )
05294   {
05295     _GLUpdateActiveTexture();
05296     // array targets are not supported in fixed function pipeline and therefore
05297     // should not be enabled/disabled.
05298     if( target != GL_TEXTURE_2D_ARRAY_EXT && target != GL_TEXTURE_1D_ARRAY_EXT )
05299     {
05300       NVSG_ASSERT( glIsEnabled( target ) );
05301     }
05302 #endif
05303     if( target != GL_TEXTURE_2D_ARRAY_EXT && target != GL_TEXTURE_1D_ARRAY_EXT )
05304     {
05305       _GLDisable( target );
05306     }
05307 #if defined( GL_CACHING )
05308     ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_active].m_texture[target] = GL_FALSE;
05309   }
05310 #endif
05311 }
05312
05314
05316 inline void GLDisableTextureGen( GLenum target )
05317 {
05318 #if defined( GL_CACHING )
05319   GLContext * ctx = glContext();
05320   NVSG_ASSERT(    ( target == GL_TEXTURE_GEN_S )
05321               ||  ( target == GL_TEXTURE_GEN_T )
05322               ||  ( target == GL_TEXTURE_GEN_R )
05323               ||  ( target == GL_TEXTURE_GEN_Q ) );
05324   if ( ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_gen[target-GL_TEXTURE_GEN_S] )
05325   {
05326     _GLUpdateActiveTexture();
05327     NVSG_ASSERT( glIsEnabled( target ) );
05328 #endif
05329     _GLDisable( target );
05330 #if defined( GL_CACHING )
05331     ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_active].m_gen[target-GL_TEXTURE_GEN_S] = GL_FALSE;
05332   }
05333 #endif
05334 }
05335
05337
05338 inline  void  GLDisable( GLenum cap )
05339 {
05340 #if defined( GL_CACHING )
05341   switch( cap )
05342   {
05343     case GL_ALPHA_TEST :
05344       GLDisableAlphaTest();
05345       break;
05346     case GL_AUTO_NORMAL :
05347       GLDisableAutoNormal();
05348       break;
05349     case GL_BLEND :
05350       GLDisableBlend();
05351       break;
05352     case GL_CLIP_PLANE0 :
05353     case GL_CLIP_PLANE1 :
05354     case GL_CLIP_PLANE2 :
05355     case GL_CLIP_PLANE3 :
05356     case GL_CLIP_PLANE4 :
05357     case GL_CLIP_PLANE5 :
05358       GLDisableClipPlane( cap );
05359       break;
05360     case GL_COLOR_LOGIC_OP :
05361       GLDisableColorLogicOp();
05362       break;
05363     case GL_COLOR_MATERIAL :
05364       GLDisableColorMaterial();
05365       break;
05366     case GL_CULL_FACE :
05367       GLDisableCullFace();
05368       break;
05369     case GL_DEPTH_TEST :
05370       GLDisableDepthTest();
05371       break;
05372     case GL_DITHER :
05373       GLDisableDither();
05374       break;
05375     case GL_FOG :
05376       GLDisableFog();
05377       break;
05378     case GL_LIGHT0 :
05379     case GL_LIGHT1 :
05380     case GL_LIGHT2 :
05381     case GL_LIGHT3 :
05382     case GL_LIGHT4 :
05383     case GL_LIGHT5 :
05384     case GL_LIGHT6 :
05385     case GL_LIGHT7 :
05386       GLDisableLight( cap );
05387       break;
05388     case GL_LIGHTING :
05389       GLDisableLighting();
05390       break;
05391     case GL_LINE_SMOOTH :
05392       GLDisableLineSmooth();
05393       break;
05394     case GL_LINE_STIPPLE :
05395       GLDisableLineStipple();
05396       break;
05397     case GL_LOGIC_OP :
05398       GLDisableLogicOp();
05399       break;
05400     case GL_NORMALIZE :
05401       GLDisableNormalize();
05402       break;
05403     case GL_POINT_SMOOTH :
05404       GLDisablePointSmooth();
05405       break;
05406     case GL_POLYGON_OFFSET_FILL :
05407       GLDisablePolygonOffsetFill();
05408       break;
05409     case GL_POLYGON_OFFSET_LINE :
05410       GLDisablePolygonOffsetLine();
05411       break;
05412     case GL_POLYGON_OFFSET_POINT :
05413       GLDisablePolygonOffsetPoint();
05414       break;
05415     case GL_POLYGON_SMOOTH :
05416       GLDisablePolygonSmooth();
05417       break;
05418     case GL_POLYGON_STIPPLE :
05419       GLDisablePolygonStipple();
05420       break;
05421     case GL_SCISSOR_TEST :
05422       GLDisableScissorTest();
05423       break;
05424     case GL_STENCIL_TEST :
05425       GLDisableStencilTest();
05426       break;
05427     case GL_TEXTURE_1D :
05428     case GL_TEXTURE_2D :
05429     case GL_TEXTURE_3D :
05430     case GL_TEXTURE_CUBE_MAP :
05431     case GL_TEXTURE_RECTANGLE_NV :
05432     case GL_TEXTURE_2D_ARRAY_EXT:
05433     case GL_TEXTURE_1D_ARRAY_EXT:
05434       GLDisableTexture( cap );
05435       break;
05436     case GL_TEXTURE_GEN_S :
05437     case GL_TEXTURE_GEN_T :
05438     case GL_TEXTURE_GEN_R :
05439     case GL_TEXTURE_GEN_Q :
05440       GLDisableTextureGen( cap );
05441       break;
05442     default :
05443       _GLDisable( cap );
05444       break;
05445   }
05446 #else
05447   switch( cap )
05448   {
05449     case GL_CULL_FACE :
05450       GLDisableCullFace();
05451       break;
05452     default :
05453       _GLEnable( cap );
05454       break;
05455   }
05456 #endif
05457 }
05458
05459 #if !defined(DOXYGEN_IGNORE)
05460 #if defined( GL_CACHING )
05461 inline void _GLDisableClientStateCached( GLenum cap, GLboolean * cache )
05462 {
05463   if ( *cache )
05464   {
05465     NVSG_ASSERT( glIsEnabled( cap ) );
05466     _GLDisableClientState( cap );
05467     *cache = GL_FALSE;
05468   }
05469 }
05470 #define GL_DISABLE_CLIENT_STATE( cap, cache )   _GLDisableClientStateCached( cap, cache )
05471 #else
05472 #define GL_DISABLE_CLIENT_STATE( cap, cache )   _GLDisableClientState( cap );
05473 #endif
05474 #endif // DOXYGEN_IGNORE
05475
05477
05479 inline  void  GLDisableColorArray( void )
05480 {
05481   GL_DISABLE_CLIENT_STATE( GL_COLOR_ARRAY, &glContext()->m_vertexArrayAttributes.m_colorArray );
05482 }
05483
05485
05487 inline  void  GLDisableFogCoordinateArray( void )
05488 {
05489   GL_DISABLE_CLIENT_STATE( GL_FOG_COORDINATE_ARRAY, &glContext()->m_vertexArrayAttributes.m_fogCoordArray );
05490 }
05491
05493
05495 inline  void  GLDisableNormalArray( void )
05496 {
05497   GL_DISABLE_CLIENT_STATE( GL_NORMAL_ARRAY, &glContext()->m_vertexArrayAttributes.m_normalArray );
05498 }
05499
05501
05503 inline  void  GLDisableSecondaryColorArray( void )
05504 {
05505   GL_DISABLE_CLIENT_STATE( GL_SECONDARY_COLOR_ARRAY, &glContext()->m_vertexArrayAttributes.m_secondaryColorArray );
05506 }
05507
05509
05511 inline  void  GLDisableTextureCoordArray( void )
05512 {
05513 #if defined( GL_CACHING )
05514   GLContext * ctx = glContext();
05515   if ( ctx->m_vertexArrayAttributes.m_textureCoordArray[ctx->m_vertexArrayAttributes.m_clientTextureToActivate] )
05516   {
05517     _GLUpdateClientActiveTexture();
05518     NVSG_ASSERT( glIsEnabled( GL_TEXTURE_COORD_ARRAY ) );
05519 #endif
05520     _GLDisableClientState( GL_TEXTURE_COORD_ARRAY );
05521 #if defined( GL_CACHING )
05522     ctx->m_vertexArrayAttributes.m_textureCoordArray[ctx->m_vertexArrayAttributes.m_clientTextureActive] = GL_FALSE;
05523   }
05524 #endif
05525 }
05526
05528
05530 inline  void  GLDisableVertexArray( void )
05531 {
05532   GL_DISABLE_CLIENT_STATE( GL_VERTEX_ARRAY, &glContext()->m_vertexArrayAttributes.m_vertexArray );
05533 }
05534
05536
05537 inline  void  GLDisableClientState( GLenum array )
05538 {
05539 #if defined( GL_CACHING )
05540   switch( array )
05541   {
05542     case GL_COLOR_ARRAY :
05543       GLDisableColorArray();
05544       break;
05545     case GL_FOG_COORDINATE_ARRAY :
05546       GLDisableFogCoordinateArray();
05547       break;
05548     case GL_NORMAL_ARRAY :
05549       GLDisableNormalArray();
05550       break;
05551     case GL_SECONDARY_COLOR_ARRAY :
05552       GLDisableSecondaryColorArray();
05553       break;
05554     case GL_TEXTURE_COORD_ARRAY :
05555       GLDisableTextureCoordArray();
05556       break;
05557     case GL_VERTEX_ARRAY :
05558       GLDisableVertexArray();
05559       break;
05560     default :
05561       _GLDisableClientState( array );
05562       break;
05563   }
05564 #else
05565   _GLDisableClientState( array );
05566 #endif
05567 }
05568
05570 inline void GLDisableVertexAttribArray( GLuint index )
05571 {
05572   NVSG_GL_STATS_FCT_COUNT();
05573   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDisableVertexAttribArray );
05574   GLContext * ctx = glContext();
05575 #if defined(GL_CACHING)
05576   NVSG_ASSERT(index<(GLuint)ctx->m_maxVertexAttribs);
05577   if ( ctx->m_vertexArrayAttributes.m_vertexAttribArray[index] != GL_FALSE )
05578 #endif
05579   {
05580     ctx->m_glFunctions->glDisableVertexAttribArray(index);
05581 #if defined(GL_CACHING)
05582     ctx->m_vertexArrayAttributes.m_vertexAttribArray[index] = GL_FALSE;
05583 #endif
05584     ASSERT_GL_NO_ERROR;
05585   }
05586 }
05587
05589
05590 inline  void  GLDrawArrays( GLenum mode, GLint first, GLsizei count )
05591 {
05592   NVSG_GL_STATS_FCT_COUNT();
05593   glDrawArrays( mode, first, count );
05594   ASSERT_GL_NO_ERROR;
05595 }
05596
05598
05599 inline  void  GLDrawArraysInstanced( GLenum mode, GLint start, GLsizei count, GLsizei primcount )
05600 {
05601   NVSG_GL_STATS_FCT_COUNT();
05602   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDrawArraysInstanced );
05603   glContext()->m_glFunctions->glDrawArraysInstanced( mode, start, count, primcount );
05604   ASSERT_GL_NO_ERROR;
05605 }
05606
05608
05609 inline  void  GLDrawBuffer( GLenum mode )
05610 {
05611   NVSG_GL_STATS_FCT_COUNT();
05612   glDrawBuffer( mode );
05613   ASSERT_GL_NO_ERROR;
05614 }
05615
05617
05618 inline  void  GLDrawBuffers( GLsizei n, const GLenum *bufs )
05619 {
05620   NVSG_GL_STATS_FCT_COUNT();
05621   ASSERT_GL_ARRAY_BUFFER_BINDING();
05622   ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
05623   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDrawBuffers );
05624   glContext()->m_glFunctions->glDrawBuffers( n, bufs );
05625   ASSERT_GL_NO_ERROR;
05626 }
05627
05629
05630 inline  void  GLDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
05631 {
05632   NVSG_GL_STATS_DRAW_ELEMENTS( mode, count, type, indices );
05633   ASSERT_GL_ARRAY_BUFFER_BINDING();
05634   ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
05635   glDrawElements( mode, count, type, indices );
05636   ASSERT_GL_NO_ERROR;
05637 }
05638
05640
05641 inline  void  GLDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount )
05642 {
05643   NVSG_GL_STATS_FCT_COUNT();
05644   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDrawElementsInstanced );
05645   glContext()->m_glFunctions->glDrawElementsInstanced( mode, count, type, indices, primcount );
05646   ASSERT_GL_NO_ERROR;
05647 }
05648
05650
05651 inline  void  GLMultiDrawArrays( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount )
05652 {
05653   NVSG_GL_STATS_FCT_COUNT();
05654   ASSERT_GL_ARRAY_BUFFER_BINDING();
05655   ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
05656   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiDrawArrays );
05657   glContext()->m_glFunctions->glMultiDrawArrays( mode, first, count, primcount );
05658   ASSERT_GL_NO_ERROR;
05659 }
05660
05662
05663 inline  void  GLMultiDrawElements( GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount )
05664 {
05665   NVSG_GL_STATS_FCT_COUNT();
05666   ASSERT_GL_ARRAY_BUFFER_BINDING();
05667   ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
05668   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiDrawElements );
05669   glContext()->m_glFunctions->glMultiDrawElements( mode, count, type, indices, primcount );
05670   ASSERT_GL_NO_ERROR;
05671 }
05672
05674
05675 inline  void  GLDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
05676 {
05677   NVSG_GL_STATS_FCT_COUNT();
05678   glDrawPixels( width, height, format, type, pixels );
05679   ASSERT_GL_NO_ERROR;
05680 }
05681
05683
05684 inline  void  GLDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices )
05685 {
05686   NVSG_GL_STATS_DRAW_RANGE_ELEMENTS( mode, start, end, count, type, indices );
05687   ASSERT_GL_ARRAY_BUFFER_BINDING();
05688   ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
05689   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glDrawRangeElements );
05690   glContext()->m_glFunctions->glDrawRangeElements( mode, start, end, count, type, indices );
05691   ASSERT_GL_NO_ERROR;
05692 }
05693
05695
05696 inline  void  GLEdgeFlagPointer( GLsizei stride, const GLboolean *pointer )
05697 {
05698   NVSG_GL_STATS_FCT_COUNT();
05699   glEdgeFlagPointer( stride, pointer );
05700   ASSERT_GL_NO_ERROR;
05701 }
05702
05704
05705 inline  void  GLEdgeFlag( GLboolean flag )
05706 {
05707   NVSG_GL_STATS_FCT_COUNT();
05708   glEdgeFlag( flag );
05709   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05710 }
05711
05713
05714 inline  void  GLEdgeFlagv( const GLboolean *flag )
05715 {
05716   NVSG_GL_STATS_FCT_COUNT();
05717   glEdgeFlagv( flag );
05718   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05719 }
05720
05722
05724 inline  void  GLEnableAlphaTest( void )
05725 {
05726   GL_ENABLE( GL_ALPHA_TEST, &glContext()->m_colorBufferEnableAttributes.m_alphaTest
05727            , &glContext()->m_previousAttributes.m_alphaTest );
05728 }
05729
05734 inline void GLResetAlphaTest()
05735 {
05736   GL_RESET( GL_ALPHA_TEST, &glContext()->m_colorBufferEnableAttributes.m_alphaTest
05737           , glContext()->m_previousAttributes.m_alphaTest );
05738 }
05739
05741
05743 inline  void  GLEnableAutoNormal( void )
05744 {
05745   GL_ENABLE( GL_AUTO_NORMAL, &glContext()->m_evalAttributes.m_autoNormal
05746            , &glContext()->m_previousAttributes.m_autoNormal );
05747 }
05748
05753 inline void GLResetAutoNormal()
05754 {
05755   GL_RESET( GL_AUTO_NORMAL, &glContext()->m_evalAttributes.m_autoNormal
05756           , glContext()->m_previousAttributes.m_autoNormal );
05757 }
05758
05760
05762 inline  void  GLEnableBlend( void )
05763 {
05764   GL_ENABLE( GL_BLEND, &glContext()->m_colorBufferEnableAttributes.m_blend
05765            , &glContext()->m_previousAttributes.m_blend );
05766 }
05767
05772 inline void GLResetBlend()
05773 {
05774   GL_RESET( GL_BLEND, &glContext()->m_colorBufferEnableAttributes.m_blend
05775           , glContext()->m_previousAttributes.m_blend );
05776 }
05777
05779
05781 inline  void  GLEnableClipPlane( GLenum plane )
05782 {
05783 #if defined( GL_CACHING )
05784   NVSG_ASSERT( plane-GL_CLIP_PLANE0 < glContext()->m_transformEnableAttributes.m_clipPlanes.size() );
05785 #endif
05786   GL_ENABLE( plane, &glContext()->m_transformEnableAttributes.m_clipPlanes[plane-GL_CLIP_PLANE0]
05787            , &glContext()->m_previousAttributes.m_clipPlanes[plane-GL_CLIP_PLANE0] );
05788 }
05789
05795 inline void GLResetClipPlane( GLenum plane )
05796 {
05797   GL_RESET( plane, &glContext()->m_transformEnableAttributes.m_clipPlanes[plane-GL_CLIP_PLANE0]
05798           , glContext()->m_previousAttributes.m_clipPlanes[plane-GL_CLIP_PLANE0] );
05799 }
05800
05802
05804 inline  void  GLEnableColorLogicOp( void )
05805 {
05806   GL_ENABLE( GL_COLOR_LOGIC_OP, &glContext()->m_colorBufferEnableAttributes.m_colorLogicOp
05807            , &glContext()->m_previousAttributes.m_colorLogicOp );
05808 }
05809
05814 inline void GLResetColorLogicOp()
05815 {
05816   GL_RESET( GL_COLOR_LOGIC_OP, &glContext()->m_colorBufferEnableAttributes.m_colorLogicOp
05817           , glContext()->m_previousAttributes.m_colorLogicOp );
05818 }
05819
05821
05823 inline  void  GLEnableColorMaterial( void )
05824 {
05825   GL_ENABLE( GL_COLOR_MATERIAL, &glContext()->m_lightingAttributes.m_colorMaterial
05826            , &glContext()->m_previousAttributes.m_colorMaterial );
05827 }
05828
05833 inline  void  GLResetColorMaterial()
05834 {
05835   GL_RESET( GL_COLOR_MATERIAL, &glContext()->m_lightingAttributes.m_colorMaterial
05836           , glContext()->m_previousAttributes.m_colorMaterial );
05837 }
05838
05840
05842 inline  void  GLEnableCullFace( void )
05843 {
05844   GLContext * ctx = glContext();
05845 #if defined( GL_CACHING )
05846 # if defined(GL_SUPPORT_RESET)
05847   ctx->m_previousAttributes.m_cullFace = ctx->m_polygonEnableAttributes.m_cullFace;
05848 # endif
05849   if ( ! ctx->m_polygonEnableAttributes.m_cullFace )
05850 #endif
05851   {
05852     if ( ! ctx->m_locks.m_cullFace )
05853     {
05854 #if defined( GL_CACHING )
05855       NVSG_ASSERT( ! glIsEnabled( GL_CULL_FACE ) );
05856 #endif
05857       _GLEnable( GL_CULL_FACE );
05858 #if defined( GL_CACHING )
05859       ctx->m_polygonEnableAttributes.m_cullFace = GL_TRUE;
05860 #endif
05861     }
05862   }
05863 }
05864
05870 inline void GLResetCullFace()
05871 {
05872 #if defined(GL_SUPPORT_RESET)
05873   glContext()->m_previousAttributes.m_cullFace ? GLEnableCullFace() : GLDisableCullFace();
05874 #else
05875   GLEnableCullFace(); // NVSG specific! Not OpenGL default!
05876 #endif
05877 }
05878
05884 inline void GLEnableCullFaceLock( void )
05885 {
05886   NVSG_ASSERT( ! glContext()->m_locks.m_cullFace );
05887   GLEnableCullFace();
05888   glContext()->m_locks.m_cullFace = true;
05889 }
05890
05894 inline void GLEnableCullFaceUnlock( void )
05895 {
05896   NVSG_ASSERT( glContext()->m_locks.m_cullFace );
05897   glContext()->m_locks.m_cullFace = false;
05898   GLEnableCullFace();
05899 }
05900
05902
05904 inline  void  GLEnableDepthTest( void )
05905 {
05906   GL_ENABLE( GL_DEPTH_TEST, &glContext()->m_depthBufferEnableAttributes.m_depthTesting
05907            , &glContext()->m_previousAttributes.m_depthTesting );
05908 }
05909
05915 inline void GLResetDepthTest()
05916 {
05917 #if defined(GL_SUPPORT_RESET)
05918   glContext()->m_previousAttributes.m_depthTesting ? GLEnableDepthTest() : GLDisableDepthTest();
05919 #else
05920   GLEnableDepthTest();  // NVSG specific! Not OpenGL default!
05921 #endif
05922 }
05923
05925
05927 inline  void  GLEnableDither( void )
05928 {
05929   GL_ENABLE( GL_DITHER, &glContext()->m_colorBufferEnableAttributes.m_dither
05930            , &glContext()->m_previousAttributes.m_dither );
05931 }
05932
05937 inline void GLResetDither()
05938 {
05939   GL_RESET( GL_DITHER, &glContext()->m_colorBufferEnableAttributes.m_dither
05940           , glContext()->m_previousAttributes.m_dither );
05941 }
05942
05944
05946 inline  void  GLEnableFog( void )
05947 {
05948   GL_ENABLE( GL_FOG, &glContext()->m_fogEnableAttributes.m_fog
05949            , &glContext()->m_previousAttributes.m_fog );
05950 }
05951
05956 inline void GLResetFog()
05957 {
05958   GL_RESET( GL_FOG, &glContext()->m_fogEnableAttributes.m_fog
05959           , glContext()->m_previousAttributes.m_fog );
05960 }
05961
05963
05964 inline  void  GLEnableIndexed( GLenum target, GLuint index )
05965 {
05966   NVSG_GL_STATS_FCT_COUNT();
05967   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glEnableIndexed );
05968   glContext()->m_glFunctions->glEnableIndexed( target, index );
05969   ASSERT_GL_NO_ERROR;
05970 }
05971
05973
05975 inline  void  GLEnableLight( GLenum light )
05976 {
05977 #if defined( GL_CACHING )
05978   NVSG_ASSERT( light-GL_LIGHT0 < glContext()->m_lightingEnableAttributes.m_lights.size() );
05979 #endif
05980   GL_ENABLE( light, &glContext()->m_lightingEnableAttributes.m_lights[light-GL_LIGHT0]
05981            , &glContext()->m_previousAttributes.m_lights[light-GL_LIGHT0] );
05982 }
05983
05989 inline void GLResetLight( GLenum light )
05990 {
05991   GL_RESET( light, &glContext()->m_lightingEnableAttributes.m_lights[light-GL_LIGHT0]
05992           , glContext()->m_previousAttributes.m_lights[light-GL_LIGHT0] );
05993 }
05994
05996
05998 inline  void  GLEnableLighting( void )
05999 {
06000   GLContext * ctx = glContext();
06001 #if defined( GL_CACHING )
06002 # if defined(GL_SUPPORT_RESET)
06003   ctx->m_previousAttributes.m_lighting = ctx->m_lightingEnableAttributes.m_lighting;
06004 # endif
06005   if ( ! ctx->m_lightingEnableAttributes.m_lighting )
06006 #endif
06007   {
06008     if ( ! ctx->m_locks.m_lighting )
06009     {
06010 #if defined( GL_CACHING )
06011       NVSG_ASSERT( ! glIsEnabled( GL_LIGHTING ) );
06012 #endif
06013       _GLEnable( GL_LIGHTING );
06014 #if defined( GL_CACHING )
06015       ctx->m_lightingEnableAttributes.m_lighting = GL_TRUE;
06016 #endif
06017     }
06018   }
06019 }
06020
06025 inline void GLResetLighting()
06026 {
06027   GL_RESET( GL_LIGHTING, &glContext()->m_lightingEnableAttributes.m_lighting
06028           , glContext()->m_previousAttributes.m_lighting );
06029 }
06030
06032
06034 inline  void  GLEnableLineSmooth( void )
06035 {
06036   GL_ENABLE( GL_LINE_SMOOTH, &glContext()->m_lineEnableAttributes.m_smooth
06037            , &glContext()->m_previousAttributes.m_lineSmooth );
06038 }
06039
06044 inline void GLResetLineSmooth()
06045 {
06046   GL_RESET( GL_LINE_SMOOTH, &glContext()->m_lineEnableAttributes.m_smooth
06047           , glContext()->m_previousAttributes.m_lineSmooth );
06048 }
06049
06051
06053 inline  void  GLEnableLineStipple( void )
06054 {
06055   GL_ENABLE( GL_LINE_STIPPLE, &glContext()->m_lineEnableAttributes.m_stipple
06056            , &glContext()->m_previousAttributes.m_lineStipple );
06057 }
06058
06063 inline void GLResetLineStipple()
06064 {
06065   GL_RESET( GL_LINE_STIPPLE, &glContext()->m_lineEnableAttributes.m_stipple
06066           , glContext()->m_previousAttributes.m_lineStipple );
06067 }
06068
06070
06072 inline  void  GLEnableLogicOp( void )
06073 {
06074   GL_ENABLE( GL_LOGIC_OP, &glContext()->m_colorBufferEnableAttributes.m_logicOp
06075            , &glContext()->m_previousAttributes.m_logicOp );
06076 }
06077
06082 inline void GLResetLogicOp()
06083 {
06084   GL_RESET( GL_LOGIC_OP, &glContext()->m_colorBufferEnableAttributes.m_logicOp
06085           , glContext()->m_previousAttributes.m_logicOp );
06086 }
06087
06089
06091 inline  void  GLEnableNormalize( void )
06092 {
06093   GL_ENABLE( GL_NORMALIZE, &glContext()->m_transformEnableAttributes.m_normalize
06094            , &glContext()->m_previousAttributes.m_normalize );
06095 }
06096
06101 inline void GLResetNormalize()
06102 {
06103   GL_RESET( GL_NORMALIZE, &glContext()->m_transformEnableAttributes.m_normalize
06104           , glContext()->m_previousAttributes.m_normalize );
06105 }
06106
06108
06110 inline  void  GLEnablePointSmooth( void )
06111 {
06112   GL_ENABLE( GL_POINT_SMOOTH, &glContext()->m_pointEnableAttributes.m_smooth
06113            , &glContext()->m_previousAttributes.m_pointSmooth );
06114 }
06115
06120 inline void GLResetPointSmooth()
06121 {
06122   GL_RESET( GL_POINT_SMOOTH, &glContext()->m_pointEnableAttributes.m_smooth
06123           , glContext()->m_previousAttributes.m_pointSmooth );
06124 }
06125
06127
06129 inline  void  GLEnablePolygonOffsetFill( void )
06130 {
06131   GL_ENABLE( GL_POLYGON_OFFSET_FILL, &glContext()->m_polygonEnableAttributes.m_offsetFill
06132            , &glContext()->m_previousAttributes.m_offsetFill );
06133 }
06134
06139 inline void GLResetPolygonOffsetFill()
06140 {
06141   GL_RESET( GL_POLYGON_OFFSET_FILL, &glContext()->m_polygonEnableAttributes.m_offsetFill
06142           , glContext()->m_previousAttributes.m_offsetFill );
06143 }
06144
06146
06148 inline  void  GLEnablePolygonOffsetLine( void )
06149 {
06150   GL_ENABLE( GL_POLYGON_OFFSET_LINE, &glContext()->m_polygonEnableAttributes.m_offsetLine
06151            , &glContext()->m_previousAttributes.m_offsetLine );
06152 }
06153
06158 inline void GLResetPolygonOffsetLine()
06159 {
06160   GL_RESET( GL_POLYGON_OFFSET_LINE, &glContext()->m_polygonEnableAttributes.m_offsetLine
06161           , glContext()->m_previousAttributes.m_offsetLine );
06162 }
06163
06165
06167 inline  void  GLEnablePolygonOffsetPoint( void )
06168 {
06169   GL_ENABLE( GL_POLYGON_OFFSET_POINT, &glContext()->m_polygonEnableAttributes.m_offsetPoint
06170            , &glContext()->m_previousAttributes.m_offsetPoint );
06171 }
06172
06177 inline void GLResetPolygonOffsetPoint()
06178 {
06179   GL_RESET( GL_POLYGON_OFFSET_POINT, &glContext()->m_polygonEnableAttributes.m_offsetPoint
06180           , glContext()->m_previousAttributes.m_offsetPoint );
06181 }
06182
06184
06186 inline  void  GLEnablePolygonSmooth( void )
06187 {
06188   GL_ENABLE( GL_POLYGON_SMOOTH, &glContext()->m_polygonEnableAttributes.m_smooth
06189            , &glContext()->m_previousAttributes.m_polygonSmooth );
06190 }
06191
06196 inline  void  GLResetPolygonSmooth()
06197 {
06198   GL_RESET( GL_POLYGON_SMOOTH, &glContext()->m_polygonEnableAttributes.m_smooth
06199           , glContext()->m_previousAttributes.m_polygonSmooth );
06200 }
06201
06203
06205 inline  void  GLEnablePolygonStipple( void )
06206 {
06207   GL_ENABLE( GL_POLYGON_STIPPLE, &glContext()->m_polygonEnableAttributes.m_stipple
06208            , &glContext()->m_previousAttributes.m_polygonStipple );
06209 }
06210
06215 inline  void  GLResetPolygonStipple()
06216 {
06217   GL_RESET( GL_POLYGON_STIPPLE, &glContext()->m_polygonEnableAttributes.m_stipple
06218           , glContext()->m_previousAttributes.m_polygonStipple );
06219 }
06220
06222
06224 inline  void  GLEnableScissorTest( void )
06225 {
06226   GL_ENABLE( GL_SCISSOR_TEST, &glContext()->m_scissorEnableAttributes.m_scissorTest
06227            , &glContext()->m_previousAttributes.m_scissorTest );
06228 }
06229
06234 inline  void  GLResetScissorTest()
06235 {
06236   GL_RESET( GL_SCISSOR_TEST, &glContext()->m_scissorEnableAttributes.m_scissorTest
06237           , glContext()->m_previousAttributes.m_scissorTest );
06238 }
06239
06241
06243 inline  void  GLEnableStencilTest( void )
06244 {
06245   GL_ENABLE( GL_STENCIL_TEST, &glContext()->m_stencilBufferEnableAttributes.m_stencilTest
06246            , &glContext()->m_previousAttributes.m_stencilTest );
06247 }
06248
06253 inline  void  GLResetStencilTest()
06254 {
06255   GL_RESET( GL_STENCIL_TEST, &glContext()->m_stencilBufferEnableAttributes.m_stencilTest
06256           , glContext()->m_previousAttributes.m_stencilTest );
06257 }
06258
06261
06263 inline void GLEnableTexture( GLenum target )
06264 {
06265 #if defined( GL_CACHING )
06266   GLContext * ctx = glContext();
06267 # if defined(GL_SUPPORT_RESET)
06268   // MMM - should there be a statement here??
06269   ctx->m_previousAttributes.m_textureEnables[ctx->m_textureAttributes.m_toActivate].m_texture[target];
06270 # endif
06271   NVSG_ASSERT(   ( target == GL_TEXTURE_1D ) || ( target == GL_TEXTURE_2D ) || ( target == GL_TEXTURE_3D )
06272              ||  ( target == GL_TEXTURE_CUBE_MAP ) || ( target == GL_TEXTURE_RECTANGLE_NV )
06273              ||  ( target == GL_TEXTURE_2D_ARRAY_EXT ) || ( target == GL_TEXTURE_1D_ARRAY_EXT ) );
06274   if ( !ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_texture[target] )
06275   {
06276     _GLUpdateActiveTexture();
06277
06278     // Texture ARRAY targets are not supported by the fixed function pipeline,
06279     // and therefore can not be 'ENABLED' in the Gl sense of the term, as it will
06280     // produce an error.
06281     if( target != GL_TEXTURE_2D_ARRAY_EXT && target != GL_TEXTURE_1D_ARRAY_EXT )
06282     {
06283       NVSG_ASSERT( ! glIsEnabled( target ) );
06284     }
06285 #endif
06286     if( target != GL_TEXTURE_2D_ARRAY_EXT && target != GL_TEXTURE_1D_ARRAY_EXT )
06287     {
06288       _GLEnable( target );
06289     }
06290 #if defined( GL_CACHING )
06291     ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_active].m_texture[target] = GL_TRUE;
06292   }
06293 #endif
06294 }
06295
06301 inline void GLResetTexture( GLenum target )
06302 {
06303 #if defined(GL_SUPPORT_RESET)
06304   GLContext * ctx = glContext();
06305   GLDisableTexture( ctx->m_previousAttributes.m_textureEnables[ctx->m_textureAttributes.m_toActivate].m_texture[target] );
06306 #else
06307   GLDisableTexture( target );
06308 #endif
06309 }
06310
06312
06314 inline void GLEnableTextureGen( GLenum target )
06315 {
06316 #if defined( GL_CACHING )
06317   GLContext * ctx = glContext();
06318   NVSG_ASSERT(    ( target == GL_TEXTURE_GEN_S )
06319               ||  ( target == GL_TEXTURE_GEN_T )
06320               ||  ( target == GL_TEXTURE_GEN_R )
06321               ||  ( target == GL_TEXTURE_GEN_Q ) );
06322   if ( ! ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_gen[target-GL_TEXTURE_GEN_S] )
06323   {
06324     _GLUpdateActiveTexture();
06325     NVSG_ASSERT( ! glIsEnabled( target ) );
06326 #endif
06327     _GLEnable( target );
06328 #if defined( GL_CACHING )
06329     ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_active].m_gen[target-GL_TEXTURE_GEN_S] = GL_TRUE;
06330   }
06331 #endif
06332 }
06333
06335
06336 inline  void  GLEnable( GLenum cap )
06337 {
06338 #if defined( GL_CACHING )
06339   switch( cap )
06340   {
06341     case GL_ALPHA_TEST :
06342       GLEnableAlphaTest();
06343       break;
06344     case GL_AUTO_NORMAL :
06345       GLEnableAutoNormal();
06346       break;
06347     case GL_BLEND :
06348       GLEnableBlend();
06349       break;
06350     case GL_CLIP_PLANE0 :
06351     case GL_CLIP_PLANE1 :
06352     case GL_CLIP_PLANE2 :
06353     case GL_CLIP_PLANE3 :
06354     case GL_CLIP_PLANE4 :
06355     case GL_CLIP_PLANE5 :
06356       GLEnableClipPlane( cap );
06357       break;
06358     case GL_COLOR_LOGIC_OP :
06359       GLEnableColorLogicOp();
06360       break;
06361     case GL_COLOR_MATERIAL :
06362       GLEnableColorMaterial();
06363       break;
06364     case GL_CULL_FACE :
06365       GLEnableCullFace();
06366       break;
06367     case GL_DEPTH_TEST :
06368       GLEnableDepthTest();
06369       break;
06370     case GL_DITHER :
06371       GLEnableDither();
06372       break;
06373     case GL_FOG :
06374       GLEnableFog();
06375       break;
06376     case GL_LIGHT0 :
06377     case GL_LIGHT1 :
06378     case GL_LIGHT2 :
06379     case GL_LIGHT3 :
06380     case GL_LIGHT4 :
06381     case GL_LIGHT5 :
06382     case GL_LIGHT6 :
06383     case GL_LIGHT7 :
06384       GLEnableLight( cap );
06385       break;
06386     case GL_LIGHTING :
06387       GLEnableLighting();
06388       break;
06389     case GL_LINE_SMOOTH :
06390       GLEnableLineSmooth();
06391       break;
06392     case GL_LINE_STIPPLE :
06393       GLEnableLineStipple();
06394       break;
06395     case GL_LOGIC_OP :
06396       GLEnableLogicOp();
06397       break;
06398     case GL_NORMALIZE :
06399       GLEnableNormalize();
06400       break;
06401     case GL_POINT_SMOOTH :
06402       GLEnablePointSmooth();
06403       break;
06404     case GL_POLYGON_OFFSET_FILL :
06405       GLEnablePolygonOffsetFill();
06406       break;
06407     case GL_POLYGON_OFFSET_LINE :
06408       GLEnablePolygonOffsetLine();
06409       break;
06410     case GL_POLYGON_OFFSET_POINT :
06411       GLEnablePolygonOffsetPoint();
06412       break;
06413     case GL_POLYGON_SMOOTH :
06414       GLEnablePolygonSmooth();
06415       break;
06416     case GL_POLYGON_STIPPLE :
06417       GLEnablePolygonStipple();
06418       break;
06419     case GL_SCISSOR_TEST :
06420       GLEnableScissorTest();
06421       break;
06422     case GL_STENCIL_TEST :
06423       GLEnableStencilTest();
06424       break;
06425     case GL_TEXTURE_1D :
06426     case GL_TEXTURE_2D :
06427     case GL_TEXTURE_3D :
06428     case GL_TEXTURE_CUBE_MAP :
06429     case GL_TEXTURE_RECTANGLE_NV :
06430     case GL_TEXTURE_2D_ARRAY_EXT:
06431     case GL_TEXTURE_1D_ARRAY_EXT:
06432       GLEnableTexture( cap );
06433       break;
06434     case GL_TEXTURE_GEN_S :
06435     case GL_TEXTURE_GEN_T :
06436     case GL_TEXTURE_GEN_R :
06437     case GL_TEXTURE_GEN_Q :
06438       GLEnableTextureGen( cap );
06439       break;
06440     default :
06441       _GLEnable( cap );
06442       break;
06443   }
06444 #else
06445   switch( cap )
06446   {
06447     case GL_CULL_FACE :
06448       GLEnableCullFace();
06449       break;
06450     default :
06451       _GLEnable( cap );
06452       break;
06453   }
06454 #endif
06455 }
06456
06457 #if !defined(DOXYGEN_IGNORE)
06458 #if defined( GL_CACHING )
06459 inline void _GLEnableClientStateCached( GLenum cap, GLboolean * cache )
06460 {
06461   if ( !*cache )
06462   {
06463     NVSG_ASSERT( !glIsEnabled( cap ) );
06464     _GLEnableClientState( cap );
06465     *cache = GL_TRUE;
06466   }
06467 }
06468 #define GL_ENABLE_CLIENT_STATE( cap, cache )  _GLEnableClientStateCached( cap, cache )
06469 #else
06470 #define GL_ENABLE_CLIENT_STATE( cap, cache )  _GLEnableClientState( cap );
06471 #endif
06472 #endif // DOXYGEN_IGNORE
06473
06475
06477 inline  void  GLEnableColorArray( void )
06478 {
06479   GL_ENABLE_CLIENT_STATE( GL_COLOR_ARRAY, &glContext()->m_vertexArrayAttributes.m_colorArray );
06480 }
06481
06483
06485 inline  void  GLEnableFogCoordinateArray( void )
06486 {
06487   GL_ENABLE_CLIENT_STATE( GL_FOG_COORDINATE_ARRAY, &glContext()->m_vertexArrayAttributes.m_fogCoordArray );
06488 }
06489
06491
06493 inline  void  GLEnableNormalArray( void )
06494 {
06495   GL_ENABLE_CLIENT_STATE( GL_NORMAL_ARRAY, &glContext()->m_vertexArrayAttributes.m_normalArray );
06496 }
06497
06499
06501 inline  void  GLEnableSecondaryColorArray( void )
06502 {
06503   GL_ENABLE_CLIENT_STATE( GL_SECONDARY_COLOR_ARRAY, &glContext()->m_vertexArrayAttributes.m_secondaryColorArray );
06504 }
06505
06507
06509 inline  void  GLEnableTextureCoordArray( void )
06510 {
06511 #if defined( GL_CACHING )
06512   GLContext * ctx = glContext();
06513   if ( ! ctx->m_vertexArrayAttributes.m_textureCoordArray[ctx->m_vertexArrayAttributes.m_clientTextureToActivate] )
06514   {
06515     _GLUpdateClientActiveTexture();
06516     NVSG_ASSERT( ! glIsEnabled( GL_TEXTURE_COORD_ARRAY ) );
06517 #endif
06518     _GLEnableClientState( GL_TEXTURE_COORD_ARRAY );
06519 #if defined( GL_CACHING )
06520     ctx->m_vertexArrayAttributes.m_textureCoordArray[ctx->m_vertexArrayAttributes.m_clientTextureActive] = GL_TRUE;
06521   }
06522 #endif
06523 }
06524
06526
06528 inline  void  GLEnableVertexArray( void )
06529 {
06530   GL_ENABLE_CLIENT_STATE( GL_VERTEX_ARRAY, &glContext()->m_vertexArrayAttributes.m_vertexArray );
06531 }
06532
06534
06535 inline  void  GLEnableClientState( GLenum array )
06536 {
06537 #if defined( GL_CACHING )
06538   switch( array )
06539   {
06540     case GL_COLOR_ARRAY :
06541       GLEnableColorArray();
06542       break;
06543     case GL_FOG_COORDINATE_ARRAY :
06544       GLEnableFogCoordinateArray();
06545       break;
06546     case GL_NORMAL_ARRAY :
06547       GLEnableNormalArray();
06548       break;
06549     case GL_SECONDARY_COLOR_ARRAY :
06550       GLEnableSecondaryColorArray();
06551       break;
06552     case GL_TEXTURE_COORD_ARRAY :
06553       GLEnableTextureCoordArray();
06554       break;
06555     case GL_VERTEX_ARRAY :
06556       GLEnableVertexArray();
06557       break;
06558     default :
06559       _GLEnableClientState( array );
06560       break;
06561   }
06562 #else
06563   _GLEnableClientState( array );
06564 #endif
06565 }
06566
06568 inline void GLEnableVertexAttribArray( GLuint index )
06569 {
06570   NVSG_GL_STATS_FCT_COUNT();
06571   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glEnableVertexAttribArray );
06572   GLContext * ctx = glContext();
06573 #if defined(GL_CACHING)
06574   NVSG_ASSERT(index<(GLuint)ctx->m_maxVertexAttribs);
06575   if ( ctx->m_vertexArrayAttributes.m_vertexAttribArray[index] != GL_TRUE )
06576 #endif
06577   {
06578     ctx->m_glFunctions->glEnableVertexAttribArray(index);
06579 #if defined(GL_CACHING)
06580     ctx->m_vertexArrayAttributes.m_vertexAttribArray[index] = GL_TRUE;
06581 #endif
06582     ASSERT_GL_NO_ERROR;
06583   }
06584 }
06585
06587
06588 inline  void  GLEnd( void )
06589 {
06590   NVSG_GL_STATS_FCT_COUNT();
06591   glEnd();
06592 #if !defined(NDEBUG)
06593   glContext()->m_inBeginEndLoop = false;
06594 #endif
06595   ASSERT_GL_NO_ERROR;
06596 }
06597
06599
06600 inline  void  GLEndList( void )
06601 {
06602   NVSG_GL_STATS_END_LIST();
06603   glEndList();
06604   // NOTE: no assertion on GL_NO_ERROR here, because on glEndList the GL_OUT_OF_MEMORY is to be tested!
06605 }
06606
06608
06609 inline  void  GLEndOcclusionQuery( void )
06610 {
06611   NVSG_GL_STATS_FCT_COUNT();
06612   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glEndOcclusionQueryNV );
06613   glContext()->m_glFunctions->glEndOcclusionQueryNV();
06614   ASSERT_GL_NO_ERROR;
06615 }
06616
06618
06619 inline  void  GLEndQuery( GLenum target )
06620 {
06621   NVSG_GL_STATS_FCT_COUNT();
06622   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glEndQuery );
06623   glContext()->m_glFunctions->glEndQuery( target );
06624   ASSERT_GL_NO_ERROR;
06625 }
06626
06628
06629 inline  void  GLEndTransformFeedback()
06630 {
06631   NVSG_GL_STATS_FCT_COUNT();
06632   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glEndTransformFeedbackNV );
06633   glContext()->m_glFunctions->glEndTransformFeedbackNV();
06634   ASSERT_GL_NO_ERROR;
06635 }
06636
06638
06639 inline  void  GLEvalCoord1d( GLdouble u )
06640 {
06641   NVSG_GL_STATS_FCT_COUNT();
06642   glEvalCoord1d( u );
06643   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06644 }
06645
06647
06648 inline  void  GLEvalCoord1f( GLfloat u )
06649 {
06650   NVSG_GL_STATS_FCT_COUNT();
06651   glEvalCoord1f( u );
06652   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06653 }
06654
06656
06657 inline  void  GLEvalCoord2d( GLdouble u, GLdouble v )
06658 {
06659   NVSG_GL_STATS_FCT_COUNT();
06660   glEvalCoord2d( u, v );
06661   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06662 }
06663
06665
06666 inline  void  GLEvalCoord2f( GLfloat u, GLfloat v )
06667 {
06668   NVSG_GL_STATS_FCT_COUNT();
06669   glEvalCoord2f( u, v );
06670   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06671 }
06672
06674
06675 inline  void  GLEvalMesh1( GLenum mode, GLint i1, GLint i2 )
06676 {
06677   NVSG_GL_STATS_FCT_COUNT();
06678   glEvalMesh1( mode, i1, i2 );
06679   ASSERT_GL_NO_ERROR;
06680 }
06681
06683
06684 inline  void  GLEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
06685 {
06686   NVSG_GL_STATS_FCT_COUNT();
06687   glEvalMesh2( mode, i1, i2, j1, j2 );
06688   ASSERT_GL_NO_ERROR;
06689 }
06690
06692
06693 inline  void  GLEvalPoint1( GLint i )
06694 {
06695   NVSG_GL_STATS_FCT_COUNT();
06696   glEvalPoint1( i );
06697   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06698 }
06699
06701
06702 inline  void  GLEvalPoint2( GLint i, GLint j )
06703 {
06704   NVSG_GL_STATS_FCT_COUNT();
06705   glEvalPoint2( i, j );
06706   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06707 }
06708
06710
06711 inline  void  GLExecuteProgram( GLenum target, GLuint id, const GLfloat *params )
06712 {
06713   NVSG_GL_STATS_FCT_COUNT();
06714   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glExecuteProgramNV );
06715   glContext()->m_glFunctions->glExecuteProgramNV( target, id, params );
06716   ASSERT_GL_NO_ERROR;
06717 }
06718
06720
06721 inline  void  GLFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
06722 {
06723   NVSG_GL_STATS_FCT_COUNT();
06724   glFeedbackBuffer( size, type, buffer );
06725   ASSERT_GL_NO_ERROR;
06726 }
06727
06729
06730 inline  void  GLFinalCombinerInput( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage )
06731 {
06732   NVSG_GL_STATS_FCT_COUNT();
06733   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFinalCombinerInput );
06734   glContext()->m_glFunctions->glFinalCombinerInput( variable, input, mapping, componentUsage );
06735   ASSERT_GL_NO_ERROR;
06736 }
06737
06739
06740 inline  void  GLFinish( void )
06741 {
06742   NVSG_GL_STATS_FCT_COUNT();
06743   glFinish();
06744   ASSERT_GL_NO_ERROR;
06745 }
06746
06748 inline  void  GLFinishFence( GLuint fence )
06749 {
06750   NVSG_GL_STATS_FCT_COUNT();
06751   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFinishFence );
06752   glContext()->m_glFunctions->glFinishFence( fence );
06753   ASSERT_GL_NO_ERROR;
06754 }
06755
06757
06758 inline  void  GLFlush( void )
06759 {
06760   NVSG_GL_STATS_FCT_COUNT();
06761   glFlush();
06762   ASSERT_GL_NO_ERROR;
06763 }
06764
06766
06767 inline  void  GLFlushPixelDataRange( GLenum target )
06768 {
06769   NVSG_GL_STATS_FCT_COUNT();
06770   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFlushPixelDataRange );
06771   glContext()->m_glFunctions->glFlushPixelDataRange( target );
06772   ASSERT_GL_NO_ERROR;
06773 }
06774
06776
06777 inline  void  GLFlushVertexArrayRange()
06778 {
06779   NVSG_GL_STATS_FCT_COUNT();
06780   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFlushVertexArrayRange );
06781   glContext()->m_glFunctions->glFlushVertexArrayRange();
06782   ASSERT_GL_NO_ERROR;
06783 }
06784
06785 #if !defined(DOXYGEN_IGNORE)
06786 #if defined( GL_CACHING )
06787 inline void _GLFogfCached( GLenum pname, GLfloat param, GLfloat * cache )
06788 {
06789   if ( param != *cache )
06790   {
06791     _GLFogf( pname, param );
06792     *cache = param;
06793   }
06794 }
06795 inline void _GLFogfvCached( GLenum pname, const GLfloat * params, GLfloat * cache )
06796 {
06797   if ( !equal4fv( params, cache ) )
06798   {
06799     _GLFogfv( pname, params );
06800     memcpy( cache, params, 4*sizeof(GLfloat) );
06801   }
06802 }
06803 inline void _GLFogiCached( GLenum pname, GLint param, GLint * cache )
06804 {
06805   if ( param != *cache )
06806   {
06807     _GLFogi( pname, param );
06808     *cache = param;
06809   }
06810 }
06811 # if defined(GL_SUPPORT_RESET)
06812 inline void _GLFogfCached( GLenum pname, GLfloat param, GLfloat * cache, GLfloat * prev )
06813 {
06814   *prev = *cache;
06815   _GLFogfCached( pname, param, cache );
06816 }
06817 inline void _GLFogfvCached( GLenum pname, const GLfloat * params, GLfloat * cache, GLfloat * prev )
06818 {
06819   memcpy( prev, cache, 4*sizeof(GLfloat) );
06820   _GLFogfvCached( pname, params, cache );
06821 }
06822 inline void _GLFogiCached( GLenum pname, GLint param, GLint * cache, GLint * prev )
06823 {
06824   *prev = *cache;
06825   _GLFogiCached( pname, param, cache );
06826 }
06827 #  define GL_FOG_F( pname, param, cache, prev )   _GLFogfCached( pname, param, cache )
06828 #  define GL_FOG_FV( pname, params, cache, prev ) _GLFogfvCached( pname, params, cache )
06829 #  define GL_FOG_I( pname, param, cache, prev )   _GLFogiCached( pname, param, cache )
06830 # else
06831 #  define GL_FOG_F( pname, param, cache, prev )   _GLFogfCached( pname, param, cache )
06832 #  define GL_FOG_FV( pname, params, cache, prev ) _GLFogfvCached( pname, params, cache )
06833 #  define GL_FOG_I( pname, param, cache, prev )   _GLFogiCached( pname, param, cache )
06834 # endif
06835 #else
06836 # define GL_FOG_F( pname, param, cache, prev )    _GLFogf( pname, param )
06837 # define GL_FOG_FV( pname, params, cache, prev )  _GLFogfv( pname, params )
06838 # define GL_FOG_I( pname, param, cache, prev )    _GLFogi( pname, param )
06839 #endif
06840 #endif // DOXYGEN_IGNORE
06841
06843
06845 inline  void  GLFogColor( const GLfloat * color )
06846 {
06847   GL_FOG_FV( GL_FOG_COLOR, color, &glContext()->m_fogAttributes.m_color[0]
06848            , &glContext()->m_previousAttributes.m_fogColor[0] );
06849 }
06850
06855 inline void GLResetFogColor()
06856 {
06857 #if defined(GL_SUPPORT_RESET)
06858   GLFogColor( &glContext()->m_previousAttributes.m_fogColor[0] );
06859 #else
06860   static nvmath::Vec4f fc(0.0f,0.0f,0.0f,0.0f);
06861   GLFogColor( &fc[0] );
06862 #endif
06863 }
06864
06866
06867 inline  void  GLFogCoordd( GLdouble fog )
06868 {
06869   NVSG_GL_STATS_FCT_COUNT();
06870   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFogCoordd );
06871   glContext()->m_glFunctions->glFogCoordd( fog );
06872   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06873 }
06874
06876
06877 inline  void  GLFogCoorddv( const GLdouble *fog )
06878 {
06879   NVSG_GL_STATS_FCT_COUNT();
06880   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFogCoorddv );
06881   glContext()->m_glFunctions->glFogCoorddv( fog );
06882   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06883 }
06884
06886
06887 inline  void  GLFogCoordf( GLfloat fog )
06888 {
06889   NVSG_GL_STATS_FCT_COUNT();
06890   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFogCoordf );
06891   glContext()->m_glFunctions->glFogCoordf( fog );
06892   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06893 }
06894
06896
06897 inline  void  GLFogCoordfv( const GLfloat *fog )
06898 {
06899   NVSG_GL_STATS_FCT_COUNT();
06900   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFogCoordfv );
06901   glContext()->m_glFunctions->glFogCoordfv( fog );
06902   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06903 }
06904
06906
06907 inline  void  GLFogCoordh( GLhalf fog )
06908 {
06909   NVSG_GL_STATS_FCT_COUNT();
06910   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFogCoordh );
06911   glContext()->m_glFunctions->glFogCoordh( fog );
06912   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06913 }
06914
06916
06917 inline  void  GLFogCoordhv( const GLhalf *fog )
06918 {
06919   NVSG_GL_STATS_FCT_COUNT();
06920   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFogCoordhv );
06921   glContext()->m_glFunctions->glFogCoordhv( fog );
06922   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06923 }
06924
06926
06927 inline  void  GLFogCoordPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
06928 {
06929   GLContext * ctx = glContext();
06930   NVSG_GL_STATS_FCT_COUNT();
06931   ctx->m_glFunctions->glFogCoordPointer( type, stride, pointer );
06932   ASSERT_GL_NO_ERROR;
06933 }
06934
06936
06938 inline  void  GLFogDensity( GLfloat density )
06939 {
06940   GL_FOG_F( GL_FOG_DENSITY, density, &glContext()->m_fogAttributes.m_density
06941           , &glContext()->m_previousAttributes.m_fogDensity );
06942 }
06943
06948 inline void GLResetFogDensity()
06949 {
06950 #if defined(GL_SUPPORT_RESET)
06951   GLFogDensity( glContext()->m_previousAttributes.m_fogDensity );
06952 #else
06953   GLFogDensity( 1.0f );
06954 #endif
06955 }
06956
06958
06960 inline  void  GLFogEnd( GLfloat end )
06961 {
06962   GL_FOG_F( GL_FOG_END, end, &glContext()->m_fogAttributes.m_end
06963           , &glContext()->m_previousAttributes.m_fogEnd );
06964 }
06965
06970 inline void GLResetFogEnd()
06971 {
06972 #if defined(GL_SUPPORT_RESET)
06973   GLFogEnd( glContext()->m_previousAttributes.m_fogEnd );
06974 #else
06975   GLFogEnd( 1.0f );
06976 #endif
06977 }
06978
06980
06981 inline  void  GLFogf( GLenum pname, GLfloat param )
06982 {
06983 #if defined( GL_CACHING )
06984   switch( pname )
06985   {
06986     case GL_FOG_DENSITY :
06987       GLFogDensity( param );
06988       break;
06989     case GL_FOG_END :
06990       GLFogEnd( param );
06991       break;
06992     case GL_FOG_MODE :
06993       GLFogMode( (GLenum)param );
06994       break;
06995     case GL_FOG_START :
06996       GLFogStart( param );
06997       break;
06998     default :
06999       _GLFogf( pname, param );
07000       break;
07001   }
07002 #else
07003   _GLFogf( pname, param );
07004 #endif
07005 }
07006
07008
07009 inline  void  GLFogfv( GLenum pname, const GLfloat *params )
07010 {
07011 #if defined( GL_CACHING )
07012   switch( pname )
07013   {
07014     case GL_FOG_COLOR :
07015       GLFogColor( params );
07016       break;
07017     case GL_FOG_DENSITY :
07018       GLFogDensity( *params );
07019       break;
07020     case GL_FOG_END :
07021       GLFogEnd( *params );
07022       break;
07023     case GL_FOG_MODE :
07024       GLFogMode( (GLenum)*params );
07025       break;
07026     case GL_FOG_START :
07027       GLFogStart( *params );
07028       break;
07029     default :
07030       _GLFogfv( pname, params );
07031       break;
07032   }
07033 #else
07034   _GLFogfv( pname, params );
07035 #endif
07036 }
07037
07039
07040 inline  void  GLFogi( GLenum pname, GLint param )
07041 {
07042 #if defined( GL_CACHING )
07043   switch( pname )
07044   {
07045     case GL_FOG_DENSITY :
07046       GLFogDensity( (GLfloat)param );
07047       break;
07048     case GL_FOG_END :
07049       GLFogEnd( (GLfloat)param );
07050       break;
07051     case GL_FOG_MODE :
07052       GLFogMode( param );
07053       break;
07054     case GL_FOG_START :
07055       GLFogStart( (GLfloat)param );
07056       break;
07057     default :
07058       _GLFogi( pname, param );
07059       break;
07060   }
07061 #else
07062   _GLFogi( pname, param );
07063 #endif
07064 }
07065
07067
07068 inline  void  GLFogiv( GLenum pname, const GLint *params )
07069 {
07070 #if defined( GL_CACHING )
07071   switch( pname )
07072   {
07073     case GL_FOG_COLOR :
07074       {
07075         GLfloat fParams[4];
07076         for ( size_t i=0 ; i<4 ; i++ )
07077         {
07078           fParams[i] = (GLfloat)params[i];
07079         }
07080         GLFogColor( fParams );
07081       }
07082       break;
07083     case GL_FOG_DENSITY :
07084       GLFogDensity( (GLfloat)*params );
07085       break;
07086     case GL_FOG_END :
07087       GLFogEnd( (GLfloat)*params );
07088       break;
07089     case GL_FOG_MODE :
07090       GLFogMode( *params );
07091       break;
07092     case GL_FOG_START :
07093       GLFogStart( (GLfloat)*params );
07094       break;
07095     default :
07096       _GLFogiv( pname, params );
07097       break;
07098   }
07099 #else
07100   _GLFogiv( pname, params );
07101 #endif
07102 }
07103
07105
07107 inline  void  GLFogMode( GLenum mode )
07108 {
07109   GL_FOG_I( GL_FOG_MODE, mode, (GLint*)&glContext()->m_fogAttributes.m_mode
07110           , (GLint*) &glContext()->m_previousAttributes.m_fogMode );
07111 }
07112
07117 inline void GLResetFogMode()
07118 {
07119 #if defined(GL_SUPPORT_RESET)
07120   GLFogMode( glContext()->m_previousAttributes.m_fogMode );
07121 #else
07122   GLFogMode( GL_EXP );
07123 #endif
07124 }
07125
07127
07129 inline  void  GLFogStart( GLfloat start )
07130 {
07131   GL_FOG_F( GL_FOG_START, start, &glContext()->m_fogAttributes.m_start
07132           , glContext()->m_previousAttributes.m_fogStart );
07133 }
07134
07139 inline void GLResetFogStart()
07140 {
07141 #if defined(GL_SUPPORT_RESET)
07142   GLFogStart( glContext()->m_previousAttributes.m_fogStart );
07143 #else
07144   GLFogStart( 0.0f );
07145 #endif
07146 }
07147
07149
07150 inline  void  GLFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level )
07151 {
07152   NVSG_GL_STATS_FCT_COUNT();
07153   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFramebufferTexture );
07154   glContext()->m_glFunctions->glFramebufferTexture( target, attachment, texture, level );
07155   ASSERT_GL_NO_ERROR;
07156 }
07157
07159
07160 inline  void  GLFramebufferTextureFace( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face )
07161 {
07162   NVSG_GL_STATS_FCT_COUNT();
07163   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFramebufferTextureFace );
07164   glContext()->m_glFunctions->glFramebufferTextureFace( target, attachment, texture, level, face );
07165   ASSERT_GL_NO_ERROR;
07166 }
07167
07169
07170 inline  void  GLFrontFace( GLenum mode )
07171 {
07172 #if defined(GL_CACHING)
07173   GLContext * ctx = glContext();
07174 # if defined(GL_SUPPORT_RESET)
07175   ctx->m_previousAttributes.m_frontFaceMode = ctx->m_polygonAttributes.m_frontFaceMode;
07176 # endif
07177   if ( mode != ctx->m_polygonAttributes.m_frontFaceMode )
07178 #endif
07179   {
07180     NVSG_GL_STATS_FCT_COUNT();
07181     glFrontFace( mode );
07182     ASSERT_GL_NO_ERROR;
07183 #if defined(GL_CACHING)
07184     ctx->m_polygonAttributes.m_frontFaceMode = mode;
07185 #endif
07186   }
07187 }
07188
07193 inline void GLResetFrontFace()
07194 {
07195 #if defined(GL_SUPPORT_RESET)
07196   GLFrontFace( glContext()->m_previousAttributes.m_frontFaceMode );
07197 #else
07198   GLFrontFace(GL_CCW);
07199 #endif
07200 }
07201
07203
07204 inline  void  GLFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
07205 {
07206   NVSG_GL_STATS_FRUSTUM( left, right, bottom, top, zNear, zFar );
07207   glFrustum( left, right, bottom, top, zNear, zFar );
07208   ASSERT_GL_NO_ERROR;
07209 }
07210
07212
07213 inline  GLuint  GLGenLists( GLsizei range )
07214 {
07215   NVSG_GL_STATS_GEN_LISTS( range );
07216   GLuint  firstList = glGenLists( range );
07217   glContext()->addLists(range, firstList);
07218   ASSERT_GL_NO_ERROR;
07219   return( firstList );
07220 }
07221
07223
07224 inline  void  GLGenOcclusionQueries( GLsizei n, GLuint *ids )
07225 {
07226   NVSG_GL_STATS_FCT_COUNT();
07227   GLContext * ctx = glContext();
07228   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glGenOcclusionQueriesNV );
07229   ctx->m_glFunctions->glGenOcclusionQueriesNV( n, ids );
07230   ctx->addOcclusionQueries(n, ids);
07231   ASSERT_GL_NO_ERROR;
07232 }
07233
07235
07236 inline  void  GLGenPrograms( GLsizei n, GLuint *ids )
07237 {
07238   NVSG_GL_STATS_FCT_COUNT();
07239   GLContext * ctx = glContext();
07240   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glGenProgramsNV );
07241   ctx->m_glFunctions->glGenProgramsNV( n, ids );
07242   ctx->addPrograms(n, ids);
07243   ASSERT_GL_NO_ERROR;
07244 }
07245
07247
07248 inline  void  GLGenQueries( GLsizei n, GLuint *ids )
07249 {
07250   NVSG_GL_STATS_FCT_COUNT();
07251   GLContext * ctx = glContext();
07252   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glGenQueries );
07253   ctx->m_glFunctions->glGenQueries( n, ids );
07254   ctx->addQueries( n, ids );
07255   ASSERT_GL_NO_ERROR;
07256 }
07257
07259
07260 inline  void  GLGenTextures( GLsizei n, GLuint *textures )
07261 {
07262   NVSG_GL_STATS_GEN_TEXTURES( n, textures );
07263   glGenTextures( n, textures );
07264   glContext()->addTextures(n, textures);
07265   ASSERT_GL_NO_ERROR;
07266 }
07267
07269
07270 inline  void  GLGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name )
07271 {
07272   NVSG_GL_STATS_FCT_COUNT();
07273   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetActiveAttrib );
07274   glContext()->m_glFunctions->glGetActiveAttrib( program, index, bufSize, length, size, type, name );
07275   ASSERT_GL_NO_ERROR;
07276 }
07277
07279
07280 inline  void  GLGetActiveUniform( GLuint program, GLuint index, GLsizei maxLength, GLsizei *length, GLsizei *size, GLenum *type, GLcharARB *name )
07281 {
07282   NVSG_GL_STATS_FCT_COUNT();
07283   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetActiveUniform );
07284   glContext()->m_glFunctions->glGetActiveUniform( program, index, maxLength, length, size, type, name );
07285   ASSERT_GL_NO_ERROR;
07286 }
07287
07289
07290 inline  void  GLGetActiveVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name )
07291 {
07292   NVSG_GL_STATS_FCT_COUNT();
07293   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetActiveVaryingNV );
07294   glContext()->m_glFunctions->glGetActiveVaryingNV( program, index, bufSize, length, size, type, name );
07295   ASSERT_GL_NO_ERROR;
07296 }
07297
07299
07300 inline  void  GLGetAttachedObjects( GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj )
07301 {
07302   NVSG_GL_STATS_FCT_COUNT();
07303   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetAttachedObjectsARB );
07304   glContext()->m_glFunctions->glGetAttachedObjectsARB( containerObj, maxCount, count, obj );
07305   ASSERT_GL_NO_ERROR;
07306 }
07307
07309
07310 inline  void  GLGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders )
07311 {
07312   NVSG_GL_STATS_FCT_COUNT();
07313   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetAttachedShaders );
07314   glContext()->m_glFunctions->glGetAttachedShaders( program, maxCount, count, shaders );
07315   ASSERT_GL_NO_ERROR;
07316 }
07317
07319
07320 inline  GLint GLGetAttribLocation( GLuint program, const GLchar *name )
07321 {
07322   NVSG_GL_STATS_FCT_COUNT();
07323   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetAttribLocation );
07324   GLint loc = glContext()->m_glFunctions->glGetAttribLocation( program, name );
07325   ASSERT_GL_NO_ERROR;
07326   return( loc );
07327 }
07328
07330
07331 inline  void  GLGetBooleanv( GLenum pname, GLboolean *params )
07332 {
07333   NVSG_GL_STATS_FCT_COUNT();
07334   glGetBooleanv( pname, params );
07335   ASSERT_GL_NO_ERROR;
07336 }
07337
07339
07340 inline  void  GLGetBooleanIndexedv( GLenum target, GLuint index, GLboolean *data )
07341 {
07342   NVSG_GL_STATS_FCT_COUNT();
07343   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetBooleanIndexedv );
07344   glContext()->m_glFunctions->glGetBooleanIndexedv( target, index, data );
07345   ASSERT_GL_NO_ERROR;
07346 }
07347
07349
07350 inline  void  GLGetColorTable( GLenum target, GLenum format, GLenum type, GLvoid *table )
07351 {
07352   NVSG_GL_STATS_FCT_COUNT();
07353   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetColorTable );
07354   glContext()->m_glFunctions->glGetColorTable( target, format, type, table );
07355   ASSERT_GL_NO_ERROR;
07356 }
07357
07359
07360 inline void GLGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
07361 {
07362   NVSG_GL_STATS_FCT_COUNT();
07363   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetColorTableParameterfv );
07364   glContext()->m_glFunctions->glGetColorTableParameterfv( target, pname, params );
07365   ASSERT_GL_NO_ERROR;
07366 }
07367
07369
07370 inline void GLGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
07371 {
07372   NVSG_GL_STATS_FCT_COUNT();
07373   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetColorTableParameteriv );
07374   glContext()->m_glFunctions->glGetColorTableParameteriv( target, pname, params );
07375   ASSERT_GL_NO_ERROR;
07376 }
07377
07379
07380 inline void GLGetCombinerInputParameterfv( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params )
07381 {
07382   NVSG_GL_STATS_FCT_COUNT();
07383   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetCombinerInputParameterfv );
07384   glContext()->m_glFunctions->glGetCombinerInputParameterfv( stage, portion, variable, pname, params );
07385   ASSERT_GL_NO_ERROR;
07386 }
07387
07389
07390 inline void GLGetCombinerInputParameteriv( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params )
07391 {
07392   NVSG_GL_STATS_FCT_COUNT();
07393   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetCombinerInputParameteriv );
07394   glContext()->m_glFunctions->glGetCombinerInputParameteriv( stage, portion, variable, pname, params );
07395   ASSERT_GL_NO_ERROR;
07396 }
07397
07399
07400 inline void GLGetCombinerOutputParameterfv( GLenum stage, GLenum portion, GLenum pname, GLfloat *params )
07401 {
07402   NVSG_GL_STATS_FCT_COUNT();
07403   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetCombinerOutputParameterfv );
07404   glContext()->m_glFunctions->glGetCombinerOutputParameterfv( stage, portion, pname, params );
07405   ASSERT_GL_NO_ERROR;
07406 }
07407
07409
07410 inline void GLGetCombinerOutputParameteriv( GLenum stage, GLenum portion, GLenum pname, GLint *params )
07411 {
07412   NVSG_GL_STATS_FCT_COUNT();
07413   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetCombinerOutputParameteriv );
07414   glContext()->m_glFunctions->glGetCombinerOutputParameteriv( stage, portion, pname, params );
07415   ASSERT_GL_NO_ERROR;
07416 }
07417
07419
07420 inline void GLGetCombinerStageParameterfv( GLenum stage, GLenum pname, GLfloat *params )
07421 {
07422   NVSG_GL_STATS_FCT_COUNT();
07423   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetCombinerStageParameterfv );
07424   glContext()->m_glFunctions->glGetCombinerStageParameterfv( stage, pname, params );
07425   ASSERT_GL_NO_ERROR;
07426 }
07427
07429
07430 inline void GLGetCompressedTexImage( GLenum target, GLint lod, GLvoid *img )
07431 {
07432   NVSG_GL_STATS_FCT_COUNT();
07433   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetCompressedTexImage );
07434   glContext()->m_glFunctions->glGetCompressedTexImage( target, lod, img );
07435   ASSERT_GL_NO_ERROR;
07436 }
07437
07439
07440 inline void GLGetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid *image )
07441 {
07442   NVSG_GL_STATS_FCT_COUNT();
07443   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetConvolutionFilter );
07444   glContext()->m_glFunctions->glGetConvolutionFilter( target, format, type, image );
07445   ASSERT_GL_NO_ERROR;
07446 }
07447
07449
07450 inline void GLGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params )
07451 {
07452   NVSG_GL_STATS_FCT_COUNT();
07453   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetConvolutionParameterfv );
07454   glContext()->m_glFunctions->glGetConvolutionParameterfv( target, pname, params );
07455   ASSERT_GL_NO_ERROR;
07456 }
07457
07459
07460 inline void GLGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params )
07461 {
07462   NVSG_GL_STATS_FCT_COUNT();
07463   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetConvolutionParameteriv );
07464   glContext()->m_glFunctions->glGetConvolutionParameteriv( target, pname, params );
07465   ASSERT_GL_NO_ERROR;
07466 }
07467
07469
07470 inline  void  GLGetDoublev( GLenum pname, GLdouble *params )
07471 {
07472   NVSG_GL_STATS_FCT_COUNT();
07473   glGetDoublev( pname, params );
07474   ASSERT_GL_NO_ERROR;
07475 }
07476
07478
07479 inline  void  GLGetFenceiv( GLuint fence, GLenum pname, GLint *params )
07480 {
07481   NVSG_GL_STATS_FCT_COUNT();
07482   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetFenceiv );
07483   glContext()->m_glFunctions->glGetFenceiv( fence, pname, params );
07484   ASSERT_GL_NO_ERROR;
07485 }
07486
07488
07489 inline  void  GLGetFinalCombinerInputParameterfv( GLenum variable, GLenum pname, GLfloat *params )
07490 {
07491   NVSG_GL_STATS_FCT_COUNT();
07492   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetFinalCombinerInputParameterfv );
07493   glContext()->m_glFunctions->glGetFinalCombinerInputParameterfv( variable, pname, params );
07494   ASSERT_GL_NO_ERROR;
07495 }
07496
07498
07499 inline  void  GLGetFinalCombinerInputParameteriv( GLenum variable, GLenum pname, GLint *params )
07500 {
07501   NVSG_GL_STATS_FCT_COUNT();
07502   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetFinalCombinerInputParameteriv );
07503   glContext()->m_glFunctions->glGetFinalCombinerInputParameteriv( variable, pname, params );
07504   ASSERT_GL_NO_ERROR;
07505 }
07506
07508
07509 inline  void  GLGetFloatv( GLenum pname, GLfloat *params )
07510 {
07511   NVSG_GL_STATS_FCT_COUNT();
07512   glGetFloatv( pname, params );
07513   ASSERT_GL_NO_ERROR;
07514 }
07515
07516 inline  void  GLGetFogColor( GLfloat * fogColor )
07517 {
07518   NVSG_GL_STATS_FCT_COUNT();
07519   NVSG_ASSERT( glContext() );
07520 #if defined(GL_CACHING)
07521 # if !defined(NDEBUG)
07522   GLfloat params[4];
07523   glGetFloatv( GL_FOG_COLOR, params );
07524   ASSERT_GL_NO_ERROR;
07525   NVSG_ASSERT( memcmp( params, &glContext()->m_fogAttributes.m_color[0], 4*sizeof(GLfloat) ) == 0 );
07526 # endif
07527   memcpy( fogColor, &glContext()->m_fogAttributes.m_color[0], 4*sizeof(GLfloat) );
07528 #else
07529   glGetFloatv( GL_FOG_COLOR, fogColor );
07530   ASSERT_GL_NO_ERROR;
07531 #endif
07532 }
07533
07535
07536 inline  GLint GLGetFragDataLocation( GLuint program, const GLchar *name )
07537 {
07538   NVSG_GL_STATS_FCT_COUNT();
07539   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetFragDataLocation );
07540   GLint loc = glContext()->m_glFunctions->glGetFragDataLocation( program, name );
07541   ASSERT_GL_NO_ERROR;
07542   return( loc );
07543 }
07544
07546
07547 inline  GLhandleARB GLGetHandle( GLenum pname )
07548 {
07549   NVSG_GL_STATS_FCT_COUNT();
07550   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetHandleARB );
07551   GLhandleARB hdl = glContext()->m_glFunctions->glGetHandleARB( pname );
07552   ASSERT_GL_NO_ERROR;
07553   return( hdl );
07554 }
07555
07557
07558 inline  void  GLGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values )
07559 {
07560   NVSG_GL_STATS_GET_INTEGERV( pname, params );
07561   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetHistogram );
07562   glContext()->m_glFunctions->glGetHistogram( target, reset, format, type, values );
07563   ASSERT_GL_NO_ERROR;
07564 }
07565
07567
07568 inline  void  GLGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params )
07569 {
07570   NVSG_GL_STATS_GET_INTEGERV( pname, params );
07571   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetHistogramParameterfv );
07572   glContext()->m_glFunctions->glGetHistogramParameterfv( target, pname, params );
07573   ASSERT_GL_NO_ERROR;
07574 }
07575
07577
07578 inline  void  GLGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params )
07579 {
07580   NVSG_GL_STATS_GET_INTEGERV( pname, params );
07581   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetHistogramParameteriv );
07582   glContext()->m_glFunctions->glGetHistogramParameteriv( target, pname, params );
07583   ASSERT_GL_NO_ERROR;
07584 }
07585
07587
07588 inline  void  GLGetInfoLog( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog )
07589 {
07590   NVSG_GL_STATS_FCT_COUNT();
07591   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetInfoLogARB );
07592   glContext()->m_glFunctions->glGetInfoLogARB( obj, maxLength, length, infoLog );
07593   ASSERT_GL_NO_ERROR;
07594 }
07595
07597
07598 inline  void  GLGetIntegerv( GLenum pname, GLint *params )
07599 {
07600   NVSG_GL_STATS_GET_INTEGERV( pname, params );
07601   glGetIntegerv( pname, params );
07602   ASSERT_GL_NO_ERROR;
07603 }
07604
07606
07607 inline  void  GLGetIntegerIndexedv( GLenum target, GLuint index, GLint *data )
07608 {
07609   NVSG_GL_STATS_FCT_COUNT();
07610   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetIntegerIndexedv );
07611   glContext()->m_glFunctions->glGetIntegerIndexedv( target, index, data );
07612   ASSERT_GL_NO_ERROR;
07613 }
07614
07616
07617 inline  void  GLGetBufferParameteriv( GLenum target, GLenum pname, GLint *params )
07618 {
07619   NVSG_GL_STATS_FCT_COUNT();
07620   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetBufferParameteriv );
07621   glContext()->m_glFunctions->glGetBufferParameteriv( target, pname, params );
07622   ASSERT_GL_NO_ERROR;
07623 }
07624
07626
07627 inline  void  GLGetBufferPointerv( GLenum target, GLenum pname, GLvoid* *params )
07628 {
07629   NVSG_GL_STATS_FCT_COUNT();
07630   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetBufferPointerv );
07631   glContext()->m_glFunctions->glGetBufferPointerv( target, pname, params );
07632   ASSERT_GL_NO_ERROR;
07633 }
07634
07636
07637 inline  void  GLGetBufferSubData( GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data )
07638 {
07639   NVSG_GL_STATS_FCT_COUNT();
07640   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetBufferSubData );
07641   glContext()->m_glFunctions->glGetBufferSubData( target, offset, size, data );
07642   ASSERT_GL_NO_ERROR;
07643 }
07644
07646
07647 inline  void  GLGetClipPlane( GLenum plane, GLdouble *equation )
07648 {
07649   NVSG_GL_STATS_FCT_COUNT();
07650   glGetClipPlane( plane, equation );
07651   ASSERT_GL_NO_ERROR;
07652 }
07653
07655
07656 inline  void  GLGetLightfv( GLenum light, GLenum pname, GLfloat *params )
07657 {
07658   NVSG_GL_STATS_FCT_COUNT();
07659   glGetLightfv( light, pname, params );
07660   ASSERT_GL_NO_ERROR;
07661 }
07662
07664
07665 inline  void  GLGetLightiv( GLenum light, GLenum pname, GLint *params )
07666 {
07667   NVSG_GL_STATS_FCT_COUNT();
07668   glGetLightiv( light, pname, params );
07669   ASSERT_GL_NO_ERROR;
07670 }
07671
07673
07674 inline  void  GLGetMapdv( GLenum target, GLenum query, GLdouble *v )
07675 {
07676   NVSG_GL_STATS_FCT_COUNT();
07677   glGetMapdv( target, query, v );
07678   ASSERT_GL_NO_ERROR;
07679 }
07680
07682
07683 inline  void  GLGetMapfv( GLenum target, GLenum query, GLfloat *v )
07684 {
07685   NVSG_GL_STATS_FCT_COUNT();
07686   glGetMapfv( target, query, v );
07687   ASSERT_GL_NO_ERROR;
07688 }
07689
07691
07692 inline  void  GLGetMapiv( GLenum target, GLenum query, GLint *v )
07693 {
07694   NVSG_GL_STATS_FCT_COUNT();
07695   glGetMapiv( target, query, v );
07696   ASSERT_GL_NO_ERROR;
07697 }
07698
07700
07701 inline  void  GLGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
07702 {
07703   NVSG_GL_STATS_FCT_COUNT();
07704   glGetMaterialfv( face, pname, params );
07705   ASSERT_GL_NO_ERROR;
07706 }
07707
07709
07710 inline  void  GLGetMaterialiv( GLenum face, GLenum pname, GLint *params )
07711 {
07712   NVSG_GL_STATS_FCT_COUNT();
07713   glGetMaterialiv( face, pname, params );
07714   ASSERT_GL_NO_ERROR;
07715 }
07716
07718 inline GLint GLGetMaxTexCoords( void )
07719 {
07720   NVSG_GL_STATS_FCT_COUNT();
07721   return( glContext()->m_maxTexCoords );
07722 }
07723
07725 inline GLint GLGetMaxTexUnits( void )
07726 {
07727   NVSG_GL_STATS_FCT_COUNT();
07728   return( glContext()->m_maxTexUnits );
07729 }
07730
07732 inline GLint GLGetMaxTexImageUnits( void )
07733 {
07734   NVSG_GL_STATS_FCT_COUNT();
07735   return glContext()->m_maxTexImageUnits;
07736 }
07737
07739
07740 inline  void  GLGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values )
07741 {
07742   NVSG_GL_STATS_FCT_COUNT();
07743   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetMinmax );
07744   glContext()->m_glFunctions->glGetMinmax( target, reset, format, type, values );
07745   ASSERT_GL_NO_ERROR;
07746 }
07747
07749
07750 inline  void  GLGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params )
07751 {
07752   NVSG_GL_STATS_FCT_COUNT();
07753   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetMinmaxParameterfv );
07754   glContext()->m_glFunctions->glGetMinmaxParameterfv( target, pname, params );
07755   ASSERT_GL_NO_ERROR;
07756 }
07757
07759
07760 inline  void  GLGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params )
07761 {
07762   NVSG_GL_STATS_FCT_COUNT();
07763   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetMinmaxParameteriv );
07764   glContext()->m_glFunctions->glGetMinmaxParameteriv( target, pname, params );
07765   ASSERT_GL_NO_ERROR;
07766 }
07767
07769
07770 inline  void  GLGetObjectParameterfv( GLhandleARB obj, GLenum pname, GLfloat *params )
07771 {
07772   NVSG_GL_STATS_FCT_COUNT();
07773   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetObjectParameterfvARB );
07774   glContext()->m_glFunctions->glGetObjectParameterfvARB( obj, pname, params );
07775   ASSERT_GL_NO_ERROR;
07776 }
07777
07779
07780 inline  void  GLGetObjectParameteriv( GLhandleARB obj, GLenum pname, GLint *params )
07781 {
07782   NVSG_GL_STATS_FCT_COUNT();
07783   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetObjectParameterivARB );
07784   glContext()->m_glFunctions->glGetObjectParameterivARB( obj, pname, params );
07785   ASSERT_GL_NO_ERROR;
07786 }
07787
07789
07790 inline  void  GLGetOcclusionQueryiv( GLuint id, GLenum pname, GLint *params )
07791 {
07792   NVSG_GL_STATS_FCT_COUNT();
07793   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetOcclusionQueryivNV );
07794   glContext()->m_glFunctions->glGetOcclusionQueryivNV( id, pname, params );
07795   ASSERT_GL_NO_ERROR;
07796 }
07797
07799
07800 inline  void  GLGetOcclusionQueryuiv( GLuint id, GLenum pname, GLuint *params )
07801 {
07802   NVSG_GL_STATS_FCT_COUNT();
07803   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetOcclusionQueryuivNV );
07804   glContext()->m_glFunctions->glGetOcclusionQueryuivNV( id, pname, params );
07805   ASSERT_GL_NO_ERROR;
07806 }
07807
07809
07810 inline  void  GLGetPixelMapfv( GLenum map, GLfloat *values )
07811 {
07812   NVSG_GL_STATS_FCT_COUNT();
07813   glGetPixelMapfv( map, values );
07814   ASSERT_GL_NO_ERROR;
07815 }
07816
07818
07819 inline  void  GLGetPixelMapuiv( GLenum map, GLuint *values )
07820 {
07821   NVSG_GL_STATS_FCT_COUNT();
07822   glGetPixelMapuiv( map, values );
07823   ASSERT_GL_NO_ERROR;
07824 }
07825
07827
07828 inline  void  GLGetPixelMapusv( GLenum map, GLushort *values )
07829 {
07830   NVSG_GL_STATS_FCT_COUNT();
07831   glGetPixelMapusv( map, values );
07832   ASSERT_GL_NO_ERROR;
07833 }
07834
07836
07837 inline  void  GLGetPointerv( GLenum pname, GLvoid* *params )
07838 {
07839   NVSG_GL_STATS_FCT_COUNT();
07840   glGetPointerv( pname, params );
07841   ASSERT_GL_NO_ERROR;
07842 }
07843
07845
07846 inline  void  GLGetPolygonStipple( GLubyte *mask )
07847 {
07848   NVSG_GL_STATS_FCT_COUNT();
07849   glGetPolygonStipple( mask );
07850   ASSERT_GL_NO_ERROR;
07851 }
07852
07854
07855 inline  void  GLGetProgramEnvParameterdv( GLenum target, GLuint index, GLdouble *params )
07856 {
07857   NVSG_GL_STATS_FCT_COUNT();
07858   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramEnvParameterdvARB );
07859   glContext()->m_glFunctions->glGetProgramEnvParameterdvARB( target, index, params );
07860   ASSERT_GL_NO_ERROR;
07861 }
07862
07864
07865 inline  void  GLGetProgramEnvParameterfv( GLenum target, GLuint index, GLfloat *params )
07866 {
07867   NVSG_GL_STATS_FCT_COUNT();
07868   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramEnvParameterfvARB );
07869   glContext()->m_glFunctions->glGetProgramEnvParameterfvARB( target, index, params );
07870   ASSERT_GL_NO_ERROR;
07871 }
07872
07874
07875 inline  void  GLGetProgramiv( GLuint program, GLenum pname, GLint *params )
07876 {
07877   NVSG_GL_STATS_FCT_COUNT();
07878   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramiv );
07879   glContext()->m_glFunctions->glGetProgramiv( program, pname, params );
07880   ASSERT_GL_NO_ERROR;
07881 }
07882
07884
07885 inline  void  GLGetProgramLocalParameterdv( GLenum target, GLuint index, GLdouble *params )
07886 {
07887   NVSG_GL_STATS_FCT_COUNT();
07888   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramLocalParameterdvARB );
07889   glContext()->m_glFunctions->glGetProgramLocalParameterdvARB( target, index, params );
07890   ASSERT_GL_NO_ERROR;
07891 }
07892
07894
07895 inline  void  GLGetProgramLocalParameterfv( GLenum target, GLuint index, GLfloat *params )
07896 {
07897   NVSG_GL_STATS_FCT_COUNT();
07898   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramLocalParameterfvARB );
07899   glContext()->m_glFunctions->glGetProgramLocalParameterfvARB( target, index, params );
07900   ASSERT_GL_NO_ERROR;
07901 }
07902
07903
07905
07906 inline  void  GLGetProgramInfoLog( GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog )
07907 {
07908   NVSG_GL_STATS_FCT_COUNT();
07909   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramInfoLog );
07910   glContext()->m_glFunctions->glGetProgramInfoLog( program, bufSize, length, infoLog );
07911   ASSERT_GL_NO_ERROR;
07912 }
07913
07915
07916 inline  void  GLGetProgramEnvParameterIiv( GLenum target, GLuint index, GLint *params )
07917 {
07918   NVSG_GL_STATS_FCT_COUNT();
07919   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramEnvParameterIiv );
07920   glContext()->m_glFunctions->glGetProgramEnvParameterIiv( target, index, params );
07921   ASSERT_GL_NO_ERROR;
07922 }
07923
07925
07926 inline  void  GLGetProgramEnvParameterIuiv( GLenum target, GLuint index, GLuint *params )
07927 {
07928   NVSG_GL_STATS_FCT_COUNT();
07929   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramEnvParameterIuiv );
07930   glContext()->m_glFunctions->glGetProgramEnvParameterIuiv( target, index, params );
07931   ASSERT_GL_NO_ERROR;
07932 }
07933
07935
07936 inline  void  GLGetProgramLocalParameterIiv( GLenum target, GLuint index, GLint *params )
07937 {
07938   NVSG_GL_STATS_FCT_COUNT();
07939   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramLocalParameterIiv );
07940   glContext()->m_glFunctions->glGetProgramLocalParameterIiv( target, index, params );
07941   ASSERT_GL_NO_ERROR;
07942 }
07943
07945
07946 inline  void  GLGetProgramLocalParameterIuiv( GLenum target, GLuint index, GLuint *params )
07947 {
07948   NVSG_GL_STATS_FCT_COUNT();
07949   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramLocalParameterIuiv );
07950   glContext()->m_glFunctions->glGetProgramLocalParameterIuiv( target, index, params );
07951   ASSERT_GL_NO_ERROR;
07952 }
07953
07955
07956 inline  void  GLGetProgramNamedParameterdv( GLuint id, GLsizei len, const GLubyte *name, GLdouble *params )
07957 {
07958   NVSG_GL_STATS_FCT_COUNT();
07959   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramNamedParameterdv );
07960   glContext()->m_glFunctions->glGetProgramNamedParameterdv( id, len, name, params );
07961   ASSERT_GL_NO_ERROR;
07962 }
07963
07965
07966 inline  void  GLGetProgramNamedParameterfv( GLuint id, GLsizei len, const GLubyte *name, GLfloat *params )
07967 {
07968   NVSG_GL_STATS_FCT_COUNT();
07969   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramNamedParameterfv );
07970   glContext()->m_glFunctions->glGetProgramNamedParameterfv( id, len, name, params );
07971   ASSERT_GL_NO_ERROR;
07972 }
07973
07975
07976 inline  void  GLGetProgramParameterdv( GLenum target, GLuint index, GLenum pname, GLdouble *params )
07977 {
07978   NVSG_GL_STATS_FCT_COUNT();
07979   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramParameterdvNV );
07980   glContext()->m_glFunctions->glGetProgramParameterdvNV( target, index, pname, params );
07981   ASSERT_GL_NO_ERROR;
07982 }
07983
07985
07986 inline  void  GLGetProgramParameterfv( GLenum target, GLuint index, GLenum pname, GLfloat *params )
07987 {
07988   NVSG_GL_STATS_FCT_COUNT();
07989   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramParameterfvNV );
07990   glContext()->m_glFunctions->glGetProgramParameterfvNV( target, index, pname, params );
07991   ASSERT_GL_NO_ERROR;
07992 }
07993
07995
07996 inline  void  GLGetProgramString( GLuint id, GLenum pname, GLubyte *program )
07997 {
07998   NVSG_GL_STATS_FCT_COUNT();
07999   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetProgramStringNV );
08000   glContext()->m_glFunctions->glGetProgramStringNV( id, pname, program );
08001   ASSERT_GL_NO_ERROR;
08002 }
08003
08005
08006 inline  void  GLGetQueryiv( GLenum target, GLenum pname, GLint *params )
08007 {
08008   NVSG_GL_STATS_FCT_COUNT();
08009   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetQueryiv );
08010   glContext()->m_glFunctions->glGetQueryiv( target, pname, params );
08011   ASSERT_GL_NO_ERROR;
08012 }
08013
08015
08016 inline  void  GLGetQueryObjecti64v( GLuint id, GLenum pname, GLint64EXT *params )
08017 {
08018   NVSG_GL_STATS_FCT_COUNT();
08019   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetQueryObjecti64v );
08020   glContext()->m_glFunctions->glGetQueryObjecti64v( id, pname, params );
08021   ASSERT_GL_NO_ERROR;
08022 }
08023
08025
08026 inline  void  GLGetQueryObjectiv( GLuint id, GLenum pname, GLint *params )
08027 {
08028   NVSG_GL_STATS_FCT_COUNT();
08029   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetQueryObjectiv );
08030   glContext()->m_glFunctions->glGetQueryObjectiv( id, pname, params );
08031   ASSERT_GL_NO_ERROR;
08032 }
08033
08035
08036 inline  void  GLGetQueryObjectui64v( GLuint id, GLenum pname, GLuint64EXT *params )
08037 {
08038   NVSG_GL_STATS_FCT_COUNT();
08039   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetQueryObjectui64v );
08040   glContext()->m_glFunctions->glGetQueryObjectui64v( id, pname, params );
08041   ASSERT_GL_NO_ERROR;
08042 }
08043
08045
08046 inline  void  GLGetQueryObjectuiv( GLuint id, GLenum pname, GLuint *params )
08047 {
08048   NVSG_GL_STATS_FCT_COUNT();
08049   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetQueryObjectuiv );
08050   glContext()->m_glFunctions->glGetQueryObjectuiv( id, pname, params );
08051   ASSERT_GL_NO_ERROR;
08052 }
08053
08055
08056 inline  void  GLGetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span )
08057 {
08058   NVSG_GL_STATS_FCT_COUNT();
08059   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetSeparableFilter );
08060   glContext()->m_glFunctions->glGetSeparableFilter( target, format, type, row, column, span );
08061   ASSERT_GL_NO_ERROR;
08062 }
08063
08065
08066 inline  void  GLGetShaderiv( GLuint shader, GLenum pname, GLint *params )
08067 {
08068   NVSG_GL_STATS_FCT_COUNT();
08069   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetShaderiv );
08070   glContext()->m_glFunctions->glGetShaderiv( shader, pname, params );
08071   ASSERT_GL_NO_ERROR;
08072 }
08073
08075
08076 inline  void  GLGetShaderInfoLog( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog )
08077 {
08078   NVSG_GL_STATS_FCT_COUNT();
08079   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetShaderInfoLog );
08080   glContext()->m_glFunctions->glGetShaderInfoLog( shader, bufSize, length, infoLog );
08081   ASSERT_GL_NO_ERROR;
08082 }
08083
08085
08086 inline  void  GLGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei *length, GLcharARB *source )
08087 {
08088   NVSG_GL_STATS_FCT_COUNT();
08089   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetShaderSource );
08090   glContext()->m_glFunctions->glGetShaderSource( shader, bufSize, length, source );
08091   ASSERT_GL_NO_ERROR;
08092 }
08093
08095
08096 inline  const GLubyte * GLGetString( GLenum name )
08097 {
08098   NVSG_GL_STATS_FCT_COUNT();
08099   const GLubyte * ret = glGetString( name );
08100   ASSERT_GL_NO_ERROR;
08101   return( ret );
08102 }
08103
08105
08106 inline  void  GLGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
08107 {
08108   NVSG_GL_STATS_FCT_COUNT();
08109   glGetTexEnvfv( target,pname, params );
08110   ASSERT_GL_NO_ERROR;
08111 }
08112
08114
08115 inline  void  GLGetTexEnviv( GLenum target, GLenum pname, GLint *params )
08116 {
08117   NVSG_GL_STATS_FCT_COUNT();
08118   glGetTexEnviv( target,pname, params );
08119   ASSERT_GL_NO_ERROR;
08120 }
08121
08123
08124 inline  void  GLGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
08125 {
08126   NVSG_GL_STATS_FCT_COUNT();
08127   glGetTexGendv( coord, pname, params );
08128   ASSERT_GL_NO_ERROR;
08129 }
08130
08132
08133 inline  void  GLGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
08134 {
08135   NVSG_GL_STATS_FCT_COUNT();
08136   glGetTexGenfv( coord, pname, params );
08137   ASSERT_GL_NO_ERROR;
08138 }
08139
08141
08142 inline  void  GLGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
08143 {
08144   NVSG_GL_STATS_FCT_COUNT();
08145   glGetTexGeniv( coord, pname, params );
08146   ASSERT_GL_NO_ERROR;
08147 }
08148
08150
08151 inline  void  GLGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels )
08152 {
08153 #if defined(GL_CACHING)
08154   _GLUpdateActiveTexture();
08155 #endif
08156   NVSG_GL_STATS_FCT_COUNT();
08157   glGetTexImage( target, level, format, type, pixels );
08158   ASSERT_GL_NO_ERROR;
08159 }
08160
08162
08163 inline  void  GLGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )
08164 {
08165   NVSG_GL_STATS_FCT_COUNT();
08166   glGetTexLevelParameterfv( target, level, pname, params );
08167   ASSERT_GL_NO_ERROR;
08168 }
08169
08171
08172 inline  void  GLGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )
08173 {
08174   NVSG_GL_STATS_FCT_COUNT();
08175   glGetTexLevelParameteriv( target, level, pname, params );
08176   ASSERT_GL_NO_ERROR;
08177 }
08178
08180
08181 inline  void  GLGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
08182 {
08183   NVSG_GL_STATS_FCT_COUNT();
08184   glGetTexParameterfv( target, pname, params );
08185   ASSERT_GL_NO_ERROR;
08186 }
08187
08189
08190 inline  void  GLGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
08191 {
08192   NVSG_GL_STATS_FCT_COUNT();
08193   glGetTexParameteriv( target, pname, params );
08194   ASSERT_GL_NO_ERROR;
08195 }
08196
08198
08199 inline  void  GLGetTexParameterIiv( GLenum target, GLenum pname, GLint *params )
08200 {
08201   NVSG_GL_STATS_FCT_COUNT();
08202   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetTexParameterIiv );
08203   glContext()->m_glFunctions->glGetTexParameterIiv( target, pname, params );
08204   ASSERT_GL_NO_ERROR;
08205 }
08206
08208
08209 inline  void  GLGetTexParameterIuiv( GLenum target, GLenum pname, GLuint *params )
08210 {
08211   NVSG_GL_STATS_FCT_COUNT();
08212   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetTexParameterIuiv );
08213   glContext()->m_glFunctions->glGetTexParameterIuiv( target, pname, params );
08214   ASSERT_GL_NO_ERROR;
08215 }
08216
08218
08219 inline  void  GLGetTrackMatrixiv( GLenum target, GLuint address, GLenum pname, GLint *params )
08220 {
08221   NVSG_GL_STATS_FCT_COUNT();
08222   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetTrackMatrixivNV );
08223   glContext()->m_glFunctions->glGetTrackMatrixivNV( target, address, pname, params );
08224   ASSERT_GL_NO_ERROR;
08225 }
08226
08228
08229 inline  void  GLGetTransformFeedbackVarying( GLuint program, GLuint index, GLint *location )
08230 {
08231   NVSG_GL_STATS_FCT_COUNT();
08232   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetTransformFeedbackVaryingNV );
08233   glContext()->m_glFunctions->glGetTransformFeedbackVaryingNV( program, index, location );
08234   ASSERT_GL_NO_ERROR;
08235 }
08236
08238
08239 inline  void  GLGetUniformfv( GLuint program, GLint location, GLfloat *params )
08240 {
08241   NVSG_GL_STATS_FCT_COUNT();
08242   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetUniformfv );
08243   glContext()->m_glFunctions->glGetUniformfv( program, location, params );
08244   ASSERT_GL_NO_ERROR;
08245 }
08246
08248
08249 inline  void  GLGetUniformiv( GLuint program, GLint location, GLint *params )
08250 {
08251   NVSG_GL_STATS_FCT_COUNT();
08252   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetUniformiv );
08253   glContext()->m_glFunctions->glGetUniformiv( program, location, params );
08254   ASSERT_GL_NO_ERROR;
08255 }
08256
08258
08259 inline  void  GLGetUniformuiv( GLuint program, GLint location, GLuint *params )
08260 {
08261   NVSG_GL_STATS_FCT_COUNT();
08262   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetUniformuiv );
08263   glContext()->m_glFunctions->glGetUniformuiv( program, location, params );
08264   ASSERT_GL_NO_ERROR;
08265 }
08266
08268
08269 inline  GLint GLGetUniformBufferSize( GLuint program, GLint location )
08270 {
08271   NVSG_GL_STATS_FCT_COUNT();
08272   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetUniformBufferSize );
08273   GLint size = glContext()->m_glFunctions->glGetUniformBufferSize( program, location);
08274   ASSERT_GL_NO_ERROR;
08275   return( size );
08276 }
08277
08279
08280 inline  GLint GLGetUniformLocation( GLuint program, const GLcharARB *name )
08281 {
08282   NVSG_GL_STATS_FCT_COUNT();
08283   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetUniformLocation );
08284   GLint loc = glContext()->m_glFunctions->glGetUniformLocation( program, name );
08285   ASSERT_GL_NO_ERROR;
08286   return( loc );
08287 }
08288
08290
08291 inline  GLintptr GLGetUniformOffset( GLuint program, GLint location )
08292 {
08293   NVSG_GL_STATS_FCT_COUNT();
08294   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetUniformOffset );
08295   GLintptr offset = glContext()->m_glFunctions->glGetUniformOffset( program, location );
08296   ASSERT_GL_NO_ERROR;
08297   return( offset );
08298 }
08299
08301
08302 inline  GLint GLGetVaryingLocation( GLuint program, const GLchar *name )
08303 {
08304   NVSG_GL_STATS_FCT_COUNT();
08305   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetVaryingLocationNV );
08306   GLint loc = glContext()->m_glFunctions->glGetVaryingLocationNV( program, name );
08307   ASSERT_GL_NO_ERROR;
08308   return( loc );
08309 }
08310
08312
08313 inline  void  GLGetVertexAttribdv( GLuint index, GLenum pname, GLdouble *params )
08314 {
08315   NVSG_GL_STATS_FCT_COUNT();
08316   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetVertexAttribdv );
08317   glContext()->m_glFunctions->glGetVertexAttribdv( index, pname, params );
08318   ASSERT_GL_NO_ERROR;
08319 }
08320
08322
08323 inline  void  GLGetVertexAttribfv( GLuint index, GLenum pname, GLfloat *params )
08324 {
08325   NVSG_GL_STATS_FCT_COUNT();
08326   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetVertexAttribfv );
08327   glContext()->m_glFunctions->glGetVertexAttribfv( index, pname, params );
08328   ASSERT_GL_NO_ERROR;
08329 }
08330
08332
08333 inline  void  GLGetVertexAttribiv( GLuint index, GLenum pname, GLint *params )
08334 {
08335   NVSG_GL_STATS_FCT_COUNT();
08336   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetVertexAttribiv );
08337   glContext()->m_glFunctions->glGetVertexAttribiv( index, pname, params );
08338   ASSERT_GL_NO_ERROR;
08339 }
08340
08342
08343 inline  void  GLGetVertexAttribIiv( GLuint index, GLenum pname, GLint *params )
08344 {
08345   NVSG_GL_STATS_FCT_COUNT();
08346   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetVertexAttribIiv );
08347   glContext()->m_glFunctions->glGetVertexAttribIiv( index, pname, params );
08348   ASSERT_GL_NO_ERROR;
08349 }
08350
08352
08353 inline  void  GLGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint *params )
08354 {
08355   NVSG_GL_STATS_FCT_COUNT();
08356   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetVertexAttribIuiv );
08357   glContext()->m_glFunctions->glGetVertexAttribIuiv( index, pname, params );
08358   ASSERT_GL_NO_ERROR;
08359 }
08360
08362
08363 inline  void  GLGetVertexAttribPointerv( GLuint index, GLenum pname, GLvoid* *pointer )
08364 {
08365   NVSG_GL_STATS_FCT_COUNT();
08366   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetVertexAttribPointerv );
08367   glContext()->m_glFunctions->glGetVertexAttribPointerv( index, pname, pointer );
08368   ASSERT_GL_NO_ERROR;
08369 }
08370
08372
08373 inline  void  GLHint( GLenum target, GLenum mode )
08374 {
08375   NVSG_GL_STATS_FCT_COUNT();
08376   glHint( target, mode );
08377   ASSERT_GL_NO_ERROR;
08378 }
08379
08381
08382 inline  void  GLHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink )
08383 {
08384   NVSG_GL_STATS_FCT_COUNT();
08385   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glHistogram );
08386   glContext()->m_glFunctions->glHistogram( target, width, internalformat, sink );
08387   ASSERT_GL_NO_ERROR;
08388 }
08389
08391
08392 inline  void  GLIndexd( GLdouble c )
08393 {
08394   NVSG_GL_STATS_FCT_COUNT();
08395   glIndexd( c );
08396   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
08397 }
08398
08400
08401 inline  void  GLIndexf( GLfloat c )
08402 {
08403   NVSG_GL_STATS_FCT_COUNT();
08404   glIndexf( c );
08405   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
08406 }
08407
08409
08410 inline  void  GLIndexi( GLint c )
08411 {
08412   NVSG_GL_STATS_FCT_COUNT();
08413   glIndexi( c );
08414   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
08415 }
08416
08418
08419 inline  void  GLIndexMask( GLuint mask )
08420 {
08421   NVSG_GL_STATS_FCT_COUNT();
08422   glIndexMask( mask );
08423   ASSERT_GL_NO_ERROR;
08424 }
08425
08427
08428 inline  void  GLIndexPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
08429 {
08430   NVSG_GL_STATS_FCT_COUNT();
08431   glIndexPointer( type, stride, pointer );
08432   ASSERT_GL_NO_ERROR;
08433 }
08434
08436
08437 inline  void  GLIndexs( GLshort c )
08438 {
08439   NVSG_GL_STATS_FCT_COUNT();
08440   glIndexs( c );
08441   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
08442 }
08443
08445
08446 inline  void  GLIndexub( GLubyte c )
08447 {
08448   NVSG_GL_STATS_FCT_COUNT();
08449   glIndexub( c );
08450   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
08451 }
08452
08454
08455 inline  void  GLInitNames( void )
08456 {
08457   NVSG_GL_STATS_FCT_COUNT();
08458   glInitNames();
08459   ASSERT_GL_NO_ERROR;
08460 }
08461
08463
08464 inline  void  GLInterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer )
08465 {
08466   NVSG_GL_STATS_FCT_COUNT();
08467   glInterleavedArrays( format, stride, pointer );
08468   ASSERT_GL_NO_ERROR;
08469 }
08470
08472
08473 inline  GLboolean  GLIsEnabled( GLenum cap )
08474 {
08475   GLboolean isEnabled;
08476 #if defined( GL_CACHING )
08477   switch( cap )
08478   {
08479     case GL_ALPHA_TEST :
08480       isEnabled = GLIsEnabledAlphaTest();
08481       break;
08482     case GL_AUTO_NORMAL :
08483       isEnabled = GLIsEnabledAutoNormal();
08484       break;
08485     case GL_BLEND :
08486       isEnabled = GLIsEnabledBlend();
08487       break;
08488     case GL_CLIP_PLANE0 :
08489     case GL_CLIP_PLANE1 :
08490     case GL_CLIP_PLANE2 :
08491     case GL_CLIP_PLANE3 :
08492     case GL_CLIP_PLANE4 :
08493     case GL_CLIP_PLANE5 :
08494       isEnabled = GLIsEnabledClipPlane( cap );
08495       break;
08496     case GL_COLOR_LOGIC_OP :
08497       isEnabled = GLIsEnabledColorLogicOp();
08498       break;
08499     case GL_COLOR_MATERIAL :
08500       isEnabled = GLIsEnabledColorMaterial();
08501       break;
08502     case GL_CULL_FACE :
08503       isEnabled = GLIsEnabledCullFace();
08504       break;
08505     case GL_DEPTH_TEST :
08506       isEnabled = GLIsEnabledDepthTest();
08507       break;
08508     case GL_DITHER :
08509       isEnabled = GLIsEnabledDither();
08510       break;
08511     case GL_FOG :
08512       isEnabled = GLIsEnabledFog();
08513       break;
08514     case GL_LIGHT0 :
08515     case GL_LIGHT1 :
08516     case GL_LIGHT2 :
08517     case GL_LIGHT3 :
08518     case GL_LIGHT4 :
08519     case GL_LIGHT5 :
08520     case GL_LIGHT6 :
08521     case GL_LIGHT7 :
08522       isEnabled = GLIsEnabledLight( cap );
08523       break;
08524     case GL_LIGHTING :
08525       isEnabled = GLIsEnabledLighting();
08526       break;
08527     case GL_LINE_SMOOTH :
08528       isEnabled = GLIsEnabledLineSmooth();
08529       break;
08530     case GL_LINE_STIPPLE :
08531       isEnabled = GLIsEnabledLineStipple();
08532       break;
08533     case GL_LOGIC_OP :
08534       isEnabled = GLIsEnabledLogicOp();
08535       break;
08536     case GL_NORMALIZE :
08537       isEnabled = GLIsEnabledNormalize();
08538       break;
08539     case GL_POINT_SMOOTH :
08540       isEnabled = GLIsEnabledPointSmooth();
08541       break;
08542     case GL_POLYGON_OFFSET_FILL :
08543       isEnabled = GLIsEnabledPolygonOffsetFill();
08544       break;
08545     case GL_POLYGON_OFFSET_LINE :
08546       isEnabled = GLIsEnabledPolygonOffsetLine();
08547       break;
08548     case GL_POLYGON_OFFSET_POINT :
08549       isEnabled = GLIsEnabledPolygonOffsetPoint();
08550       break;
08551     case GL_POLYGON_SMOOTH :
08552       isEnabled = GLIsEnabledPolygonSmooth();
08553       break;
08554     case GL_POLYGON_STIPPLE :
08555       isEnabled = GLIsEnabledPolygonStipple();
08556       break;
08557     case GL_SCISSOR_TEST :
08558       isEnabled = GLIsEnabledScissorTest();
08559       break;
08560     case GL_STENCIL_TEST :
08561       isEnabled = GLIsEnabledStencilTest();
08562       break;
08563     case GL_TEXTURE_1D :
08564     case GL_TEXTURE_2D :
08565     case GL_TEXTURE_3D :
08566     case GL_TEXTURE_CUBE_MAP :
08567     case GL_TEXTURE_RECTANGLE_NV :
08568     case GL_TEXTURE_2D_ARRAY_EXT :
08569     case GL_TEXTURE_1D_ARRAY_EXT :
08570       isEnabled = GLIsEnabledTexture( cap );
08571       break;
08572     case GL_TEXTURE_GEN_S :
08573     case GL_TEXTURE_GEN_T :
08574     case GL_TEXTURE_GEN_R :
08575     case GL_TEXTURE_GEN_Q :
08576       isEnabled = GLIsEnabledTextureGen( cap );
08577       break;
08578     default :
08579       isEnabled = _GLIsEnabled( cap );
08580       break;
08581   }
08582 #else
08583   isEnabled = _GLIsEnabled( cap );
08584 #endif
08585   return( isEnabled );
08586 }
08587
08589
08590 inline GLboolean GLIsEnabledAlphaTest()
08591 {
08592   return( GL_IS_ENABLED( GL_ALPHA_TEST, glContext()->m_colorBufferEnableAttributes.m_alphaTest ) );
08593 }
08594
08596
08597 inline GLboolean GLIsEnabledAutoNormal()
08598 {
08599   return( GL_IS_ENABLED( GL_AUTO_NORMAL, glContext()->m_evalAttributes.m_autoNormal ) );
08600 }
08601
08603
08604 inline GLboolean GLIsEnabledBlend()
08605 {
08606   return( GL_IS_ENABLED( GL_BLEND, glContext()->m_colorBufferEnableAttributes.m_blend ) );
08607 }
08608
08610
08611 inline GLboolean GLIsEnabledClipPlane( GLenum plane )
08612 {
08613 #if defined( GL_CACHING )
08614   NVSG_ASSERT( plane-GL_CLIP_PLANE0 < glContext()->m_transformEnableAttributes.m_clipPlanes.size() );
08615 #endif
08616   return( GL_IS_ENABLED( plane, glContext()->m_transformEnableAttributes.m_clipPlanes[plane-GL_CLIP_PLANE0] ) );
08617 }
08618
08620
08621 inline GLboolean GLIsEnabledColorLogicOp()
08622 {
08623   return( GL_IS_ENABLED( GL_COLOR_LOGIC_OP, glContext()->m_colorBufferEnableAttributes.m_colorLogicOp ) );
08624 }
08625
08627
08628 inline  GLboolean GLIsEnabledColorMaterial()
08629 {
08630   return( GL_IS_ENABLED( GL_COLOR_MATERIAL, glContext()->m_lightingAttributes.m_colorMaterial ) );
08631 }
08632
08634
08635 inline GLboolean GLIsEnabledCullFace()
08636 {
08637   return( GL_IS_ENABLED( GL_CULL_FACE, glContext()->m_polygonEnableAttributes.m_cullFace ) );
08638 }
08639
08641
08642 inline GLboolean GLIsEnabledDepthTest()
08643 {
08644   return( GL_IS_ENABLED( GL_DEPTH_TEST, glContext()->m_depthBufferEnableAttributes.m_depthTesting ) );
08645 }
08646
08648
08649 inline GLboolean GLIsEnabledDither()
08650 {
08651   return( GL_IS_ENABLED( GL_DITHER, glContext()->m_colorBufferEnableAttributes.m_dither ) );
08652 }
08653
08655
08656 inline GLboolean GLIsEnabledFog()
08657 {
08658   return( GL_IS_ENABLED( GL_FOG, glContext()->m_fogEnableAttributes.m_fog ) );
08659 }
08660
08662
08663 inline  GLboolean GLIsEnabledIndexed( GLenum target, GLuint index )
08664 {
08665   NVSG_GL_STATS_FCT_COUNT();
08666   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glIsEnabledIndexed );
08667   GLboolean ok = glContext()->m_glFunctions->glIsEnabledIndexed( target, index );
08668   ASSERT_GL_NO_ERROR;
08669   return( ok );
08670 }
08671
08673
08674 inline GLboolean GLIsEnabledLight( GLenum light )
08675 {
08676 #if defined( GL_CACHING )
08677   NVSG_ASSERT( light-GL_LIGHT0 < glContext()->m_lightingEnableAttributes.m_lights.size() );
08678 #endif
08679   return( GL_IS_ENABLED( light, glContext()->m_lightingEnableAttributes.m_lights[light-GL_LIGHT0] ) );
08680 }
08681
08683
08684 inline GLboolean GLIsEnabledLighting()
08685 {
08686   return( GL_IS_ENABLED( GL_LIGHTING, glContext()->m_lightingEnableAttributes.m_lighting ) );
08687 }
08688
08690
08691 inline GLboolean GLIsEnabledLineSmooth()
08692 {
08693   return( GL_IS_ENABLED( GL_LINE_SMOOTH, glContext()->m_lineEnableAttributes.m_smooth ) );
08694 }
08695
08697
08698 inline GLboolean GLIsEnabledLineStipple()
08699 {
08700   return( GL_IS_ENABLED( GL_LINE_STIPPLE, glContext()->m_lineEnableAttributes.m_stipple ) );
08701 }
08702
08704
08705 inline GLboolean GLIsEnabledLogicOp()
08706 {
08707   return( GL_IS_ENABLED( GL_LOGIC_OP, glContext()->m_colorBufferEnableAttributes.m_logicOp ) );
08708 }
08709
08711
08712 inline GLboolean GLIsEnabledNormalize()
08713 {
08714   return( GL_IS_ENABLED( GL_NORMALIZE, glContext()->m_transformEnableAttributes.m_normalize ) );
08715 }
08716
08718
08719 inline GLboolean GLIsEnabledPointSmooth()
08720 {
08721   return( GL_IS_ENABLED( GL_POINT_SMOOTH, glContext()->m_pointEnableAttributes.m_smooth ) );
08722 }
08723
08725
08726 inline GLboolean GLIsEnabledPolygonOffsetFill()
08727 {
08728   return( GL_IS_ENABLED( GL_POLYGON_OFFSET_FILL, glContext()->m_polygonEnableAttributes.m_offsetFill ) );
08729 }
08730
08732
08733 inline GLboolean GLIsEnabledPolygonOffsetLine()
08734 {
08735   return( GL_IS_ENABLED( GL_POLYGON_OFFSET_LINE, glContext()->m_polygonEnableAttributes.m_offsetLine ) );
08736 }
08737
08739
08740 inline GLboolean GLIsEnabledPolygonOffsetPoint()
08741 {
08742   return( GL_IS_ENABLED( GL_POLYGON_OFFSET_POINT, glContext()->m_polygonEnableAttributes.m_offsetPoint ) );
08743 }
08744
08746
08747 inline GLboolean GLIsEnabledPolygonSmooth()
08748 {
08749   return( GL_IS_ENABLED( GL_POLYGON_SMOOTH, glContext()->m_polygonEnableAttributes.m_smooth ) );
08750 }
08751
08753
08754 inline GLboolean GLIsEnabledPolygonStipple()
08755 {
08756   return( GL_IS_ENABLED( GL_POLYGON_STIPPLE, glContext()->m_polygonEnableAttributes.m_stipple ) );
08757 }
08758
08760
08761 inline GLboolean GLIsEnabledScissorTest()
08762 {
08763   return( GL_IS_ENABLED( GL_SCISSOR_TEST, glContext()->m_scissorEnableAttributes.m_scissorTest ) );
08764 }
08765
08767
08768 inline GLboolean GLIsEnabledStencilTest()
08769 {
08770   return( GL_IS_ENABLED( GL_STENCIL_TEST, glContext()->m_stencilBufferEnableAttributes.m_stencilTest ) );
08771 }
08772
08774
08775 inline GLboolean GLIsEnabledTexture( GLenum target )
08776 {
08777   NVSG_ASSERT(    ( target == GL_TEXTURE_1D ) || ( target == GL_TEXTURE_2D ) || ( target == GL_TEXTURE_3D )
08778               ||  ( target == GL_TEXTURE_CUBE_MAP ) || ( target == GL_TEXTURE_RECTANGLE_NV )
08779               ||  ( target == GL_TEXTURE_2D_ARRAY_EXT ) || ( target == GL_TEXTURE_2D_ARRAY_EXT ) );
08780   GLContext * ctx = glContext();
08781   return( GL_IS_ENABLED( target, ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_texture[target] ) );
08782 }
08783
08785
08786 inline GLboolean GLIsEnabledTextureGen( GLenum target )
08787 {
08788   NVSG_ASSERT(    ( target == GL_TEXTURE_GEN_S )
08789               ||  ( target == GL_TEXTURE_GEN_T )
08790               ||  ( target == GL_TEXTURE_GEN_R )
08791               ||  ( target == GL_TEXTURE_GEN_Q ) );
08792   GLContext * ctx = glContext();
08793   return( GL_IS_ENABLED( target, ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_gen[target-GL_TEXTURE_GEN_S] ) );
08794 }
08795
08797
08800 inline GLint GLGetVersion()
08801 {
08802   NVSG_GL_STATS_FCT_COUNT();
08803   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
08804   return glContext()->m_glFunctions->getVersion();
08805 }
08806
08808
08810 inline GLboolean GLIsExtensionAvailable( const std::string& extension )
08811 {
08812   NVSG_GL_STATS_FCT_COUNT();
08813   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
08814   return glContext()->m_glFunctions->isAvailable(extension);
08815 }
08816
08818
08820 inline GLboolean GLIsExtensionExported( const std::string& extension )
08821 {
08822   NVSG_GL_STATS_FCT_COUNT();
08823   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
08824   return glContext()->m_glFunctions->isExported(extension);
08825 }
08826
08828
08829 inline  GLboolean GLIsFence( GLuint fence )
08830 {
08831   NVSG_GL_STATS_FCT_COUNT();
08832   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glIsFence );
08833   GLboolean ok = glContext()->m_glFunctions->glIsFence( fence );
08834   ASSERT_GL_NO_ERROR;
08835   return( ok );
08836 }
08837
08839
08840 inline  GLboolean GLIsList( GLuint list )
08841 {
08842   NVSG_GL_STATS_FCT_COUNT();
08843   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
08844   NVSG_ASSERT(!!glContext()->isList(list)==!!glIsList(list));
08845   return glContext()->isList(list);
08846 }
08847
08849
08850 inline  GLboolean GLIsOcclusionQuery( GLuint id )
08851 {
08852   NVSG_GL_STATS_FCT_COUNT();
08853   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glIsOcclusionQueryNV );
08854   NVSG_ASSERT( !!glContext()->isOcclusionQuery(id) == !!glContext()->m_glFunctions->glIsOcclusionQueryNV(id) );
08855   return( glContext()->isOcclusionQuery( id ) );
08856 }
08857
08859
08860 inline  GLboolean GLIsProgram( GLuint program )
08861 {
08862   NVSG_GL_STATS_FCT_COUNT();
08863   NVSG_ASSERT(glContext()->m_glFunctions && glContext()->m_glFunctions->glIsProgram );
08864   NVSG_ASSERT( !!glContext()->isProgram( program ) == !!glContext()->m_glFunctions->glIsProgram( program ) );
08865   return glContext()->isProgram( program );
08866 }
08867
08869
08870 inline  GLboolean GLIsQuery( GLuint id )
08871 {
08872   NVSG_GL_STATS_FCT_COUNT();
08873   NVSG_ASSERT(glContext()->m_glFunctions && glContext()->m_glFunctions->glIsQuery);
08874   NVSG_ASSERT(!!glContext()->isQuery(id)==!!glContext()->m_glFunctions->glIsQuery(id));
08875   return glContext()->isQuery(id);
08876 }
08877
08879
08880 inline  GLboolean GLIsShader( GLuint shader )
08881 {
08882   NVSG_GL_STATS_FCT_COUNT();
08883   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glIsShader );
08884   GLboolean ok = glContext()->m_glFunctions->glIsShader( shader );
08885   ASSERT_GL_NO_ERROR;
08886   return( ok );
08887 }
08888
08890
08891 inline  GLboolean GLIsTexture( GLuint texture )
08892 {
08893   NVSG_GL_STATS_IS_TEXTURE( texture );
08894   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
08895   NVSG_ASSERT(!!glContext()->isTexture(texture)==!!glIsTexture(texture));
08896   return(glContext()->isTexture(texture));
08897 }
08898
08899 #if !defined(DOXYGEN_IGNORE)
08900 #if defined( GL_CACHING )
08901 inline void _GLLightfCached( GLenum light, GLenum pname, GLfloat param, GLfloat * cache )
08902 {
08903   if ( param != *cache )
08904   {
08905 #if !defined(NDEBUG)
08906     GLfloat f;
08907     glGetLightfv( light, pname, &f );
08908     NVSG_ASSERT( f == *cache );
08909 #endif
08910     _GLLightf( light, pname, param );
08911     *cache = param;
08912   }
08913 }
08914 inline void _GLLightfvCached( GLenum light, GLenum pname, const GLfloat * params, GLfloat * cache )
08915 {
08916   if ( !equal4fv( params, cache ) )
08917   {
08918 #if !defined(NDEBUG)
08919     GLfloat f[4];
08920     glGetLightfv( light, pname, f );
08921     NVSG_ASSERT( equal4fv( f, cache ) );
08922 #endif
08923     _GLLightfv( light, pname, params );
08924     memcpy( cache, params, 4*sizeof(GLfloat) );
08925   }
08926 }
08927 # if defined(GL_SUPPORT_RESET)
08928 inline void _GLLightfCached( GLenum light, GLenum pname, GLfloat param, GLfloat * cache, GLfloat * prev )
08929 {
08930   *prev = *cache;
08931   _GLLightfCached( light, pname, param, cache );
08932 }
08933 inline void _GLLightfvCached( GLenum light, GLenum pname, const GLfloat * params, GLfloat * cache, GLfloat * prev )
08934 {
08935   memcpy( prev, cache, 4*sizeof(GLfloat) );
08936   _GLLightfvCached( light, pname, params, cache );
08937 }
08938 #  define GL_LIGHT_F( light, pname, param, cache, prev )    _GLLightfCached( light, pname, param, cache, prev )
08939 #  define GL_LIGHT_FV( light, pname, params, cache, prev )  _GLLightfvCached( light, pname, params, cache, prev )
08940 # else
08941 #  define GL_LIGHT_F( light, pname, param, cache, prev )    _GLLightfCached( light, pname, param, cache )
08942 #  define GL_LIGHT_FV( light, pname, params, cache, prev )  _GLLightfvCached( light, pname, params, cache )
08943 # endif
08944 #else
08945 # define GL_LIGHT_F( light, pname, param, cache, prev )     _GLLightf( light, pname, param )
08946 # define GL_LIGHT_FV( light, pname, params, cache, prev )   _GLLightfv( light, pname, params )
08947 #endif
08948 #endif // DOXYGEN_IGNORE
08949
08951
08953 inline  void  GLLightAmbient( GLenum light, const GLfloat *params )
08954 {
08955   GL_LIGHT_FV( light, GL_AMBIENT, params
08956              , &glContext()->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_ambient[0]
08957              , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_ambient[0] );
08958 }
08959
08965 inline void GLResetLightAmbient( GLenum light )
08966 {
08967 #if defined(GL_SUPPORT_RESET)
08968   GLLightAmbient( light, &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_ambient[0] );
08969 #else
08970   static nvmath::Vec4f al(0.0f,0.0f,0.0f,1.0f);
08971   GLLightAmbient(light, &al[0]);
08972 #endif
08973 }
08974
08976
08978 inline  void  GLLightConstantAttenuation( GLenum light, GLfloat param )
08979 {
08980   GL_LIGHT_F( light, GL_CONSTANT_ATTENUATION, param
08981             , &glContext()->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[0]
08982             , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[0] );
08983 }
08984
08990 inline void GLResetLightConstantAttenuation( GLenum light )
08991 {
08992 #if defined(GL_SUPPORT_RESET)
08993   GLLightConstantAttenuation( light, glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[0] );
08994 #else
08995   GLLightConstantAttenuation( light, 1.0f );
08996 #endif
08997 }
08998
09000
09002 inline  void  GLLightDiffuse( GLenum light, const GLfloat *params )
09003 {
09004   GL_LIGHT_FV( light, GL_DIFFUSE, params
09005              , &glContext()->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_diffuse[0]
09006              , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_diffuse[0] );
09007 }
09008
09015 inline void GLResetLightDiffuse( GLenum light )
09016 {
09017 #if defined(GL_SUPPORT_RESET)
09018   GLLightDiffuse( light, &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_diffuse[0] );
09019 #else
09020   static Vec4f ld[2] = { Vec4f(1.0f,1.0f.1.0f,1.0f), Vec4f(0.0f,0.0f,0.0f,1.0f) };
09021   GLLightDiffuse( light, &ld[light!=GL_LIGHT0][0] );
09022 #endif
09023 }
09024
09026
09028 inline  void  GLLightLinearAttenuation( GLenum light, GLfloat param )
09029 {
09030   GL_LIGHT_F( light, GL_LINEAR_ATTENUATION, param
09031             , &glContext()->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[1]
09032             , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[1] );
09033 }
09034
09040 inline void GLResetLightLinearAttenuation( GLenum light )
09041 {
09042 #if defined(GL_SUPPORT_RESET)
09043   GLLightLinearAttenuation( light, glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[1] );
09044 #else
09045   GLLightLinearAttenuation( light, 0.0f );
09046 #endif
09047 }
09048
09050
09051 inline  void  GLLightPosition( GLenum light, const GLfloat *params )
09052 {
09053 #if defined( GL_CACHING )
09054 # if defined( GL_SUPPORT_RESET )
09055   GLContext * ctx = glContext();
09056   ctx->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_position = ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_position;
09057   memcpy( &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_position[0], params, 4*sizeof(GLfloat) );
09058 # endif
09059   _GLLightfv( light, GL_POSITION, params );
09060 #else
09061   GLLightfv( light, GL_POSITION, params );
09062 #endif
09063 }
09064
09070 inline void GLResetLightPosition( GLenum light )
09071 {
09072 #if defined( GL_SUPPORT_RESET )
09073   GLLightPosition( light, &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_position[0] );
09074 #else
09075   static nvmath::Vec4f lp(0.0f,0.0f,1.0f,0.0f);
09076   GLLightPosition( light, &lp[0] );
09077 #endif
09078 }
09079
09081
09083 inline  void  GLLightQuadraticAttenuation( GLenum light, GLfloat param )
09084 {
09085   GL_LIGHT_F( light, GL_QUADRATIC_ATTENUATION, param
09086             , &glContext()->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[2]
09087             , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[2] );
09088 }
09089
09095 inline void GLResetLightQuadraticAttenuation( GLenum light )
09096 {
09097 #if defined(GL_SUPPORT_RESET)
09098   GLLightQuadraticAttenuation( light, glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[2] );
09099 #else
09100   GLLightQuadraticAttenuation( light, 0.0f );
09101 #endif
09102 }
09103
09105
09107 inline  void  GLLightSpecular( GLenum light, const GLfloat *params )
09108 {
09109   GL_LIGHT_FV( light, GL_SPECULAR, params
09110              , &glContext()->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_specular[0]
09111              , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_specular[0] );
09112 }
09113
09120 inline void GLResetLightSpecular( GLenum light )
09121 {
09122 #if defined(GL_SUPPORT_RESET)
09123   GLLightSpecular( light, &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_specular[0] );
09124 #else
09125   static Vec4f ls[2] = { Vec4f(1.0f,1.0f.1.0f,1.0f), Vec4f(0.0f,0.0f,0.0f,1.0f) };
09126   GLLightSpecular( light, &ls[light!=GL_LIGHT0][0] );
09127 #endif
09128 }
09129
09131
09133 inline  void  GLLightSpotCutoff( GLenum light, GLfloat param )
09134 {
09135   GL_LIGHT_F( light, GL_SPOT_CUTOFF, param
09136             , &glContext()->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotCutoff
09137             , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_spotCutoff );
09138 }
09139
09145 inline void GLResetLightSpotCutoff( GLenum light )
09146 {
09147 #if defined(GL_SUPPORT_RESET)
09148   GLLightSpotCutoff( light, glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_spotCutoff );
09149 #else
09150   GLLightSpotCutoff( light, 180.0f );
09151 #endif
09152 }
09153
09155
09156 inline  void  GLLightSpotDirection( GLenum light, const GLfloat *params )
09157 {
09158 #if defined( GL_CACHING )
09159 # if defined( GL_SUPPORT_RESET )
09160   GLContext * ctx = glContext();
09161   ctx->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_spotDirection = ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotDirection;
09162   memcpy( &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotDirection[0], params, 4*sizeof(GLfloat) );
09163 # endif
09164   _GLLightfv( light, GL_SPOT_DIRECTION, params );
09165 #else
09166   GLLightfv( light, GL_SPOT_DIRECTION, params );
09167 #endif
09168 }
09169
09175 inline void GLResetLightSpotDirection( GLenum light )
09176 {
09177 #if defined( GL_SUPPORT_RESET )
09178   GLLightSpotDirection( light
09179                       , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_spotDirection[0] );
09180 #else
09181   static nvmath::Vec4f lsd(0.0f,0.0f,-1.0f,1.0f);
09182   GLLightSpotDirection( light, &lsd[0] );
09183 #endif
09184 }
09185
09187
09189 inline  void  GLLightSpotExponent( GLenum light, GLfloat param )
09190 {
09191   GL_LIGHT_F( light, GL_SPOT_EXPONENT, param
09192             , &glContext()->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotExponent
09193             , &glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_spotExponent );
09194 }
09195
09201 inline void GLResetLightSpotExponent( GLenum light )
09202 {
09203 #if defined(GL_SUPPORT_RESET)
09204   GLLightSpotExponent( light, glContext()->m_previousAttributes.m_lightParameters[light-GL_LIGHT0].m_spotExponent );
09205 #else
09206   GLLightSpotExponent( light, 0.0f );
09207 #endif
09208 }
09209
09211
09212 inline  void  GLLightf( GLenum light, GLenum pname, GLfloat param )
09213 {
09214 #if defined( GL_CACHING )
09215   switch( pname )
09216   {
09217     case GL_CONSTANT_ATTENUATION :
09218       GLLightConstantAttenuation( light, param );
09219       break;
09220     case GL_LINEAR_ATTENUATION :
09221       GLLightLinearAttenuation( light, param );
09222       break;
09223     case GL_QUADRATIC_ATTENUATION :
09224       GLLightQuadraticAttenuation( light, param );
09225       break;
09226     case GL_SPOT_CUTOFF :
09227       GLLightSpotCutoff( light, param );
09228       break;
09229     case GL_SPOT_EXPONENT :
09230       GLLightSpotExponent( light, param );
09231       break;
09232     default :
09233       _GLLightf( light, pname, param );
09234       break;
09235   }
09236 #else
09237   _GLLightf( light, pname, param );
09238 #endif
09239 }
09240
09242
09243 inline  void  GLLightfv( GLenum light, GLenum pname, const GLfloat *params )
09244 {
09245 #if defined( GL_CACHING )
09246   switch( pname )
09247   {
09248     case GL_AMBIENT :
09249       GLLightAmbient( light, params );
09250       break;
09251     case GL_CONSTANT_ATTENUATION :
09252       GLLightConstantAttenuation( light, params[0] );
09253       break;
09254     case GL_DIFFUSE :
09255       GLLightDiffuse( light, params );
09256       break;
09257     case GL_LINEAR_ATTENUATION :
09258       GLLightLinearAttenuation( light, params[0] );
09259       break;
09260     case GL_POSITION :
09261       GLLightPosition( light, params );
09262       break;
09263     case GL_QUADRATIC_ATTENUATION :
09264       GLLightQuadraticAttenuation( light, params[0] );
09265       break;
09266     case GL_SPECULAR :
09267       GLLightSpecular( light, params );
09268       break;
09269     case GL_SPOT_CUTOFF :
09270       GLLightSpotCutoff( light, params[0] );
09271       break;
09272     case GL_SPOT_DIRECTION :
09273       GLLightSpotDirection( light, params );
09274       break;
09275     case GL_SPOT_EXPONENT :
09276       GLLightSpotExponent( light, params[0] );
09277       break;
09278     default :
09279       _GLLightfv( light, pname, params );
09280       break;
09281   }
09282 #else
09283   _GLLightfv( light, pname, params );
09284 #endif
09285 }
09286
09288
09289 inline  void  GLLighti( GLenum light, GLenum pname, GLint param )
09290 {
09291 #if defined( GL_CACHING )
09292   switch( pname )
09293   {
09294     case GL_CONSTANT_ATTENUATION :
09295       GLLightConstantAttenuation( light, (GLfloat)param );
09296       break;
09297     case GL_LINEAR_ATTENUATION :
09298       GLLightLinearAttenuation( light, (GLfloat)param );
09299       break;
09300     case GL_QUADRATIC_ATTENUATION :
09301       GLLightQuadraticAttenuation( light, (GLfloat)param );
09302       break;
09303     case GL_SPOT_CUTOFF :
09304       GLLightSpotCutoff( light, (GLfloat)param );
09305       break;
09306     case GL_SPOT_EXPONENT :
09307       GLLightSpotExponent( light, (GLfloat)param );
09308       break;
09309     default :
09310       _GLLighti( light, pname, param );
09311       break;
09312   }
09313 #else
09314   _GLLighti( light, pname, param );
09315 #endif
09316 }
09317
09319 inline  void  GLintToGLfloat( const GLint *params, GLfloat *fParams )
09320 {
09321   for ( size_t i=0 ; i<4 ; i++ )
09322   {
09323     fParams[i] = (GLfloat)params[i] / INT_MAX;
09324   }
09325 }
09326
09328
09329 inline  void  GLLightiv( GLenum light, GLenum pname, GLint *params )
09330 {
09331 #if defined( GL_CACHING )
09332   GLfloat fParams[4];
09333   switch( pname )
09334   {
09335     case GL_AMBIENT :
09336       GLintToGLfloat( params, fParams );
09337       GLLightAmbient( light, fParams );
09338       break;
09339     case GL_CONSTANT_ATTENUATION :
09340       GLLightConstantAttenuation( light, (GLfloat)params[0] );
09341       break;
09342     case GL_DIFFUSE :
09343       GLintToGLfloat( params, fParams );
09344       GLLightDiffuse( light, fParams );
09345       break;
09346     case GL_LINEAR_ATTENUATION :
09347       GLLightLinearAttenuation( light, (GLfloat)params[0] );
09348       break;
09349     case GL_POSITION :
09350       for ( size_t i=0 ; i<4 ; i++ )
09351       {
09352         fParams[i] = (GLfloat)params[i];
09353       }
09354       GLLightPosition( light, fParams );
09355       break;
09356     case GL_QUADRATIC_ATTENUATION :
09357       GLLightQuadraticAttenuation( light, (GLfloat)params[0] );
09358       break;
09359     case GL_SPECULAR :
09360       GLintToGLfloat( params, fParams );
09361       GLLightSpecular( light, fParams );
09362       break;
09363     case GL_SPOT_CUTOFF :
09364       GLLightSpotCutoff( light, (GLfloat)params[0] );
09365       break;
09366     case GL_SPOT_DIRECTION :
09367       for ( size_t i=0 ; i<4 ; i++ )
09368       {
09369         fParams[i] = (GLfloat)params[i];
09370       }
09371       GLLightSpotDirection( light, fParams );
09372       break;
09373     case GL_SPOT_EXPONENT :
09374       GLLightSpotExponent( light, (GLfloat)params[0] );
09375       break;
09376     default :
09377       _GLLightiv( light, pname, params );
09378       break;
09379   }
09380 #else
09381   _GLLightiv( light, pname, params );
09382 #endif
09383 }
09384
09386
09387 inline  void  GLLightModelAmbient( const GLfloat * params )
09388 {
09389 #if defined( GL_CACHING )
09390   GLContext * ctx = glContext();
09391 # if defined(GL_SUPPORT_RESET)
09392   ctx->m_previousAttributes.m_lightModelAmbient = ctx->m_lightingAttributes.m_lightModelAmbient;
09393 # endif
09394   if ( !equal4fv( &ctx->m_lightingAttributes.m_lightModelAmbient[0], params ) )
09395 #endif
09396   {
09397     _GLLightModelfv( GL_LIGHT_MODEL_AMBIENT, params );
09398 #if defined( GL_CACHING )
09399     memcpy( &ctx->m_lightingAttributes.m_lightModelAmbient[0], params, 4*sizeof(float) );
09400 #endif
09401   }
09402 }
09403
09408 inline void GLResetLightModelAmbient()
09409 {
09410 #if defined(GL_SUPPORT_RESET)
09411   GLLightModelAmbient( &glContext()->m_previousAttributes.m_lightModelAmbient[0] );
09412 #else
09413   static nvmath::Vec4f lma(0.2f,0.2f,0.2f,1.0f);
09414   GLLightModelAmbient( &lma[0] );
09415 #endif
09416 }
09417
09419
09420 inline  void  GLLightModelLocalViewer( GLint param )
09421 {
09422 #if defined( GL_CACHING )
09423   GLContext * ctx = glContext();
09424 # if defined(GL_SUPPORT_RESET)
09425   ctx->m_previousAttributes.m_lightModelLocalViewer = ctx->m_lightingAttributes.m_lightModelLocalViewer;
09426 # endif
09427   if ( ctx->m_lightingAttributes.m_lightModelLocalViewer != !!param )
09428   {
09429 # if !defined(NDEBUG)
09430     GLboolean lv;
09431     glGetBooleanv( GL_LIGHT_MODEL_LOCAL_VIEWER, &lv );
09432     NVSG_ASSERT( ctx->m_lightingAttributes.m_lightModelLocalViewer == !!lv );
09433 # endif
09434 #endif
09435     _GLLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, param );
09436 #if defined( GL_CACHING )
09437     ctx->m_lightingAttributes.m_lightModelLocalViewer = !!param;
09438   }
09439 #endif
09440 }
09441
09446 inline void GLResetLightModelLocalViewer()
09447 {
09448 #if defined(GL_SUPPORT_RESET)
09449   GLLightModelLocalViewer( glContext()->m_previousAttributes.m_lightModelLocalViewer );
09450 #else
09451   GLLightModelLocalViewer( GL_FALSE );
09452 #endif
09453 }
09454
09456
09457 inline  void  GLLightModelTwoSide( GLint param )
09458 {
09459   GLContext * ctx = glContext();
09460 #if defined( GL_CACHING )
09461 # if defined(GL_SUPPORT_RESET)
09462   ctx->m_previousAttributes.m_lightModelTwoSide = ctx->m_lightingAttributes.m_lightModelTwoSide;
09463 # endif
09464   if ( ctx->m_lightingAttributes.m_lightModelTwoSide != !!param )
09465 #endif
09466   {
09467     if ( ! ctx->m_locks.m_lightModelTwoSide )
09468     {
09469 #if !defined( NDEBUG ) && defined( GL_CACHING )
09470       GLboolean lv;
09471       glGetBooleanv( GL_LIGHT_MODEL_TWO_SIDE, &lv );
09472       NVSG_ASSERT( ctx->m_lightingAttributes.m_lightModelTwoSide == !!lv );
09473 #endif
09474       _GLLightModeli( GL_LIGHT_MODEL_TWO_SIDE, param );
09475 #if defined( GL_CACHING )
09476       ctx->m_lightingAttributes.m_lightModelTwoSide = !!param;
09477 #endif
09478     }
09479   }
09480 }
09481
09486 inline void GLResetLightModelTwoSide()
09487 {
09488 #if defined(GL_SUPPORT_RESET)
09489   GLLightModelTwoSide( glContext()->m_previousAttributes.m_lightModelTwoSide );
09490 #else
09491   GLLightModelTwoSide( GL_FALSE );
09492 #endif
09493 }
09494
09501 inline void GLLightModelTwoSideLock( GLint param )
09502 {
09503   NVSG_ASSERT( !glContext()->m_locks.m_lightModelTwoSide );
09504   GLLightModelTwoSide( param );
09505   glContext()->m_locks.m_lightModelTwoSide = true;
09506 }
09507
09512 inline void GLLightModelTwoSideUnlock( GLint param )
09513 {
09514   NVSG_ASSERT( glContext()->m_locks.m_lightModelTwoSide );
09515   glContext()->m_locks.m_lightModelTwoSide = false;
09516   GLLightModelTwoSide( param );
09517 }
09518
09520
09521 inline  void  GLLightModelf( GLenum pname, GLfloat param )
09522 {
09523   switch( pname )
09524   {
09525     case GL_LIGHT_MODEL_LOCAL_VIEWER :
09526       GLLightModelLocalViewer( (GLint)param );
09527       break;
09528     case GL_LIGHT_MODEL_TWO_SIDE :
09529       GLLightModelTwoSide( (GLint)param );
09530       break;
09531     default :
09532       _GLLightModelf( pname, param );
09533       break;
09534   }
09535 }
09536
09538
09539 inline  void  GLLightModelfv( GLenum pname, const GLfloat *params )
09540 {
09541   switch( pname )
09542   {
09543     case GL_LIGHT_MODEL_AMBIENT :
09544       GLLightModelAmbient( params );
09545       break;
09546     case GL_LIGHT_MODEL_LOCAL_VIEWER :
09547       GLLightModelLocalViewer( (GLint)params[0] );
09548       break;
09549     case GL_LIGHT_MODEL_TWO_SIDE :
09550       GLLightModelTwoSide( (GLint)params[0] );
09551       break;
09552     default :
09553       _GLLightModelfv( pname, params );
09554       break;
09555   }
09556 }
09557
09559
09560 inline  void  GLLightModeli( GLenum pname, GLint param )
09561 {
09562   switch( pname )
09563   {
09564     case GL_LIGHT_MODEL_LOCAL_VIEWER :
09565       GLLightModelLocalViewer( param );
09566       break;
09567     case GL_LIGHT_MODEL_TWO_SIDE :
09568       GLLightModelTwoSide( param );
09569       break;
09570     default :
09571       _GLLightModeli( pname, param );
09572       break;
09573   }
09574 }
09575
09577
09578 inline  void  GLLightModeliv( GLenum pname, const GLint *params )
09579 {
09580   switch( pname )
09581   {
09582     case GL_LIGHT_MODEL_LOCAL_VIEWER :
09583       GLLightModelLocalViewer( params[0] );
09584       break;
09585     case GL_LIGHT_MODEL_TWO_SIDE :
09586       GLLightModelTwoSide( params[0] );
09587       break;
09588     default :
09589       _GLLightModeliv( pname, params );
09590       break;
09591   }
09592 }
09593
09595
09596 inline  void  GLLineStipple( GLint factor, GLushort pattern )
09597 {
09598 #if defined( GL_CACHING )
09599   GLContext * ctx = glContext();
09600 # if defined(GL_SUPPORT_RESET)
09601   ctx->m_previousAttributes.m_lineStipplePattern = ctx->m_lineAttributes.m_stipplePattern;
09602   ctx->m_previousAttributes.m_lineStippleRepeat  = ctx->m_lineAttributes.m_stippleRepeat;
09603 # endif
09604   if ( ( ctx->m_lineAttributes.m_stippleRepeat != factor ) || ( ctx->m_lineAttributes.m_stipplePattern != pattern ) )
09605 #endif
09606   {
09607     NVSG_GL_STATS_FCT_COUNT();
09608     glLineStipple( factor, pattern );
09609     ASSERT_GL_NO_ERROR;
09610 #if defined( GL_CACHING )
09611     ctx->m_lineAttributes.m_stippleRepeat = factor;
09612     ctx->m_lineAttributes.m_stipplePattern = pattern;
09613 #endif
09614   }
09615 }
09616
09622 inline void GLResetLineStippleDefinition()
09623 {
09624 #if defined(GL_SUPPORT_RESET)
09625   GLContext * ctx = glContext();
09626   GLLineStipple( ctx->m_previousAttributes.m_lineStippleRepeat
09627                , ctx->m_previousAttributes.m_lineStipplePattern );
09628 #else
09629   GLLineStipple( 1, (GLushort)0xFFFF );
09630 #endif
09631 }
09632
09634
09635 inline  void  GLLineWidth( GLfloat width )
09636 {
09637 #if defined( GL_CACHING )
09638   GLContext * ctx = glContext();
09639 # if defined(GL_SUPPORT_RESET)
09640   ctx->m_previousAttributes.m_lineWidth = ctx->m_lineAttributes.m_width;
09641 # endif
09642   if ( ctx->m_lineAttributes.m_width != width )
09643   {
09644 # if !defined(NDEBUG)
09645     GLfloat f;
09646     glGetFloatv( GL_LINE_WIDTH, &f );
09647     NVSG_ASSERT( ctx->m_lineAttributes.m_width == f );
09648 # endif
09649 #endif
09650     NVSG_GL_STATS_LINE_WIDTH( width );
09651     glLineWidth( width );
09652     ASSERT_GL_NO_ERROR;
09653 #if defined( GL_CACHING )
09654     ctx->m_lineAttributes.m_width = width;
09655   }
09656 #endif
09657 }
09658
09663 inline void GLResetLineWidth()
09664 {
09665 #if defined(GL_SUPPORT_RESET)
09666   GLLineWidth( glContext()->m_previousAttributes.m_lineWidth );
09667 #else
09668   GLLineWidth( 1.0f );
09669 #endif
09670 }
09671
09673
09674 inline  void  GLLinkProgram( GLuint program )
09675 {
09676   NVSG_GL_STATS_FCT_COUNT();
09677   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glLinkProgram );
09678   glContext()->m_glFunctions->glLinkProgram( program );
09679   ASSERT_GL_NO_ERROR;
09680 }
09681
09683
09684 inline  void  GLListBase( GLuint base )
09685 {
09686   NVSG_GL_STATS_FCT_COUNT();
09687   glListBase( base );
09688   ASSERT_GL_NO_ERROR;
09689 }
09690
09692
09693 inline  void  GLLoadIdentity( void )
09694 {
09695   NVSG_GL_STATS_LOAD_IDENTITY();
09696 #if defined( GL_CACHING )
09697   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
09698   { // note: we have a texture matrix stack per unit
09699     _GLUpdateActiveTexture();
09700   }
09701 #endif
09702   glLoadIdentity();
09703   ASSERT_GL_NO_ERROR;
09704 }
09705
09707
09708 inline  void  GLLoadMatrixd( const GLdouble *m )
09709 {
09710   NVSG_GL_STATS_LOAD_MATRIXD( m );
09711 #if defined( GL_CACHING )
09712   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
09713   { // note: we have a texture matrix stack per unit
09714     _GLUpdateActiveTexture();
09715   }
09716 #endif
09717   glLoadMatrixd( m );
09718   ASSERT_GL_NO_ERROR;
09719 }
09720
09722
09723 inline  void  GLLoadMatrixf( const GLfloat *m )
09724 {
09725   NVSG_GL_STATS_LOAD_MATRIXF( m );
09726 #if defined( GL_CACHING )
09727   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
09728   { // note: we have a texture matrix stack per unit
09729     _GLUpdateActiveTexture();
09730   }
09731 #endif
09732   glLoadMatrixf( m );
09733   ASSERT_GL_NO_ERROR;
09734 }
09735
09737
09738 inline  void  GLLoadTransposedMatrixd( const GLdouble *m )
09739 {
09740   NVSG_GL_STATS_LOAD_MATRIXD( m );
09741 #if defined( GL_CACHING )
09742   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
09743   { // note: we have a texture matrix stack per unit
09744     _GLUpdateActiveTexture();
09745   }
09746 #endif
09747   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glLoadTransposeMatrixd );
09748   glContext()->m_glFunctions->glLoadTransposeMatrixd( m );
09749   ASSERT_GL_NO_ERROR;
09750 }
09751
09753
09754 inline  void  GLLoadTransposeMatrixf( const GLfloat *m )
09755 {
09756   NVSG_GL_STATS_LOAD_MATRIXF( m );
09757 #if defined( GL_CACHING )
09758   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
09759   { // note: we have a texture matrix stack per unit
09760     _GLUpdateActiveTexture();
09761   }
09762 #endif
09763   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glLoadTransposeMatrixf );
09764   glContext()->m_glFunctions->glLoadTransposeMatrixf( m );
09765   ASSERT_GL_NO_ERROR;
09766 }
09767
09769
09770 inline  void  GLLoadName( GLuint name )
09771 {
09772   NVSG_GL_STATS_FCT_COUNT();
09773   glLoadName( name );
09774   ASSERT_GL_NO_ERROR;
09775 }
09776
09778
09779 inline  void  GLLoadProgram( GLenum target, GLuint id, GLsizei len, const GLubyte *program )
09780 {
09781   NVSG_GL_STATS_FCT_COUNT();
09782   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glLoadProgramNV );
09783   glContext()->m_glFunctions->glLoadProgramNV( target, id, len, program );
09784 #if !defined(NDEBUG)
09785   const GLubyte * err = glGetString( GL_PROGRAM_ERROR_STRING_NV );
09786   NVSG_ASSERT( err[0] == 0 );
09787   ASSERT_GL_NO_ERROR;
09788   GLint errorPos;
09789   glGetIntegerv( GL_PROGRAM_ERROR_POSITION_NV, &errorPos );
09790   NVSG_ASSERT( errorPos == -1 );
09791 #endif
09792 }
09793
09795
09796 inline  void  GLLockArrays( GLint first, GLsizei count )
09797 {
09798   NVSG_GL_STATS_FCT_COUNT();
09799   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glLockArrays );
09800   glContext()->m_glFunctions->glLockArrays( first, count );
09801   ASSERT_GL_NO_ERROR;
09802 }
09803
09805
09806 inline  void  GLLogicOp( GLenum opcode )
09807 {
09808   NVSG_GL_STATS_FCT_COUNT();
09809   glLogicOp( opcode );
09810   ASSERT_GL_NO_ERROR;
09811 }
09812
09814
09815 inline  void  GLMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
09816 {
09817   NVSG_GL_STATS_FCT_COUNT();
09818   glMap1d( target, u1, u2, stride, order, points );
09819   ASSERT_GL_NO_ERROR;
09820 }
09821
09823
09824 inline  void  GLMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
09825 {
09826   NVSG_GL_STATS_FCT_COUNT();
09827   glMap1f( target, u1, u2, stride, order, points );
09828   ASSERT_GL_NO_ERROR;
09829 }
09830
09832
09833 inline  void  GLMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
09834 {
09835   NVSG_GL_STATS_FCT_COUNT();
09836   glMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
09837   ASSERT_GL_NO_ERROR;
09838 }
09839
09841
09842 inline  void  GLMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
09843 {
09844   NVSG_GL_STATS_FCT_COUNT();
09845   glMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
09846   ASSERT_GL_NO_ERROR;
09847 }
09848
09850
09851 inline  void  GLMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
09852 {
09853   NVSG_GL_STATS_FCT_COUNT();
09854   glMapGrid1d( un, u1, u2 );
09855   ASSERT_GL_NO_ERROR;
09856 }
09857
09859
09860 inline  void  GLMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
09861 {
09862   NVSG_GL_STATS_FCT_COUNT();
09863   glMapGrid1f( un, u1, u2 );
09864   ASSERT_GL_NO_ERROR;
09865 }
09866
09868
09869 inline  void  GLMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
09870 {
09871   NVSG_GL_STATS_FCT_COUNT();
09872   glMapGrid2d( un, u1, u2, vn, v1, v2 );
09873   ASSERT_GL_NO_ERROR;
09874 }
09875
09877
09878 inline  void  GLMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
09879 {
09880   NVSG_GL_STATS_FCT_COUNT();
09881   glMapGrid2f( un, u1, u2, vn, v1, v2 );
09882   ASSERT_GL_NO_ERROR;
09883 }
09884
09885 #if !defined(DOXYGEN_IGNORE)
09886 #if defined( GL_CACHING )
09887 inline void _GLMaterialfCached( GLenum face, GLenum pname, GLfloat param, GLfloat * cache )
09888 {
09889   if ( !equalf( param, *cache ) )
09890   {
09891 #if !defined(NDEBUG)
09892     GLfloat f;
09893     glGetMaterialfv( face, pname, &f );
09894     NVSG_ASSERT( *cache == f );
09895 #endif
09896     _GLMaterialf( face, pname, param );
09897     *cache = param;
09898   }
09899 }
09900 inline void _GLMaterialfCached( GLenum pname, GLfloat param, GLfloat * cacheFront, GLfloat * cacheBack )
09901 {
09902   if ( !equalf( param, *cacheFront ) || !equalf( param, *cacheBack ) )
09903   {
09904 #if !defined(NDEBUG)
09905     GLfloat f0, f1;
09906     glGetMaterialfv( GL_FRONT, pname, &f0 );
09907     glGetMaterialfv( GL_BACK, pname, &f1 );
09908     NVSG_ASSERT( ( *cacheFront == f0 ) && ( *cacheBack == f1 ) );
09909 #endif
09910     _GLMaterialf( GL_FRONT_AND_BACK, pname, param );
09911     *cacheFront = param;
09912     *cacheBack = param;
09913   }
09914 }
09915 inline void _GLMaterialfvCached( GLenum face, GLenum pname, const GLfloat * params, GLfloat * cache )
09916 {
09917   if ( !equal4fv( params, cache ) )
09918   {
09919 #if !defined(NDEBUG)
09920     GLfloat p[4];
09921     glGetMaterialfv( face, pname, p );
09922     NVSG_ASSERT( equal4fv( cache, p ) );
09923 #endif
09924     _GLMaterialfv( face, pname, params );
09925     memcpy( cache, params, 4*sizeof(float) );
09926   }
09927 }
09928 inline void _GLMaterialfvCached( GLenum face, GLenum pname, const GLfloat * params, GLfloat * cache, bool colorMaterial )
09929 {
09930   if ( colorMaterial )
09931   {
09932     _GLMaterialfv( face, pname, params );
09933   }
09934   else
09935   {
09936     _GLMaterialfvCached( face, pname, params, cache );
09937   }
09938 }
09939 inline void _GLMaterialfvCached( GLenum pname, const GLfloat * params, GLfloat * cacheFront, GLfloat * cacheBack )
09940 {
09941   if ( !equal4fv( params, cacheFront ) || !equal4fv( params, cacheBack ) )
09942   {
09943 #if !defined(NDEBUG)
09944     GLfloat p0[4], p1[4];
09945     glGetMaterialfv( GL_FRONT, pname, p0 );
09946     glGetMaterialfv( GL_BACK, pname, p1 );
09947     NVSG_ASSERT( equal4fv( cacheFront, p0 ) && equal4fv( cacheBack, p1 ) );
09948 #endif
09949     _GLMaterialfv( GL_FRONT_AND_BACK, pname, params );
09950     memcpy( cacheFront, params, 4*sizeof(float) );
09951     memcpy( cacheBack, params, 4*sizeof(float) );
09952   }
09953 }
09954 inline void _GLMaterialfvCached( GLenum pname, const GLfloat * params, GLfloat * cacheFront, GLfloat * cacheBack, bool colorMaterial )
09955 {
09956   if ( colorMaterial )
09957   {
09958     _GLMaterialfv( GL_FRONT_AND_BACK, pname, params );
09959   }
09960   else
09961   {
09962     _GLMaterialfvCached( pname, params, cacheFront, cacheBack );
09963   }
09964 }
09965 # if defined(GL_SUPPORT_RESET)
09966 inline void _GLMaterialfCachedR( GLenum face, GLenum pname, GLfloat param, GLfloat * cache, GLfloat * prev )
09967 {
09968   *prev = *cache;
09969   _GLMaterialfCached( face, pname, param, cache );
09970 }
09971 inline void _GLMaterialfCachedR( GLenum pname, GLfloat param, GLfloat * cacheFront, GLfloat * cacheBack, GLfloat * prevFront, GLfloat * prevBack )
09972 {
09973   *prevFront = *cacheFront;
09974   *prevBack = *cacheBack;
09975   _GLMaterialfCached( pname, param, cacheFront, cacheBack );
09976 }
09977 inline void _GLMaterialfvCachedR( GLenum face, GLenum pname, const GLfloat * params, GLfloat * cache, GLfloat * prev )
09978 {
09979   memcpy( prev, cache, 4*sizeof(GLfloat) );
09980   _GLMaterialfvCached( face, pname, params, cache );
09981 }
09982 inline void _GLMaterialfvCachedR( GLenum face, GLenum pname, const GLfloat * params, GLfloat * cache, GLfloat * prev, bool colorMaterial )
09983 {
09984   memcpy( prev, cache, 4*sizeof(GLfloat) );
09985   _GLMaterialfvCached( face, pname, params, cache, colorMaterial );
09986 }
09987 inline void _GLMaterialfvCachedR( GLenum pname, const GLfloat * params, GLfloat * cacheFront, GLfloat * cacheBack, GLfloat * prevFront, GLfloat * prevBack )
09988 {
09989   memcpy( prevFront, cacheFront, 4*sizeof(GLfloat) );
09990   memcpy( prevBack, cacheBack, 4*sizeof(GLfloat) );
09991   _GLMaterialfvCached( pname, params, cacheFront, cacheBack );
09992 }
09993 inline void _GLMaterialfvCachedR( GLenum pname, const GLfloat * params, GLfloat * cacheFront, GLfloat * cacheBack, GLfloat * prevFront, GLfloat * prevBack, bool colorMaterial )
09994 {
09995   memcpy( prevFront, cacheFront, 4*sizeof(GLfloat) );
09996   memcpy( prevBack, cacheBack, 4*sizeof(GLfloat) );
09997   _GLMaterialfvCached( pname, params, cacheFront, cacheBack, colorMaterial );
09998 }
09999 #  define GL_MATERIAL_F( face, pname, param, cache, prev )                                    _GLMaterialfCachedR( face, pname, param, cache, prev )
10000 #  define GL_MATERIAL_F2( pname, param, cacheFront, cacheBack, prevFront, prevBack )          _GLMaterialfCachedR( pname, param, cacheFront, cacheBack, prevFront, prevBack )
10001 #  define GL_MATERIAL_FV( face, pname, params, cache, prev )                                  _GLMaterialfvCachedR( face, pname, params, cache, prev )
10002 #  define GL_MATERIAL_FV2( pname, params, cacheFront, cacheBack, prevFront, prevBack )        _GLMaterialfvCachedR( pname, params, cacheFront, cacheBack, prevFront, prevBack )
10003 #  define GL_MATERIAL_FV_CM( face, pname, params, cache, prev, cm )                           _GLMaterialfvCachedR( face, pname, params, cache, prev, cm )
10004 #  define GL_MATERIAL_FV2_CM( pname, params, cacheFront, cacheBack, prevFront, prevBack, cm ) _GLMaterialfvCachedR( pname, params, cacheFront, cacheBack, prevFront, prevBack, cm )
10005 # else
10006 #  define GL_MATERIAL_F( face, pname, param, cache, prev )                                    _GLMaterialfCached( face, pname, param, cache )
10007 #  define GL_MATERIAL_F2( pname, param, cacheFront, cacheBack, prevFront, prevBack )          _GLMaterialfCached( pname, param, cacheFront, cacheBack )
10008 #  define GL_MATERIAL_FV( face, pname, params, cache, prev )                                  _GLMaterialfvCached( face, pname, params, cache )
10009 #  define GL_MATERIAL_FV2( pname, params, cacheFront, cacheBack, prevFront, prevBack )        _GLMaterialfvCached( pname, params, cacheFront, cacheBack )
10010 #  define GL_MATERIAL_FV_CM( face, pname, params, cache, prev, cm )                           _GLMaterialfvCached( face, pname, params, cache, cm )
10011 #  define GL_MATERIAL_FV2_CM( pname, params, cacheFront, cacheBack, prevFront, prevBack, cm ) _GLMaterialfvCached( pname, params, cacheFront, cacheBack, cm )
10012 # endif
10013 #else
10014 # define GL_MATERIAL_F( face, pname, param, cache, prevFront )                                _GLMaterialf( face, pname, param )
10015 # define GL_MATERIAL_F2( pname, param, cacheFront, cacheBack, prevFront, prevBack )           _GLMaterialf( GL_FRONT_AND_BACK, pname, param )
10016 # define GL_MATERIAL_FV( face, pname, params, cache, prev )                                   _GLMaterialfv( face, pname, params )
10017 # define GL_MATERIAL_FV2( pname, params, cacheFront, cacheBack, prevFront, prevBack )         _GLMaterialfv( GL_FRONT_AND_BACK, pname, params )
10018 # define GL_MATERIAL_FV_CM( face, pname, params, cache, prev, cm )                            _GLMaterialfv( face, pname, params )
10019 # define GL_MATERIAL_FV2_CM( pname, params, cacheFront, cacheBack, prevFront, prevBack, cm )  _GLMaterialfv( GL_FRONT_AND_BACK, pname, params )
10020 #endif
10021
10022 #if defined(GL_SUPPORT_RESET)
10023 inline void _GLResetMaterialf( GLenum pname, GLfloat defParam, GLfloat * cacheFront, GLfloat * cacheBack, GLfloat * prevFront, GLfloat * prevBack )
10024 {
10025   if ( *prevFront == *prevBack )
10026   {
10027     _GLMaterialfCachedR( pname, *prevFront, cacheFront, cacheBack, prevFront, prevBack );
10028   }
10029   else
10030   {
10031     _GLMaterialfCachedR( GL_FRONT, pname, *prevFront, cacheFront, prevFront );
10032     _GLMaterialfCachedR( GL_BACK, pname, *prevBack, cacheBack, prevBack );
10033   }
10034 }
10035 inline void _GLResetMaterialfv( GLenum face, GLenum pname, GLfloat * cache, GLfloat * prev )
10036 {
10037   GLfloat tmp[4];
10038   memcpy( &tmp[0], prev, 4*sizeof(GLfloat) );
10039   _GLMaterialfvCachedR( face, pname, tmp, cache, prev );
10040 }
10041 inline void _GLResetMaterialfv( GLenum pname, GLfloat * cacheFront, GLfloat * cacheBack, GLfloat * prevFront, GLfloat * prevBack )
10042 {
10043   if ( equal4fv( prevFront, prevBack ) )
10044   {
10045     GLfloat tmp[4];
10046     memcpy( &tmp[0], prevFront, 4*sizeof(GLfloat) );
10047     _GLMaterialfvCachedR( pname, tmp, cacheFront, cacheBack, prevFront, prevBack );
10048   }
10049   else
10050   {
10051     _GLResetMaterialfv( GL_FRONT, pname, cacheFront, prevFront );
10052     _GLResetMaterialfv( GL_BACK, pname, cacheBack, prevBack );
10053   }
10054 }
10055 inline void _GLResetMaterialfv( GLenum face, GLenum pname, const GLfloat * defParams, GLfloat * cache, GLfloat * prev, bool colorMaterial )
10056 {
10057   if ( colorMaterial )
10058   {
10059     _GLMaterialfv( face, pname, defParams );
10060   }
10061   else
10062   {
10063     _GLResetMaterialfv( face, pname, cache, prev );
10064   }
10065 }
10066 inline void _GLResetMaterialfv( GLenum pname, const GLfloat * defParams, GLfloat * cacheFront, GLfloat * cacheBack, GLfloat * prevFront, GLfloat * prevBack, bool colorMaterial )
10067 {
10068   if ( colorMaterial )
10069   {
10070     _GLMaterialfv( GL_FRONT_AND_BACK, pname, defParams );
10071   }
10072   else
10073   {
10074     _GLResetMaterialfv( pname, cacheFront, cacheBack, prevFront, prevBack );
10075   }
10076 }
10077 # define GL_RESET_MATERIAL_F( face, pname, defParam, cache, prev )                                    _GLMaterialfCachedR( face, pname, *prev, cache, prev )
10078 # define GL_RESET_MATERIAL_F2( pname, defParam, cacheFront, cacheBack, prevFront, prevBack )          _GLResetMaterialf( pname, defParam, cacheFront, cacheBack, prevFront, prevBack )
10079 # define GL_RESET_MATERIAL_FV( face, pname, defParams, cache, prev )                                  _GLResetMaterialfv( face, pname, cache, prev )
10080 # define GL_RESET_MATERIAL_FV2( pname, defParams, cacheFront, cacheBack, prevFront, prevBack )        _GLResetMaterialfv( pname, cacheFront, cacheBack, prevFront, prevBack )
10081 # define GL_RESET_MATERIAL_FV_CM( face, pname, defParams, cache, prev, cm )                           _GLResetMaterialfv( face, pname, defParams, cache, prev, cm )
10082 # define GL_RESET_MATERIAL_FV2_CM( pname, defParams, cacheFront, cacheBack, prevFront, prevBack, cm ) _GLResetMaterialfv( pname, defParams, cacheFront, cacheBack, prevFront, prevBack, cm )
10083 #else
10084 # define GL_RESET_MATERIAL_F( face, pname, defParam, cache, prev )                                    _GLMaterialf( face, pname, defParam )
10085 # define GL_RESET_MATERIAL_F2( pname, defParam, cacheFront, cacheBack, prevFront, prevBack )          _GLMaterialf( GL_FRONT_AND_BACK, pname, defParam )
10086 # define GL_RESET_MATERIAL_FV( face, pname, defParams, cache, prev )                                  _GLMaterialfv( face, pname, defParams )
10087 # define GL_RESET_MATERIAL_FV2( pname, defParams, cacheFront, cacheBack, prevFront, prevBack )        _GLMaterialfv( GL_FRONT_AND_BACK, pname, defParams )
10088 # define GL_RESET_MATERIAL_FV_CM( face, pname, defParams, cache, prev, cm )                           _GLMaterialfv( face, pname, defParams )
10089 # define GL_RESET_MATERIAL_FV2_CM( pname, defParams, cacheFront, cacheBack, prevFront, prevBack, cm ) _GLMaterialfv( GL_FRONT_AND_BACK, pname, defParams )
10090 #endif
10091 #endif // DOXYGEN_IGNORE
10092
10094
10096 inline  void  GLMaterialShininessBack( GLfloat param )
10097 {
10098   GL_MATERIAL_F( GL_BACK, GL_SHININESS, param
10099                , &glContext()->m_lightingAttributes.m_materialShininess[NVSG_CACHE_BACK]
10100                , &glContext()->m_previousAttributes.m_materialShininess[NVSG_CACHE_BACK] );
10101 }
10102
10107 inline void GLResetMaterialShininessBack()
10108 {
10109   GL_RESET_MATERIAL_F( GL_BACK, GL_SHININESS, 0.0f
10110                      , &glContext()->m_lightingAttributes.m_materialShininess[NVSG_CACHE_BACK]
10111                      , &glContext()->m_previousAttributes.m_materialShininess[NVSG_CACHE_BACK] );
10112 }
10113
10115
10117 inline  void  GLMaterialShininessFront( GLfloat param )
10118 {
10119   GL_MATERIAL_F( GL_FRONT, GL_SHININESS, param
10120                , &glContext()->m_lightingAttributes.m_materialShininess[NVSG_CACHE_FRONT]
10121                , &glContext()->m_previousAttributes.m_materialShininess[NVSG_CACHE_FRONT] );
10122 }
10123
10128 inline void GLResetMaterialShininessFront()
10129 {
10130   GL_RESET_MATERIAL_F( GL_FRONT, GL_SHININESS, 0.0f
10131                      , &glContext()->m_lightingAttributes.m_materialShininess[NVSG_CACHE_FRONT]
10132                      , &glContext()->m_previousAttributes.m_materialShininess[NVSG_CACHE_FRONT] );
10133 }
10134
10136
10138 inline  void  GLMaterialShininessFrontAndBack( GLfloat param )
10139 {
10140   GL_MATERIAL_F2( GL_SHININESS, param
10141                 , &glContext()->m_lightingAttributes.m_materialShininess[NVSG_CACHE_FRONT]
10142                 , &glContext()->m_lightingAttributes.m_materialShininess[NVSG_CACHE_BACK]
10143                 , &glContext()->m_previousAttributes.m_materialShininess[NVSG_CACHE_FRONT]
10144                 , &glContext()->m_previousAttributes.m_materialShininess[NVSG_CACHE_BACK] );
10145 }
10146
10151 inline void GLResetMaterialShininessFrontAndBack()
10152 {
10153   GL_RESET_MATERIAL_F2( GL_SHININESS, 0.0f
10154                       , &glContext()->m_lightingAttributes.m_materialShininess[NVSG_CACHE_FRONT]
10155                       , &glContext()->m_lightingAttributes.m_materialShininess[NVSG_CACHE_BACK]
10156                       , &glContext()->m_previousAttributes.m_materialShininess[NVSG_CACHE_FRONT]
10157                       , &glContext()->m_previousAttributes.m_materialShininess[NVSG_CACHE_BACK] );
10158 }
10159
10161
10163 inline  void  GLMaterialShininess( GLenum face, GLfloat param )
10164 {
10165 #if defined( GL_CACHING )
10166   switch( face )
10167   {
10168     case GL_BACK :
10169       GLMaterialShininessBack( param );
10170       break;
10171     case GL_FRONT :
10172       GLMaterialShininessFront( param );
10173       break;
10174     case GL_FRONT_AND_BACK :
10175       GLMaterialShininessFrontAndBack( param );
10176       break;
10177     default :
10178       NVSG_ASSERT( false );
10179       break;
10180   }
10181 #else
10182   GLMaterialf( face, GL_SHININESS, param );
10183 #endif
10184 }
10185
10187
10189 inline  void  GLMaterialAmbientBack( const GLfloat *params )
10190 {
10191   GL_MATERIAL_FV_CM( GL_BACK, GL_AMBIENT, params
10192                    , &glContext()->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_BACK][0]
10193                    , &glContext()->m_previousAttributes.m_materialAmbient[NVSG_CACHE_BACK][0]
10194                    , !!glContext()->m_lightingAttributes.m_colorMaterial );
10195 }
10196
10201 inline void GLResetMaterialAmbientBack()
10202 {
10203   static nvmath::Vec4f ma(0.2f,0.2f,0.2f,1.0f);
10204   GL_RESET_MATERIAL_FV_CM( GL_BACK, GL_AMBIENT, &ma[0]
10205                          , &glContext()->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_BACK][0]
10206                          , &glContext()->m_previousAttributes.m_materialAmbient[NVSG_CACHE_BACK][0]
10207                          , !!glContext()->m_lightingAttributes.m_colorMaterial );
10208 }
10209
10211
10213 inline  void  GLMaterialAmbientFront( const GLfloat *params )
10214 {
10215   GL_MATERIAL_FV_CM( GL_FRONT, GL_AMBIENT, params
10216                    , &glContext()->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0]
10217                    , &glContext()->m_previousAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0]
10218                    , !!glContext()->m_lightingAttributes.m_colorMaterial );
10219 }
10220
10225 inline void GLResetMaterialAmbientFront()
10226 {
10227   static nvmath::Vec4f ma(0.2f,0.2f,0.2f,1.0f);
10228   GL_RESET_MATERIAL_FV_CM( GL_FRONT, GL_AMBIENT, &ma[0]
10229                          , &glContext()->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0]
10230                          , &glContext()->m_previousAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0]
10231                          , !!glContext()->m_lightingAttributes.m_colorMaterial );
10232 }
10233
10235
10237 inline  void  GLMaterialAmbientFrontAndBack( const GLfloat *params )
10238 {
10239   GL_MATERIAL_FV2_CM( GL_AMBIENT, params
10240                     , &glContext()->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0]
10241                     , &glContext()->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_BACK][0]
10242                     , &glContext()->m_previousAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0]
10243                     , &glContext()->m_previousAttributes.m_materialAmbient[NVSG_CACHE_BACK][0]
10244                     , !!glContext()->m_lightingAttributes.m_colorMaterial );
10245 }
10246
10252 inline void GLResetMaterialAmbientFrontAndBack()
10253 {
10254   static nvmath::Vec4f ma(0.2f,0.2f,0.2f,1.0f);
10255   GL_RESET_MATERIAL_FV2_CM( GL_AMBIENT, &ma[0]
10256                           , &glContext()->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0]
10257                           , &glContext()->m_lightingAttributes.m_materialAmbient[NVSG_CACHE_BACK][0]
10258                           , &glContext()->m_previousAttributes.m_materialAmbient[NVSG_CACHE_FRONT][0]
10259                           , &glContext()->m_previousAttributes.m_materialAmbient[NVSG_CACHE_BACK][0]
10260                           , !!glContext()->m_lightingAttributes.m_colorMaterial );
10261 }
10262
10264
10266 inline  void  GLMaterialAmbient( GLenum face, const GLfloat *params )
10267 {
10268 #if defined( GL_CACHING )
10269   switch( face )
10270   {
10271     case GL_BACK :
10272       GLMaterialAmbientBack( params );
10273       break;
10274     case GL_FRONT :
10275       GLMaterialAmbientFront( params );
10276       break;
10277     case GL_FRONT_AND_BACK :
10278       GLMaterialAmbientFrontAndBack( params );
10279       break;
10280     default :
10281       NVSG_ASSERT( false );
10282       break;
10283   }
10284 #else
10285   GLMaterialfv( face, GL_AMBIENT, params );
10286 #endif
10287 }
10288
10290
10292 inline  void  GLMaterialDiffuseBack( const GLfloat *params )
10293 {
10294   GL_MATERIAL_FV_CM( GL_BACK, GL_DIFFUSE, params
10295                    , &glContext()->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0]
10296                    , &glContext()->m_previousAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0]
10297                    , !!glContext()->m_lightingAttributes.m_colorMaterial );
10298 }
10299
10304 inline void GLResetMaterialDiffuseBack()
10305 {
10306   static nvmath::Vec4f md(0.8f,0.8f,0.8f,1.0f);
10307   GL_RESET_MATERIAL_FV_CM( GL_BACK, GL_DIFFUSE, &md[0]
10308                           , &glContext()->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0]
10309                           , &glContext()->m_previousAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0]
10310                           , !!glContext()->m_lightingAttributes.m_colorMaterial );
10311 }
10312
10314
10316 inline  void  GLMaterialDiffuseFront( const GLfloat *params )
10317 {
10318   GL_MATERIAL_FV_CM( GL_FRONT, GL_DIFFUSE, params
10319                    , &glContext()->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0]
10320                    , &glContext()->m_previousAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0]
10321                    , !!glContext()->m_lightingAttributes.m_colorMaterial );
10322 }
10323
10328 inline void GLResetMaterialDiffuseFront()
10329 {
10330   static nvmath::Vec4f md(0.8f,0.8f,0.8f,1.0f);
10331   GL_RESET_MATERIAL_FV_CM( GL_FRONT, GL_DIFFUSE, &md[0]
10332                          , &glContext()->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0]
10333                          , &glContext()->m_previousAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0]
10334                          , !!glContext()->m_lightingAttributes.m_colorMaterial );
10335 }
10336
10338
10340 inline  void  GLMaterialDiffuseFrontAndBack( const GLfloat *params )
10341 {
10342   GL_MATERIAL_FV2_CM( GL_DIFFUSE, params
10343                     , &glContext()->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0]
10344                     , &glContext()->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0]
10345                     , &glContext()->m_previousAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0]
10346                     , &glContext()->m_previousAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0]
10347                     , !!glContext()->m_lightingAttributes.m_colorMaterial );
10348 }
10349
10355 inline void GLResetMaterialDiffuseFrontAndBack()
10356 {
10357   static nvmath::Vec4f md(0.8f,0.8f,0.8f,1.0f);
10358   GL_RESET_MATERIAL_FV2_CM( GL_DIFFUSE, &md[0]
10359                           , &glContext()->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0]
10360                           , &glContext()->m_lightingAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0]
10361                           , &glContext()->m_previousAttributes.m_materialDiffuse[NVSG_CACHE_FRONT][0]
10362                           , &glContext()->m_previousAttributes.m_materialDiffuse[NVSG_CACHE_BACK][0]
10363                           , !!glContext()->m_lightingAttributes.m_colorMaterial );
10364 }
10365
10367
10369 inline  void  GLMaterialDiffuse( GLenum face, const GLfloat *params )
10370 {
10371 #if defined( GL_CACHING )
10372   switch( face )
10373   {
10374     case GL_BACK :
10375       GLMaterialDiffuseBack( params );
10376       break;
10377     case GL_FRONT :
10378       GLMaterialDiffuseFront( params );
10379       break;
10380     case GL_FRONT_AND_BACK :
10381       GLMaterialDiffuseFrontAndBack( params );
10382       break;
10383     default :
10384       NVSG_ASSERT( false );
10385       break;
10386   }
10387 #else
10388   GLMaterialfv( face, GL_DIFFUSE, params );
10389 #endif
10390 }
10391
10393
10395 inline  void  GLMaterialEmissionBack( const GLfloat *params )
10396 {
10397   GL_MATERIAL_FV( GL_BACK, GL_EMISSION, params
10398                 , &glContext()->m_lightingAttributes.m_materialEmission[NVSG_CACHE_BACK][0]
10399                 , &glContext()->m_previousAttributes.m_materialEmission[NVSG_CACHE_BACK][0] );
10400 }
10401
10406 inline void GLResetMaterialEmissionBack()
10407 {
10408   static nvmath::Vec4f me(0.0f,0.0f,0.0f,1.0f);
10409   GL_RESET_MATERIAL_FV( GL_BACK, GL_EMISSION, &me[0]
10410                       , &glContext()->m_lightingAttributes.m_materialEmission[NVSG_CACHE_BACK][0]
10411                       , &glContext()->m_previousAttributes.m_materialEmission[NVSG_CACHE_BACK][0] );
10412 }
10413
10415
10417 inline  void  GLMaterialEmissionFront( const GLfloat *params )
10418 {
10419   GL_MATERIAL_FV( GL_FRONT, GL_EMISSION, params
10420                 , &glContext()->m_lightingAttributes.m_materialEmission[NVSG_CACHE_FRONT][0]
10421                 , &glContext()->m_previousAttributes.m_materialEmission[NVSG_CACHE_FRONT][0] );
10422 }
10423
10428 inline void GLResetMaterialEmissionFront()
10429 {
10430   static nvmath::Vec4f me(0.0f,0.0f,0.0f,1.0f);
10431   GL_RESET_MATERIAL_FV( GL_FRONT, GL_EMISSION, &me[0]
10432                       , &glContext()->m_lightingAttributes.m_materialEmission[NVSG_CACHE_FRONT][0]
10433                       , &glContext()->m_previousAttributes.m_materialEmission[NVSG_CACHE_FRONT][0] );
10434 }
10435
10437
10439 inline  void  GLMaterialEmissionFrontAndBack( const GLfloat *params )
10440 {
10441   GL_MATERIAL_FV2( GL_EMISSION, params
10442                  , &glContext()->m_lightingAttributes.m_materialEmission[NVSG_CACHE_FRONT][0]
10443                  , &glContext()->m_lightingAttributes.m_materialEmission[NVSG_CACHE_BACK][0]
10444                  , &glContext()->m_previousAttributes.m_materialEmission[NVSG_CACHE_FRONT][0]
10445                  , &glContext()->m_previousAttributes.m_materialEmission[NVSG_CACHE_BACK][0] );
10446 }
10447
10452 inline void GLResetMaterialEmissionFrontAndBack()
10453 {
10454   static nvmath::Vec4f me(0.0f,0.0f,0.0f,1.0f);
10455   GL_RESET_MATERIAL_FV2( GL_EMISSION, &me[0]
10456                        , &glContext()->m_lightingAttributes.m_materialEmission[NVSG_CACHE_FRONT][0]
10457                        , &glContext()->m_lightingAttributes.m_materialEmission[NVSG_CACHE_BACK][0]
10458                        , &glContext()->m_previousAttributes.m_materialEmission[NVSG_CACHE_FRONT][0]
10459                        , &glContext()->m_previousAttributes.m_materialEmission[NVSG_CACHE_BACK][0] );
10460 }
10461
10463
10465 inline  void  GLMaterialEmission( GLenum face, const GLfloat *params )
10466 {
10467 #if defined( GL_CACHING )
10468   switch( face )
10469   {
10470     case GL_BACK :
10471       GLMaterialEmissionBack( params );
10472       break;
10473     case GL_FRONT :
10474       GLMaterialEmissionFront( params );
10475       break;
10476     case GL_FRONT_AND_BACK :
10477       GLMaterialEmissionFrontAndBack( params );
10478       break;
10479     default :
10480       NVSG_ASSERT( false );
10481       break;
10482   }
10483 #else
10484   GLMaterialfv( face, GL_EMISSION, params );
10485 #endif
10486 }
10487
10489
10491 inline  void  GLMaterialSpecularBack( const GLfloat *params )
10492 {
10493   GL_MATERIAL_FV( GL_BACK, GL_SPECULAR, params
10494                 , &glContext()->m_lightingAttributes.m_materialSpecular[NVSG_CACHE_BACK][0]
10495                 , &glContext()->m_previousAttributes.m_materialSpecular[NVSG_CACHE_BACK][0] );
10496 }
10497
10502 inline void GLResetMaterialSpecularBack()
10503 {
10504   static nvmath::Vec4f ms(0.0f,0.0f,0.0f,1.0f);
10505   GL_RESET_MATERIAL_FV( GL_BACK, GL_SPECULAR, &ms[0]
10506                       , &glContext()->m_lightingAttributes.m_materialSpecular[NVSG_CACHE_BACK][0]
10507                       , &glContext()->m_previousAttributes.m_materialSpecular[NVSG_CACHE_BACK][0] );
10508 }
10509
10511
10513 inline  void  GLMaterialSpecularFront( const GLfloat *params )
10514 {
10515   GL_MATERIAL_FV( GL_FRONT, GL_SPECULAR, params
10516                 , &glContext()->m_lightingAttributes.m_materialSpecular[NVSG_CACHE_FRONT][0]
10517                 , &glContext()->m_previousAttributes.m_materialSpecular[NVSG_CACHE_FRONT][0] );
10518 }
10519
10524 inline void GLResetMaterialSpecularFront()
10525 {
10526   static nvmath::Vec4f ms(0.0f,0.0f,0.0f,1.0f);
10527   GL_RESET_MATERIAL_FV( GL_FRONT, GL_SPECULAR, &ms[0]
10528                       , &glContext()->m_lightingAttributes.m_materialSpecular[NVSG_CACHE_FRONT][0]
10529                       , &glContext()->m_previousAttributes.m_materialSpecular[NVSG_CACHE_FRONT][0] );
10530 }
10531
10533
10535 inline  void  GLMaterialSpecularFrontAndBack( const GLfloat *params )
10536 {
10537   GL_MATERIAL_FV2( GL_SPECULAR, params
10538                  , &glContext()->m_lightingAttributes.m_materialSpecular[NVSG_CACHE_FRONT][0]
10539                  , &glContext()->m_lightingAttributes.m_materialSpecular[NVSG_CACHE_BACK][0]
10540                  , &glContext()->m_previousAttributes.m_materialSpecular[NVSG_CACHE_FRONT][0]
10541                  , &glContext()->m_previousAttributes.m_materialSpecular[NVSG_CACHE_BACK][0] );
10542 }
10543
10548 inline void GLResetMaterialSpecularFrontAndBack()
10549 {
10550   static nvmath::Vec4f ms(0.0f,0.0f,0.0f,1.0f);
10551   GL_RESET_MATERIAL_FV2( GL_SPECULAR, &ms[0]
10552                        , &glContext()->m_lightingAttributes.m_materialSpecular[NVSG_CACHE_FRONT][0]
10553                        , &glContext()->m_lightingAttributes.m_materialSpecular[NVSG_CACHE_BACK][0]
10554                        , &glContext()->m_previousAttributes.m_materialSpecular[NVSG_CACHE_FRONT][0]
10555                        , &glContext()->m_previousAttributes.m_materialSpecular[NVSG_CACHE_BACK][0] );
10556 }
10557
10559
10561 inline  void  GLMaterialSpecular( GLenum face, const GLfloat *params )
10562 {
10563 #if defined( GL_CACHING )
10564   switch( face )
10565   {
10566     case GL_BACK :
10567       GLMaterialSpecularBack( params );
10568       break;
10569     case GL_FRONT :
10570       GLMaterialSpecularFront( params );
10571       break;
10572     case GL_FRONT_AND_BACK :
10573       GLMaterialSpecularFrontAndBack( params );
10574       break;
10575     default :
10576       NVSG_ASSERT( false );
10577       break;
10578   }
10579 #else
10580   GLMaterialfv( face, GL_SPECULAR, params );
10581 #endif
10582 }
10583
10585
10586 inline  void  GLMaterialf( GLenum face, GLenum pname, GLfloat param )
10587 {
10588 #if defined( GL_CACHING )
10589   switch( pname )
10590   {
10591     case GL_SHININESS :
10592       GLMaterialShininess( face, param );
10593       break;
10594     default :
10595       _GLMaterialf( face, pname, param );
10596       break;
10597   }
10598 #else
10599   _GLMaterialf( face, pname, param );
10600 #endif
10601 }
10602
10604
10605 inline  void  GLMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
10606 {
10607 #if defined( GL_CACHING )
10608   switch( pname )
10609   {
10610     case GL_AMBIENT :
10611       GLMaterialAmbient( face, params );
10612       break;
10613     case GL_DIFFUSE :
10614       GLMaterialDiffuse( face, params );
10615       break;
10616     case GL_EMISSION :
10617       GLMaterialEmission( face, params );
10618       break;
10619     case GL_SPECULAR :
10620       GLMaterialSpecular( face, params );
10621       break;
10622     case GL_SHININESS :
10623       GLMaterialShininess( face, params[0] );
10624       break;
10625     default :
10626       _GLMaterialfv( face, pname, params );
10627       break;
10628   }
10629 #else
10630   _GLMaterialfv( face, pname, params );
10631 #endif
10632 }
10633
10635
10636 inline  void  GLMateriali( GLenum face, GLenum pname, GLint param )
10637 {
10638 #if defined( GL_CACHING )
10639   switch( pname )
10640   {
10641     case GL_SHININESS :
10642       GLMaterialShininess( face, (GLfloat)param );
10643       break;
10644     default :
10645       _GLMateriali( face, pname, param );
10646       break;
10647   }
10648 #else
10649   _GLMateriali( face, pname, param );
10650 #endif
10651 }
10652
10654
10655 inline  void  GLMaterialiv( GLenum face, GLenum pname, const GLint *params )
10656 {
10657 #if defined( GL_CACHING )
10658   GLfloat fParams[4];
10659   switch( pname )
10660   {
10661     case GL_AMBIENT :
10662       GLintToGLfloat( params, fParams );
10663       GLMaterialAmbient( face, fParams );
10664       break;
10665     case GL_DIFFUSE :
10666       GLintToGLfloat( params, fParams );
10667       GLMaterialDiffuse( face, fParams );
10668       break;
10669     case GL_EMISSION :
10670       GLintToGLfloat( params, fParams );
10671       GLMaterialEmission( face, fParams );
10672       break;
10673     case GL_SPECULAR :
10674       GLintToGLfloat( params, fParams );
10675       GLMaterialSpecular( face, fParams );
10676       break;
10677     case GL_SHININESS :
10678       GLMaterialShininess( face, (GLfloat)params[0] );
10679       break;
10680     default :
10681       _GLMaterialiv( face, pname, params );
10682       break;
10683   }
10684 #else
10685   _GLMaterialiv( face, pname, params );
10686 #endif
10687 }
10688
10690
10691 inline  void  GLMatrixMode( GLenum mode )
10692 {
10693 #if defined( GL_CACHING )
10694   GLContext * ctx = glContext();
10695   if ( ctx->m_transformAttributes.m_matrixMode != mode )
10696 #endif
10697   {
10698     NVSG_GL_STATS_MATRIX_MODE( mode );
10699     glMatrixMode( mode );
10700     ASSERT_GL_NO_ERROR;
10701 #if defined( GL_CACHING )
10702     ctx->m_transformAttributes.m_matrixMode = mode;
10703 #endif
10704   }
10705 }
10706
10708
10709 inline  void  GLMinmax( GLenum target, GLenum internalformat, GLboolean sink )
10710 {
10711   NVSG_GL_STATS_FCT_COUNT();
10712   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMinmax );
10713   glContext()->m_glFunctions->glMinmax( target, internalformat, sink );
10714   ASSERT_GL_NO_ERROR;
10715 }
10716
10718
10719 inline  void  GLMultiTexCoord1d( GLenum target, GLdouble s )
10720 {
10721   NVSG_GL_STATS_FCT_COUNT();
10722   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1d );
10723   glContext()->m_glFunctions->glMultiTexCoord1d( target, s );
10724   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10725 }
10726
10728
10729 inline  void  GLMultiTexCoord1dv( GLenum target, const GLdouble *v )
10730 {
10731   NVSG_GL_STATS_FCT_COUNT();
10732   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1dv );
10733   glContext()->m_glFunctions->glMultiTexCoord1dv( target, v );
10734   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10735 }
10736
10738
10739 inline  void  GLMultiTexCoord1f( GLenum target, GLfloat s )
10740 {
10741   NVSG_GL_STATS_FCT_COUNT();
10742   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1f );
10743   glContext()->m_glFunctions->glMultiTexCoord1f( target, s );
10744   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10745 }
10746
10748
10749 inline  void  GLMultiTexCoord1fv( GLenum target, const GLfloat *v )
10750 {
10751   NVSG_GL_STATS_FCT_COUNT();
10752   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1fv );
10753   glContext()->m_glFunctions->glMultiTexCoord1fv( target, v );
10754   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10755 }
10756
10758
10759 inline  void  GLMultiTexCoord1h( GLenum target, GLhalf s )
10760 {
10761   NVSG_GL_STATS_FCT_COUNT();
10762   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1h );
10763   glContext()->m_glFunctions->glMultiTexCoord1h( target, s );
10764   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10765 }
10766
10768
10769 inline  void  GLMultiTexCoord1hv( GLenum target, const GLhalf *v )
10770 {
10771   NVSG_GL_STATS_FCT_COUNT();
10772   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1hv );
10773   glContext()->m_glFunctions->glMultiTexCoord1hv( target, v );
10774   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10775 }
10776
10778
10779 inline  void  GLMultiTexCoord1i( GLenum target, GLint s )
10780 {
10781   NVSG_GL_STATS_FCT_COUNT();
10782   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1i );
10783   glContext()->m_glFunctions->glMultiTexCoord1i( target, s );
10784   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10785 }
10786
10788
10789 inline  void  GLMultiTexCoord1iv( GLenum target, const GLint *v )
10790 {
10791   NVSG_GL_STATS_FCT_COUNT();
10792   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1iv );
10793   glContext()->m_glFunctions->glMultiTexCoord1iv( target, v );
10794   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10795 }
10796
10798
10799 inline  void  GLMultiTexCoord1s( GLenum target, GLshort s )
10800 {
10801   NVSG_GL_STATS_FCT_COUNT();
10802   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1s );
10803   glContext()->m_glFunctions->glMultiTexCoord1s( target, s );
10804   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10805 }
10806
10808
10809 inline  void  GLMultiTexCoord1sv( GLenum target, const GLshort *v )
10810 {
10811   NVSG_GL_STATS_FCT_COUNT();
10812   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord1sv );
10813   glContext()->m_glFunctions->glMultiTexCoord1sv( target, v );
10814   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10815 }
10816
10818
10819 inline  void  GLMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t )
10820 {
10821   NVSG_GL_STATS_FCT_COUNT();
10822   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2d );
10823   glContext()->m_glFunctions->glMultiTexCoord2d( target, s, t );
10824   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10825 }
10826
10828
10829 inline  void  GLMultiTexCoord2dv( GLenum target, const GLdouble *v )
10830 {
10831   NVSG_GL_STATS_FCT_COUNT();
10832   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2dv );
10833   glContext()->m_glFunctions->glMultiTexCoord2dv( target, v );
10834   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10835 }
10836
10838
10839 inline  void  GLMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t )
10840 {
10841   NVSG_GL_STATS_FCT_COUNT();
10842   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2f );
10843   glContext()->m_glFunctions->glMultiTexCoord2f( target, s, t );
10844   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10845 }
10846
10848
10849 inline  void  GLMultiTexCoord2fv( GLenum target, const GLfloat *v )
10850 {
10851   NVSG_GL_STATS_FCT_COUNT();
10852   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2fv );
10853   glContext()->m_glFunctions->glMultiTexCoord2fv( target, v );
10854   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10855 }
10856
10858
10859 inline  void  GLMultiTexCoord2h( GLenum target, GLhalf s, GLhalf t )
10860 {
10861   NVSG_GL_STATS_FCT_COUNT();
10862   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2h );
10863   glContext()->m_glFunctions->glMultiTexCoord2h( target, s, t );
10864   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10865 }
10866
10868
10869 inline  void  GLMultiTexCoord2hv( GLenum target, const GLhalf *v )
10870 {
10871   NVSG_GL_STATS_FCT_COUNT();
10872   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2hv );
10873   glContext()->m_glFunctions->glMultiTexCoord2hv( target, v );
10874   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10875 }
10876
10878
10879 inline  void  GLMultiTexCoord2i( GLenum target, GLint s, GLint t )
10880 {
10881   NVSG_GL_STATS_FCT_COUNT();
10882   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2i );
10883   glContext()->m_glFunctions->glMultiTexCoord2i( target, s, t );
10884   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10885 }
10886
10888
10889 inline  void  GLMultiTexCoord2iv( GLenum target, const GLint *v )
10890 {
10891   NVSG_GL_STATS_FCT_COUNT();
10892   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2iv );
10893   glContext()->m_glFunctions->glMultiTexCoord2iv( target, v );
10894   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10895 }
10896
10898
10899 inline  void  GLMultiTexCoord2s( GLenum target, GLshort s, GLshort t )
10900 {
10901   NVSG_GL_STATS_FCT_COUNT();
10902   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2s );
10903   glContext()->m_glFunctions->glMultiTexCoord2s( target, s, t );
10904   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10905 }
10906
10908
10909 inline  void  GLMultiTexCoord2sv( GLenum target, const GLshort *v )
10910 {
10911   NVSG_GL_STATS_FCT_COUNT();
10912   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2sv );
10913   glContext()->m_glFunctions->glMultiTexCoord2sv( target, v );
10914   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10915 }
10916
10918
10919 inline  void  GLMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r )
10920 {
10921   NVSG_GL_STATS_FCT_COUNT();
10922   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3d );
10923   glContext()->m_glFunctions->glMultiTexCoord3d( target, s, t, r );
10924   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10925 }
10926
10928
10929 inline  void  GLMultiTexCoord3dv( GLenum target, const GLdouble *v )
10930 {
10931   NVSG_GL_STATS_FCT_COUNT();
10932   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3dv );
10933   glContext()->m_glFunctions->glMultiTexCoord3dv( target, v );
10934   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10935 }
10936
10938
10939 inline  void  GLMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r )
10940 {
10941   NVSG_GL_STATS_FCT_COUNT();
10942   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3f );
10943   glContext()->m_glFunctions->glMultiTexCoord3f( target, s, t, r );
10944   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10945 }
10946
10948
10949 inline  void  GLMultiTexCoord3fv( GLenum target, const GLfloat *v )
10950 {
10951   NVSG_GL_STATS_FCT_COUNT();
10952   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3fv );
10953   glContext()->m_glFunctions->glMultiTexCoord3fv( target, v );
10954   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10955 }
10956
10958
10959 inline  void  GLMultiTexCoord3h( GLenum target, GLhalf s, GLhalf t, GLhalf r )
10960 {
10961   NVSG_GL_STATS_FCT_COUNT();
10962   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3h );
10963   glContext()->m_glFunctions->glMultiTexCoord3h( target, s, t, r );
10964   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10965 }
10966
10968
10969 inline  void  GLMultiTexCoord3hv( GLenum target, const GLhalf *v )
10970 {
10971   NVSG_GL_STATS_FCT_COUNT();
10972   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3hv );
10973   glContext()->m_glFunctions->glMultiTexCoord3hv( target, v );
10974   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10975 }
10976
10978
10979 inline  void  GLMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r )
10980 {
10981   NVSG_GL_STATS_FCT_COUNT();
10982   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3i );
10983   glContext()->m_glFunctions->glMultiTexCoord3i( target, s, t, r );
10984   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10985 }
10986
10988
10989 inline  void  GLMultiTexCoord3iv( GLenum target, const GLint *v )
10990 {
10991   NVSG_GL_STATS_FCT_COUNT();
10992   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3iv );
10993   glContext()->m_glFunctions->glMultiTexCoord3iv( target, v );
10994   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
10995 }
10996
10998
10999 inline  void  GLMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r )
11000 {
11001   NVSG_GL_STATS_FCT_COUNT();
11002   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3s );
11003   glContext()->m_glFunctions->glMultiTexCoord3s( target, s, t, r );
11004   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11005 }
11006
11008
11009 inline  void  GLMultiTexCoord3sv( GLenum target, const GLshort *v )
11010 {
11011   NVSG_GL_STATS_FCT_COUNT();
11012   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord3sv );
11013   glContext()->m_glFunctions->glMultiTexCoord3sv( target, v );
11014   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11015 }
11016
11018
11019 inline  void  GLMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
11020 {
11021   NVSG_GL_STATS_FCT_COUNT();
11022   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4d );
11023   glContext()->m_glFunctions->glMultiTexCoord4d( target, s, t, r, q );
11024   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11025 }
11026
11028
11029 inline  void  GLMultiTexCoord4dv( GLenum target, const GLdouble *v )
11030 {
11031   NVSG_GL_STATS_FCT_COUNT();
11032   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4dv );
11033   glContext()->m_glFunctions->glMultiTexCoord4dv( target, v );
11034   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11035 }
11036
11038
11039 inline  void  GLMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
11040 {
11041   NVSG_GL_STATS_FCT_COUNT();
11042   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4f );
11043   glContext()->m_glFunctions->glMultiTexCoord4f( target, s, t, r, q );
11044   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11045 }
11046
11048
11049 inline  void  GLMultiTexCoord4fv( GLenum target, const GLfloat *v )
11050 {
11051   NVSG_GL_STATS_FCT_COUNT();
11052   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4fv );
11053   glContext()->m_glFunctions->glMultiTexCoord4fv( target, v );
11054   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11055 }
11056
11058
11059 inline  void  GLMultiTexCoord4h( GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q )
11060 {
11061   NVSG_GL_STATS_FCT_COUNT();
11062   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4h );
11063   glContext()->m_glFunctions->glMultiTexCoord4h( target, s, t, r, q );
11064   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11065 }
11066
11068
11069 inline  void  GLMultiTexCoord4hv( GLenum target, const GLhalf *v )
11070 {
11071   NVSG_GL_STATS_FCT_COUNT();
11072   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4hv );
11073   glContext()->m_glFunctions->glMultiTexCoord4hv( target, v );
11074   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11075 }
11076
11078
11079 inline  void  GLMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q )
11080 {
11081   NVSG_GL_STATS_FCT_COUNT();
11082   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4i );
11083   glContext()->m_glFunctions->glMultiTexCoord4i( target, s, t, r, q );
11084   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11085 }
11086
11088
11089 inline  void  GLMultiTexCoord4iv( GLenum target, const GLint *v )
11090 {
11091   NVSG_GL_STATS_FCT_COUNT();
11092   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4iv );
11093   glContext()->m_glFunctions->glMultiTexCoord4iv( target, v );
11094   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11095 }
11096
11098
11099 inline  void  GLMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
11100 {
11101   NVSG_GL_STATS_FCT_COUNT();
11102   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4s );
11103   glContext()->m_glFunctions->glMultiTexCoord4s( target, s, t, r, q );
11104   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11105 }
11106
11108
11109 inline  void  GLMultiTexCoord4sv( GLenum target, const GLshort *v )
11110 {
11111   NVSG_GL_STATS_FCT_COUNT();
11112   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord4sv );
11113   glContext()->m_glFunctions->glMultiTexCoord4sv( target, v );
11114   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11115 }
11116
11118
11119 inline  void  GLMultiTexCoordPointer( GLenum target, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
11120 {
11121   NVSG_GL_STATS_FCT_COUNT();
11122   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoordPointer );
11123   glContext()->m_glFunctions->glMultiTexCoordPointer( target, size, type, stride, pointer );
11124   ASSERT_GL_NO_ERROR;
11125 }
11126
11128
11129 inline  void  GLMultMatrixd( const GLdouble *m )
11130 {
11131   NVSG_GL_STATS_MULT_MATRIXD( m );
11132 #if defined( GL_CACHING )
11133   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
11134   { // note: we have a texture matrix stack per unit
11135     _GLUpdateActiveTexture();
11136   }
11137 #endif
11138   glMultMatrixd( m );
11139   ASSERT_GL_NO_ERROR;
11140 }
11141
11143
11144 inline  void  GLMultMatrixf( const GLfloat *m )
11145 {
11146   NVSG_GL_STATS_MULT_MATRIXF( m );
11147 #if defined( GL_CACHING )
11148   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
11149   { // note: we have a texture matrix stack per unit
11150     _GLUpdateActiveTexture();
11151   }
11152 #endif
11153   glMultMatrixf( m );
11154   ASSERT_GL_NO_ERROR;
11155 }
11156
11158
11159 inline  void  GLMultTransposeMatrixd( const GLdouble *m )
11160 {
11161   NVSG_GL_STATS_MULT_MATRIXD( m );
11162 #if defined( GL_CACHING )
11163   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
11164   { // note: we have a texture matrix stack per unit
11165     _GLUpdateActiveTexture();
11166   }
11167 #endif
11168   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultTransposeMatrixd );
11169   glContext()->m_glFunctions->glMultTransposeMatrixd( m );
11170   ASSERT_GL_NO_ERROR;
11171 }
11172
11174
11175 inline  void  GLMultTransposeMatrixf( const GLfloat *m )
11176 {
11177   NVSG_GL_STATS_MULT_MATRIXF( m );
11178 #if defined( GL_CACHING )
11179   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
11180   { // note: we have a texture matrix stack per unit
11181     _GLUpdateActiveTexture();
11182   }
11183 #endif
11184   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultTransposeMatrixf );
11185   glContext()->m_glFunctions->glMultTransposeMatrixf( m );
11186   ASSERT_GL_NO_ERROR;
11187 }
11188
11190
11191 inline  void  GLNewList( GLuint list, GLenum mode )
11192 {
11193   NVSG_GL_STATS_NEW_LIST( list, mode );
11194   glNewList( list, mode );
11195   ASSERT_GL_NO_ERROR;
11196 }
11197
11199
11200 inline  void  GLNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
11201 {
11202   NVSG_GL_STATS_FCT_COUNT();
11203   glNormal3b( nx, ny, nz );
11204   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11205 }
11206
11208
11209 inline  void  GLNormal3bv( const GLbyte *v )
11210 {
11211   NVSG_GL_STATS_FCT_COUNT();
11212   glNormal3bv( v );
11213   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11214 }
11215
11217
11218 inline  void  GLNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
11219 {
11220   NVSG_GL_STATS_FCT_COUNT();
11221   glNormal3d( nx, ny, nz );
11222   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11223 }
11224
11226
11227 inline  void  GLNormal3dv( const GLdouble *v )
11228 {
11229   NVSG_GL_STATS_FCT_COUNT();
11230   glNormal3dv( v );
11231   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11232 }
11233
11235
11236 inline  void  GLNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
11237 {
11238   NVSG_GL_STATS_FCT_COUNT();
11239   glNormal3f( nx, ny, nz );
11240   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11241 }
11242
11244
11245 inline  void  GLNormal3fv( const GLfloat *v )
11246 {
11247   NVSG_GL_STATS_FCT_COUNT();
11248   glNormal3fv( v );
11249   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11250 }
11251
11253
11254 inline  void  GLNormal3h( GLhalf nx, GLhalf ny, GLhalf nz )
11255 {
11256   NVSG_GL_STATS_FCT_COUNT();
11257   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glNormal3h );
11258   glContext()->m_glFunctions->glNormal3h( nx, ny, nz );
11259   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11260 }
11261
11263
11264 inline  void  GLNormal3hv( const GLhalf *v )
11265 {
11266   NVSG_GL_STATS_FCT_COUNT();
11267   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glNormal3hv );
11268   glContext()->m_glFunctions->glNormal3hv( v );
11269   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11270 }
11271
11273
11274 inline  void  GLNormal3i( GLint nx, GLint ny, GLint nz )
11275 {
11276   NVSG_GL_STATS_FCT_COUNT();
11277   glNormal3i( nx, ny, nz );
11278   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11279 }
11280
11282
11283 inline  void  GLNormal3iv( const GLint *v )
11284 {
11285   NVSG_GL_STATS_FCT_COUNT();
11286   glNormal3iv( v );
11287   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11288 }
11289
11291
11292 inline  void  GLNormal3s( GLshort nx, GLshort ny, GLshort nz )
11293 {
11294   NVSG_GL_STATS_FCT_COUNT();
11295   glNormal3s( nx, ny, nz );
11296   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11297 }
11298
11300
11301 inline  void  GLNormal3sv( const GLshort *v )
11302 {
11303   NVSG_GL_STATS_FCT_COUNT();
11304   glNormal3sv( v );
11305   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
11306 }
11307
11309
11310 inline  void  GLNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
11311 {
11312   NVSG_GL_STATS_NORMAL_POINTER( type, stride, pointer );
11313   glNormalPointer( type, stride, pointer );
11314   ASSERT_GL_NO_ERROR;
11315 }
11316
11318
11319 inline  void  GLOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
11320 {
11321   NVSG_GL_STATS_ORTHO( left, right, bottom, top, zNear, zFar );
11322   glOrtho( left, right, bottom, top, zNear, zFar );
11323   ASSERT_GL_NO_ERROR;
11324 }
11325
11327
11328 inline  void  GLPassThrough( GLfloat token )
11329 {
11330   NVSG_GL_STATS_FCT_COUNT();
11331   glPassThrough( token );
11332   ASSERT_GL_NO_ERROR;
11333 }
11334
11336
11337 inline  void  GLPixelDataRange( GLenum target, GLsizei size, const GLvoid *pointer )
11338 {
11339   NVSG_GL_STATS_FCT_COUNT();
11340   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glPixelDataRange );
11341   glContext()->m_glFunctions->glPixelDataRange( target, size, pointer );
11342   ASSERT_GL_NO_ERROR;
11343 }
11344
11346
11347 inline  void  GLPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
11348 {
11349   NVSG_GL_STATS_FCT_COUNT();
11350   glPixelMapfv( map, mapsize, values );
11351   ASSERT_GL_NO_ERROR;
11352 }
11353
11355
11356 inline  void  GLPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values )
11357 {
11358   NVSG_GL_STATS_FCT_COUNT();
11359   glPixelMapuiv( map, mapsize, values );
11360   ASSERT_GL_NO_ERROR;
11361 }
11362
11364
11365 inline  void  GLPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values )
11366 {
11367   NVSG_GL_STATS_FCT_COUNT();
11368   glPixelMapusv( map, mapsize, values );
11369   ASSERT_GL_NO_ERROR;
11370 }
11371
11373
11374 inline  void  GLPixelStoref( GLenum pname, GLfloat param )
11375 {
11376   NVSG_GL_STATS_FCT_COUNT();
11377   glPixelStoref( pname, param );
11378   ASSERT_GL_NO_ERROR;
11379 }
11380
11382
11383 inline  void  GLPixelStorei( GLenum pname, GLint param )
11384 {
11385   NVSG_GL_STATS_FCT_COUNT();
11386   glPixelStorei( pname, param );
11387   ASSERT_GL_NO_ERROR;
11388 }
11389
11391
11392 inline  void  GLPixelTransferf( GLenum pname, GLfloat param )
11393 {
11394   NVSG_GL_STATS_FCT_COUNT();
11395   glPixelTransferf( pname, param );
11396   ASSERT_GL_NO_ERROR;
11397 }
11398
11400
11401 inline  void  GLPixelTransferi( GLenum pname, GLint param )
11402 {
11403   NVSG_GL_STATS_FCT_COUNT();
11404   glPixelTransferi( pname, param );
11405   ASSERT_GL_NO_ERROR;
11406 }
11407
11409
11410 inline  void  GLPixelZoom( GLfloat xfactor, GLfloat yfactor )
11411 {
11412   NVSG_GL_STATS_FCT_COUNT();
11413   glPixelZoom( xfactor, yfactor );
11414   ASSERT_GL_NO_ERROR;
11415 }
11416
11418
11419 inline  void  GLPointParameterf( GLenum pname, GLfloat param )
11420 {
11421   NVSG_GL_STATS_FCT_COUNT();
11422   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glPointParameterf );
11423   glContext()->m_glFunctions->glPointParameterf( pname, param );
11424   ASSERT_GL_NO_ERROR;
11425 }
11426
11428
11429 inline  void  GLPointParameterfv( GLenum pname, const GLfloat *params )
11430 {
11431   NVSG_GL_STATS_FCT_COUNT();
11432   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glPointParameterfv );
11433   glContext()->m_glFunctions->glPointParameterfv( pname, params );
11434   ASSERT_GL_NO_ERROR;
11435 }
11436
11438
11439 inline  void  GLPointParameteri( GLenum pname, GLint param )
11440 {
11441   NVSG_GL_STATS_FCT_COUNT();
11442   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glPointParameteri );
11443   glContext()->m_glFunctions->glPointParameteri( pname, param );
11444   ASSERT_GL_NO_ERROR;
11445 }
11446
11448
11449 inline  void  GLPointParameteriv( GLenum pname, const GLint *params )
11450 {
11451   NVSG_GL_STATS_FCT_COUNT();
11452   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glPointParameteriv );
11453   glContext()->m_glFunctions->glPointParameteriv( pname, params );
11454   ASSERT_GL_NO_ERROR;
11455 }
11456
11458
11459 inline  void  GLPointSize( GLfloat size )
11460 {
11461 #if defined( GL_CACHING )
11462   GLContext * ctx = glContext();
11463 # if defined(GL_SUPPORT_RESET)
11464   ctx->m_previousAttributes.m_pointSize = ctx->m_pointAttributes.m_size;
11465 # endif
11466   if ( !equalf(ctx->m_pointAttributes.m_size, size) )
11467   {
11468 # if !defined(NDEBUG)
11469     GLfloat f;
11470     glGetFloatv( GL_POINT_SIZE, &f );
11471     NVSG_ASSERT( equalf(ctx->m_pointAttributes.m_size, f) );
11472 # endif
11473 #endif
11474     NVSG_GL_STATS_POINT_SIZE( size );
11475     glPointSize( size );
11476     ASSERT_GL_NO_ERROR;
11477 #if defined( GL_CACHING )
11478     ctx->m_pointAttributes.m_size = size;
11479   }
11480 #endif
11481 }
11482
11487 inline void GLResetPointSize()
11488 {
11489 #if defined(GL_SUPPORT_RESET)
11490   GLPointSize( glContext()->m_previousAttributes.m_pointSize );
11491 #else
11492   GLPointSize( 1.0f );
11493 #endif
11494 }
11495
11497
11499 inline  void  GLPolygonModeBack( GLenum mode )
11500 {
11501   GLContext * ctx = glContext();
11502 #if defined( GL_CACHING )
11503 # if defined(GL_SUPPORT_RESET)
11504   ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_BACK] = ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_BACK];
11505 # endif
11506   if ( ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_BACK] != mode )
11507 #endif
11508   {
11509     if ( ! ctx->m_locks.m_polygonMode )
11510     {
11511 #if defined( GL_CACHING) && !defined( NDEBUG )
11512       GLint p[2];
11513       glGetIntegerv( GL_POLYGON_MODE, p );
11514       NVSG_ASSERT( ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_BACK] == p[1] );
11515 #endif
11516       _GLPolygonMode( GL_BACK, mode );
11517 #if defined( GL_CACHING )
11518       ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_BACK] = mode;
11519 #endif
11520     }
11521   }
11522 }
11523
11528 inline void GLResetPolygonModeBack()
11529 {
11530 #if defined(GL_SUPPORT_RESET)
11531   GLPolygonModeBack( glContext()->m_previousAttributes.m_rasterMode[NVSG_CACHE_BACK] );
11532 #else
11533   GLPolygonModeBack( GL_FILL );
11534 #endif
11535 }
11536
11538
11540 inline  void  GLPolygonModeFront( GLenum mode )
11541 {
11542   GLContext * ctx = glContext();
11543 #if defined( GL_CACHING )
11544 # if defined(GL_SUPPORT_RESET)
11545   ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_FRONT] = ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_FRONT];
11546 # endif
11547   if ( ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_FRONT] != mode )
11548 #endif
11549   {
11550     if ( ! ctx->m_locks.m_polygonMode )
11551     {
11552 #if defined( GL_CACHING ) && !defined( NDEBUG )
11553       GLint p[2];
11554       glGetIntegerv( GL_POLYGON_MODE, p );
11555       NVSG_ASSERT( ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_FRONT] == p[0] );
11556 #endif
11557       _GLPolygonMode( GL_FRONT, mode );
11558 #if defined( GL_CACHING )
11559       ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_FRONT] = mode;
11560 #endif
11561     }
11562   }
11563 }
11564
11569 inline void GLResetPolygonModeFront()
11570 {
11571 #if defined(GL_SUPPORT_RESET)
11572   GLPolygonModeFront( glContext()->m_previousAttributes.m_rasterMode[NVSG_CACHE_FRONT] );
11573 #else
11574   GLPolygonModeFront( GL_FILL );
11575 #endif
11576 }
11577
11579
11581 inline  void  GLPolygonModeFrontAndBack( GLenum mode )
11582 {
11583   GLContext * ctx = glContext();
11584 #if defined( GL_CACHING )
11585 # if defined(GL_SUPPORT_RESET)
11586   ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_FRONT] = ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_FRONT];
11587   ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_BACK] = ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_BACK];
11588 # endif
11589   if (    ( ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_FRONT] != mode )
11590       ||  ( ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_BACK] != mode ) )
11591 #endif
11592   {
11593     if ( ! ctx->m_locks.m_polygonMode )
11594     {
11595 #if defined( GL_CACHING ) && !defined( NDEBUG )
11596       GLint p[2];
11597       glGetIntegerv( GL_POLYGON_MODE, p );
11598       NVSG_ASSERT(    ( ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_BACK] == p[NVSG_CACHE_BACK] )
11599                   &&  ( ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_FRONT] == p[NVSG_CACHE_FRONT] ) );
11600 #endif
11601       _GLPolygonMode( GL_FRONT_AND_BACK, mode );
11602 #if defined( GL_CACHING )
11603       ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_BACK] = mode;
11604       ctx->m_polygonAttributes.m_rasterMode[NVSG_CACHE_FRONT] = mode;
11605 #endif
11606     }
11607   }
11608 }
11609
11614 inline void GLResetPolygonModeFrontAndBack()
11615 {
11616 #if defined(GL_SUPPORT_RESET)
11617   GLContext * ctx = glContext();
11618   if ( ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_FRONT] == ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_BACK] )
11619   {
11620     GLPolygonModeFrontAndBack( ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_FRONT] );
11621   }
11622   else
11623   {
11624     GLPolygonModeFront( ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_FRONT] );
11625     GLPolygonModeBack( ctx->m_previousAttributes.m_rasterMode[NVSG_CACHE_BACK] );
11626   }
11627 #else
11628   GLPolygonModeFrontAndBack( GL_FILL );
11629 #endif
11630 }
11631
11633
11634 inline  void  GLPolygonMode( GLenum face, GLenum mode )
11635 {
11636 #if defined( GL_CACHING )
11637   switch( face )
11638   {
11639     case GL_BACK :
11640       GLPolygonModeBack( mode );
11641       break;
11642     case GL_FRONT :
11643       GLPolygonModeFront( mode );
11644       break;
11645     case GL_FRONT_AND_BACK :
11646       GLPolygonModeFrontAndBack( mode );
11647       break;
11648     default :
11649       NVSG_ASSERT( false );
11650       break;
11651   }
11652 #else
11653   _GLPolygonMode( face, mode );
11654 #endif
11655 }
11656
11664 inline void GLPolygonModeLock( GLenum face, GLenum mode )
11665 {
11666   NVSG_ASSERT( ! glContext()->m_locks.m_polygonMode );
11667   GLPolygonMode( face, mode );
11668   glContext()->m_locks.m_polygonMode = true;
11669 }
11670
11676 inline void GLPolygonModeUnlock( GLenum face, GLenum mode )
11677 {
11678   glContext()->m_locks.m_polygonMode = false;
11679   GLPolygonMode( face, mode );
11680 }
11681
11683
11684 inline  void  GLPolygonOffset( GLfloat factor, GLfloat units )
11685 {
11686 #if defined( GL_CACHING )
11687   GLContext * ctx = glContext();
11688 # if defined(GL_SUPPORT_RESET)
11689   ctx->m_previousAttributes.m_polygonOffsetFactor = ctx->m_polygonAttributes.m_offsetFactor;
11690   ctx->m_previousAttributes.m_polygonOffsetBias   = ctx->m_polygonAttributes.m_offsetBias;
11691 # endif
11692   if (  !equalf(ctx->m_polygonAttributes.m_offsetFactor, factor)
11693      || !equalf(ctx->m_polygonAttributes.m_offsetBias, units) )
11694 #endif
11695   {
11696     NVSG_GL_STATS_POLYGON_OFFSET( factor, units );
11697     glPolygonOffset( factor, units );
11698     ASSERT_GL_NO_ERROR;
11699 #if defined( GL_CACHING )
11700     ctx->m_polygonAttributes.m_offsetFactor  = factor;
11701     ctx->m_polygonAttributes.m_offsetBias   = units;
11702 #endif
11703   }
11704 }
11705
11710 inline void GLResetPolygonOffset()
11711 {
11712 #if defined(GL_SUPPORT_RESET)
11713   GLContext * ctx = glContext();
11714   GLPolygonOffset( ctx->m_previousAttributes.m_polygonOffsetFactor
11715                  , ctx->m_previousAttributes.m_polygonOffsetBias );
11716 #else
11717   GLPolygonOffset( 0.0f, 0.0f );
11718 #endif
11719 }
11720
11722
11723 inline  void  GLPolygonStipple( const GLubyte *mask )
11724 {
11725   NVSG_GL_STATS_FCT_COUNT();
11726   glPolygonStipple( mask );
11727   ASSERT_GL_NO_ERROR;
11728 }
11729
11731
11735 inline  void  GLPopAttrib( void )
11736 {
11737   NVSG_GL_STATS_POP_ATTRIB();
11738   glPopAttrib();
11739   ASSERT_GL_NO_ERROR;
11740 #if defined( GL_CACHING )
11741   GLContext * ctx = glContext();
11742   GLbitfield mask = (GLbitfield)ctx->m_pushMasks.top();
11743   if ( mask == GL_ALL_ATTRIB_BITS )
11744   {
11745     ctx->m_colorBufferAttributes = ctx->m_colorBufferAttributesStack.top();
11746     ctx->m_colorBufferAttributesStack.pop();
11747     ctx->m_colorBufferEnableAttributes = ctx->m_colorBufferEnableAttributesStack.top();
11748     ctx->m_colorBufferEnableAttributesStack.pop();
11749     ctx->m_depthBufferAttributes = ctx->m_depthBufferAttributesStack.top();
11750     ctx->m_depthBufferAttributesStack.pop();
11751     ctx->m_depthBufferEnableAttributes = ctx->m_depthBufferEnableAttributesStack.top();
11752     ctx->m_depthBufferEnableAttributesStack.pop();
11753     ctx->m_evalAttributes = ctx->m_evalAttributesStack.top();
11754     ctx->m_evalAttributesStack.pop();
11755     ctx->m_fogAttributes = ctx->m_fogAttributesStack.top();
11756     ctx->m_fogAttributesStack.pop();
11757     ctx->m_fogEnableAttributes = ctx->m_fogEnableAttributesStack.top();
11758     ctx->m_fogEnableAttributesStack.pop();
11759     ctx->m_lightingAttributes = ctx->m_lightingAttributesStack.top();
11760     ctx->m_lightingAttributesStack.pop();
11761     ctx->m_lightingEnableAttributes = ctx->m_lightingEnableAttributesStack.top();
11762     ctx->m_lightingEnableAttributesStack.pop();
11763     ctx->m_lineAttributes = ctx->m_lineAttributesStack.top();
11764     ctx->m_lineAttributesStack.pop();
11765     ctx->m_lineEnableAttributes = ctx->m_lineEnableAttributesStack.top();
11766     ctx->m_lineEnableAttributesStack.pop();
11767     ctx->m_pointAttributes = ctx->m_pointAttributesStack.top();
11768     ctx->m_pointAttributesStack.pop();
11769     ctx->m_pointEnableAttributes = ctx->m_pointEnableAttributesStack.top();
11770     ctx->m_pointEnableAttributesStack.pop();
11771     ctx->m_polygonAttributes = ctx->m_polygonAttributesStack.top();
11772     ctx->m_polygonAttributesStack.pop();
11773     ctx->m_polygonEnableAttributes = ctx->m_polygonEnableAttributesStack.top();
11774     ctx->m_polygonEnableAttributesStack.pop();
11775     ctx->m_scissorAttributes = ctx->m_scissorAttributesStack.top();
11776     ctx->m_scissorAttributesStack.pop();
11777     ctx->m_scissorEnableAttributes = ctx->m_scissorEnableAttributesStack.top();
11778     ctx->m_scissorEnableAttributesStack.pop();
11779     ctx->m_stencilBufferAttributes = ctx->m_stencilBufferAttributesStack.top();
11780     ctx->m_stencilBufferAttributesStack.pop();
11781     ctx->m_stencilBufferEnableAttributes = ctx->m_stencilBufferEnableAttributesStack.top();
11782     ctx->m_stencilBufferEnableAttributesStack.pop();
11783     ctx->m_textureAttributes = ctx->m_textureAttributesStack.top();
11784     ctx->m_textureAttributesStack.pop();
11785     ctx->m_textureEnableAttributes = ctx->m_textureEnableAttributesStack.top();
11786     ctx->m_textureEnableAttributesStack.pop();
11787     ctx->m_transformAttributes = ctx->m_transformAttributesStack.top();
11788     ctx->m_transformAttributesStack.pop();
11789     ctx->m_transformEnableAttributes = ctx->m_transformEnableAttributesStack.top();
11790     ctx->m_transformEnableAttributesStack.pop();
11791     ctx->m_viewportAttributes = ctx->m_viewportAttributesStack.top();
11792     ctx->m_viewportAttributesStack.pop();
11793   }
11794   else
11795   {
11796     if ( mask & GL_COLOR_BUFFER_BIT )
11797     {
11798       ctx->m_colorBufferAttributes = ctx->m_colorBufferAttributesStack.top();
11799       ctx->m_colorBufferAttributesStack.pop();
11800     }
11801     if ( mask & GL_DEPTH_BUFFER_BIT )
11802     {
11803       ctx->m_depthBufferAttributes = ctx->m_depthBufferAttributesStack.top();
11804       ctx->m_depthBufferAttributesStack.pop();
11805     }
11806     if ( mask & ( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT ) )
11807     {
11808       ctx->m_colorBufferEnableAttributes = ctx->m_colorBufferEnableAttributesStack.top();
11809       ctx->m_colorBufferEnableAttributesStack.pop();
11810     }
11811     if ( mask & ( GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT ) )
11812     {
11813       ctx->m_depthBufferEnableAttributes = ctx->m_depthBufferEnableAttributesStack.top();
11814       ctx->m_depthBufferEnableAttributesStack.pop();
11815     }
11816     if ( mask & ( GL_ENABLE_BIT | GL_FOG_BIT ) )
11817     {
11818       ctx->m_fogEnableAttributes = ctx->m_fogEnableAttributesStack.top();
11819       ctx->m_fogEnableAttributesStack.pop();
11820     }
11821     if ( mask & ( GL_ENABLE_BIT | GL_LIGHTING_BIT ) )
11822     {
11823       ctx->m_lightingEnableAttributes = ctx->m_lightingEnableAttributesStack.top();
11824       ctx->m_lightingEnableAttributesStack.pop();
11825     }
11826     if ( mask & ( GL_ENABLE_BIT | GL_LINE_BIT ) )
11827     {
11828       ctx->m_lineEnableAttributes = ctx->m_lineEnableAttributesStack.top();
11829       ctx->m_lineEnableAttributesStack.pop();
11830     }
11831     if ( mask & ( GL_ENABLE_BIT | GL_POINT_BIT ) )
11832     {
11833       ctx->m_pointEnableAttributes = ctx->m_pointEnableAttributesStack.top();
11834       ctx->m_pointEnableAttributesStack.pop();
11835     }
11836     if ( mask & ( GL_ENABLE_BIT | GL_POLYGON_BIT ) )
11837     {
11838       ctx->m_polygonEnableAttributes = ctx->m_polygonEnableAttributesStack.top();
11839       ctx->m_polygonEnableAttributesStack.pop();
11840     }
11841     if ( mask & ( GL_ENABLE_BIT | GL_SCISSOR_BIT ) )
11842     {
11843       ctx->m_scissorEnableAttributes = ctx->m_scissorEnableAttributesStack.top();
11844       ctx->m_scissorEnableAttributesStack.pop();
11845     }
11846     if ( mask & ( GL_ENABLE_BIT | GL_STENCIL_BUFFER_BIT ) )
11847     {
11848       ctx->m_stencilBufferEnableAttributes = ctx->m_stencilBufferEnableAttributesStack.top();
11849       ctx->m_stencilBufferEnableAttributesStack.pop();
11850     }
11851     if ( mask & ( GL_ENABLE_BIT | GL_TEXTURE_BIT ) )
11852     {
11853       ctx->m_textureEnableAttributes = ctx->m_textureEnableAttributesStack.top();
11854       ctx->m_textureEnableAttributesStack.pop();
11855     }
11856     if ( mask & ( GL_ENABLE_BIT | GL_TRANSFORM_BIT ) )
11857     {
11858       ctx->m_transformEnableAttributes = ctx->m_transformEnableAttributesStack.top();
11859       ctx->m_transformEnableAttributesStack.pop();
11860     }
11861     if ( mask & GL_EVAL_BIT )
11862     {
11863       ctx->m_evalAttributes = ctx->m_evalAttributesStack.top();
11864       ctx->m_evalAttributesStack.pop();
11865     }
11866     if ( mask & GL_FOG_BIT )
11867     {
11868       ctx->m_fogAttributes = ctx->m_fogAttributesStack.top();
11869       ctx->m_fogAttributesStack.pop();
11870     }
11871     if ( mask & GL_LIGHTING_BIT )
11872     {
11873       ctx->m_lightingAttributes = ctx->m_lightingAttributesStack.top();
11874       ctx->m_lightingAttributesStack.pop();
11875     }
11876     if ( mask & GL_LINE_BIT )
11877     {
11878       ctx->m_lineAttributes = ctx->m_lineAttributesStack.top();
11879       ctx->m_lineAttributesStack.pop();
11880     }
11881     if ( mask & GL_POINT_BIT )
11882     {
11883       ctx->m_pointAttributes = ctx->m_pointAttributesStack.top();
11884       ctx->m_pointAttributesStack.pop();
11885     }
11886     if ( mask & GL_POLYGON_BIT )
11887     {
11888       ctx->m_polygonAttributes = ctx->m_polygonAttributesStack.top();
11889       ctx->m_polygonAttributesStack.pop();
11890     }
11891     if ( mask & GL_SCISSOR_BIT )
11892     {
11893       ctx->m_scissorAttributes = ctx->m_scissorAttributesStack.top();
11894       ctx->m_scissorAttributesStack.pop();
11895     }
11896     if ( mask & GL_STENCIL_BUFFER_BIT )
11897     {
11898       ctx->m_stencilBufferAttributes = ctx->m_stencilBufferAttributesStack.top();
11899       ctx->m_stencilBufferAttributesStack.pop();
11900     }
11901     if ( mask & GL_TEXTURE_BIT )
11902     {
11903       ctx->m_textureAttributes = ctx->m_textureAttributesStack.top();
11904       ctx->m_textureAttributesStack.pop();
11905     }
11906     if ( mask & GL_TRANSFORM_BIT )
11907     {
11908       ctx->m_transformAttributes = ctx->m_transformAttributesStack.top();
11909       ctx->m_transformAttributesStack.pop();
11910     }
11911     if ( mask & GL_VIEWPORT_BIT )
11912     {
11913       ctx->m_viewportAttributes = ctx->m_viewportAttributesStack.top();
11914       ctx->m_viewportAttributesStack.pop();
11915     }
11916   }
11917   ctx->m_pushMasks.pop();
11918 #endif
11919 }
11920
11922
11926 inline  void  GLPopClientAttrib( void )
11927 {
11928   NVSG_GL_STATS_FCT_COUNT();
11929   glPopClientAttrib();
11930   ASSERT_GL_NO_ERROR;
11931 #if defined( GL_CACHING )
11932   GLContext * ctx = glContext();
11933   GLbitfield mask = (GLbitfield)ctx->m_clientPushMasks.top();
11934   if ( mask & GL_CLIENT_VERTEX_ARRAY_BIT )
11935   {
11936     // note: vertex buffer binding states will be pushed/popped along with the vertex array client state
11937     GLContext::VertexBufferBinding const& binding = ctx->m_vertexBufferBindingAttributesStack.top();
11938     ctx->m_bufferBindingAttributes.setVertexBufferBinding(binding);
11939     ctx->m_vertexBufferBindingAttributesStack.pop();
11940
11941     ctx->m_vertexArrayAttributes = ctx->m_vertexArrayAttributesStack.top();
11942     ctx->m_vertexArrayAttributesStack.pop();
11943   }
11944
11945   if ( mask & GL_CLIENT_PIXEL_STORE_BIT )
11946   {
11947     // note: pixel buffer binding states will be pushed/popped along with the pixel store client state
11948     GLContext::PixelBufferBinding const& binding = ctx->m_pixelBufferBindingAttributesStack.top();
11949     ctx->m_bufferBindingAttributes.setPixelBufferBinding(binding);
11950     ctx->m_pixelBufferBindingAttributesStack.pop();
11951   }
11952
11953   ctx->m_clientPushMasks.pop();
11954 #endif
11955 }
11956
11958
11959 inline  void  GLPopMatrix( void )
11960 {
11961   NVSG_GL_STATS_POP_MATRIX();
11962 #if defined( GL_CACHING )
11963   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
11964   { // note: we have a texture matrix stack per unit
11965     _GLUpdateActiveTexture();
11966   }
11967 #endif
11968   glPopMatrix();
11969   ASSERT_GL_NO_ERROR;
11970 }
11971
11973
11974 inline  void  GLPopName( void )
11975 {
11976   NVSG_GL_STATS_FCT_COUNT();
11977   glPopName();
11978   ASSERT_GL_NO_ERROR;
11979 }
11980
11982
11983 inline  void  GLPrimitiveRestart()
11984 {
11985   NVSG_GL_STATS_FCT_COUNT();
11986   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glPrimitiveRestart );
11987   glContext()->m_glFunctions->glPrimitiveRestart();
11988   ASSERT_GL_NO_ERROR;
11989 }
11990
11992
11993 inline  void  GLPrimitiveRestartIndex( GLuint index )
11994 {
11995   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glPrimitiveRestartIndex );
11996   GLContext * ctx = glContext();
11997 #if defined( GL_CACHING )
11998   if ( ctx->m_vertexArrayAttributes.m_primitiveRestartIndex != index )
11999 #endif
12000   {
12001     NVSG_GL_STATS_PRIMITIVE_RESTART_INDEX( index );
12002     ctx->m_glFunctions->glPrimitiveRestartIndex( index );
12003     ASSERT_GL_NO_ERROR;
12004 #if defined( GL_CACHING )
12005     ctx->m_vertexArrayAttributes.m_primitiveRestartIndex = index;
12006 #endif
12007   }
12008 }
12009
12011
12012 inline  void  GLPrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities )
12013 {
12014   NVSG_GL_STATS_FCT_COUNT();
12015   glPrioritizeTextures( n, textures, priorities );
12016   ASSERT_GL_NO_ERROR;
12017 }
12018
12020
12021 inline  void  GLProgramBufferParametersfv( GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params )
12022 {
12023   NVSG_GL_STATS_FCT_COUNT();
12024   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramBufferParametersfv );
12025   glContext()->m_glFunctions->glProgramBufferParametersfv( target, buffer, index, count, params );
12026   ASSERT_GL_NO_ERROR;
12027 }
12028
12030
12031 inline  void  GLProgramBufferParametersIiv( GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params )
12032 {
12033   NVSG_GL_STATS_FCT_COUNT();
12034   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramBufferParametersIiv );
12035   glContext()->m_glFunctions->glProgramBufferParametersIiv( target, buffer, index, count, params );
12036   ASSERT_GL_NO_ERROR;
12037 }
12038
12040
12041 inline  void  GLProgramBufferParametersIuiv( GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params )
12042 {
12043   NVSG_GL_STATS_FCT_COUNT();
12044   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramBufferParametersIuiv );
12045   glContext()->m_glFunctions->glProgramBufferParametersIuiv( target, buffer, index, count, params );
12046   ASSERT_GL_NO_ERROR;
12047 }
12048
12050
12051 inline  void  GLProgramEnvParameter4d(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
12052 {
12053   NVSG_GL_STATS_FCT_COUNT();
12054   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameter4dARB );
12055   glContext()->m_glFunctions->glProgramEnvParameter4dARB( target, index, x, y, z, w );
12056   ASSERT_GL_NO_ERROR;
12057 }
12058
12060
12061 inline  void  GLProgramEnvParameter4dv(GLenum target, GLuint index, const GLdouble *params)
12062 {
12063   NVSG_GL_STATS_FCT_COUNT();
12064   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameter4dvARB );
12065   glContext()->m_glFunctions->glProgramEnvParameter4dvARB( target, index, params );
12066   ASSERT_GL_NO_ERROR;
12067 }
12068
12070
12071 inline  void  GLProgramEnvParameter4f(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
12072 {
12073   NVSG_GL_STATS_FCT_COUNT();
12074   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameter4fARB );
12075   glContext()->m_glFunctions->glProgramEnvParameter4fARB( target, index, x, y, z, w );
12076   ASSERT_GL_NO_ERROR;
12077 }
12078
12080
12081 inline  void  GLProgramEnvParameter4fv(GLenum target, GLuint index, const GLfloat *params)
12082 {
12083   NVSG_GL_STATS_FCT_COUNT();
12084   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameter4fvARB );
12085   glContext()->m_glFunctions->glProgramEnvParameter4fvARB( target, index, params );
12086   ASSERT_GL_NO_ERROR;
12087 }
12088
12089
12091
12092 inline  void  GLProgramEnvParametersI4iv( GLenum target, GLuint index, GLsizei count, const GLint *params )
12093 {
12094   NVSG_GL_STATS_FCT_COUNT();
12095   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParametersI4iv );
12096   glContext()->m_glFunctions->glProgramEnvParametersI4iv( target, index, count, params );
12097   ASSERT_GL_NO_ERROR;
12098 }
12099
12101
12102 inline  void  GLProgramEnvParametersI4uiv( GLenum target, GLuint index, GLsizei count, const GLuint *params )
12103 {
12104   NVSG_GL_STATS_FCT_COUNT();
12105   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParametersI4uiv );
12106   glContext()->m_glFunctions->glProgramEnvParametersI4uiv( target, index, count, params );
12107   ASSERT_GL_NO_ERROR;
12108 }
12109
12111
12112 inline  void  GLProgramEnvParameterI4i( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w )
12113 {
12114   NVSG_GL_STATS_FCT_COUNT();
12115   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameterI4i );
12116   glContext()->m_glFunctions->glProgramEnvParameterI4i( target, index, x, y, z, w );
12117   ASSERT_GL_NO_ERROR;
12118 }
12119
12121
12122 inline  void  GLProgramEnvParameterI4iv( GLenum target, GLuint index, const GLint *params )
12123 {
12124   NVSG_GL_STATS_FCT_COUNT();
12125   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameterI4iv );
12126   glContext()->m_glFunctions->glProgramEnvParameterI4iv( target, index, params );
12127   ASSERT_GL_NO_ERROR;
12128 }
12129
12131
12132 inline  void  GLProgramEnvParameterI4ui( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
12133 {
12134   NVSG_GL_STATS_FCT_COUNT();
12135   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameterI4ui );
12136   glContext()->m_glFunctions->glProgramEnvParameterI4ui( target, index, x, y, z, w );
12137   ASSERT_GL_NO_ERROR;
12138 }
12139
12141
12142 inline  void  GLProgramEnvParameterI4uiv( GLenum target, GLuint index, const GLuint *params )
12143 {
12144   NVSG_GL_STATS_FCT_COUNT();
12145   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameterI4uiv );
12146   glContext()->m_glFunctions->glProgramEnvParameterI4uiv( target, index, params );
12147   ASSERT_GL_NO_ERROR;
12148 }
12149
12151
12152 inline  void  GLProgramEnvParameters4fv( GLenum target, GLuint index, GLsizei count, const GLfloat *params )
12153 {
12154   NVSG_GL_STATS_FCT_COUNT();
12155   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramEnvParameters4fv );
12156   glContext()->m_glFunctions->glProgramEnvParameters4fv( target, index, count, params );
12157   ASSERT_GL_NO_ERROR;
12158 }
12159
12161
12162 inline  void  GLProgramLocalParameter4d(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
12163 {
12164   NVSG_GL_STATS_FCT_COUNT();
12165   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameter4dARB );
12166   glContext()->m_glFunctions->glProgramLocalParameter4dARB( target, index, x, y, z, w );
12167   ASSERT_GL_NO_ERROR;
12168 }
12169
12171
12172 inline  void  GLProgramLocalParameter4dv(GLenum target, GLuint index, const GLdouble *params)
12173 {
12174   NVSG_GL_STATS_FCT_COUNT();
12175   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameter4dvARB );
12176   glContext()->m_glFunctions->glProgramLocalParameter4dvARB( target, index, params );
12177   ASSERT_GL_NO_ERROR;
12178 }
12179
12181
12182 inline  void  GLProgramLocalParameter4f(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
12183 {
12184   NVSG_GL_STATS_FCT_COUNT();
12185   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameter4fARB );
12186   glContext()->m_glFunctions->glProgramLocalParameter4fARB( target, index, x, y, z, w );
12187   ASSERT_GL_NO_ERROR;
12188 }
12189
12191
12192 inline  void  GLProgramLocalParameter4fv(GLenum target, GLuint index, const GLfloat *params)
12193 {
12194   NVSG_GL_STATS_FCT_COUNT();
12195   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameter4fvARB );
12196   glContext()->m_glFunctions->glProgramLocalParameter4fvARB( target, index, params );
12197   ASSERT_GL_NO_ERROR;
12198 }
12199
12201
12202 inline  void  GLProgramLocalParametersI4iv( GLenum target, GLuint index, GLsizei count, const GLint *params )
12203 {
12204   NVSG_GL_STATS_FCT_COUNT();
12205   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParametersI4iv );
12206   glContext()->m_glFunctions->glProgramLocalParametersI4iv( target, index, count, params );
12207   ASSERT_GL_NO_ERROR;
12208 }
12209
12211
12212 inline  void  GLProgramLocalParametersI4uiv( GLenum target, GLuint index, GLsizei count, const GLuint *params )
12213 {
12214   NVSG_GL_STATS_FCT_COUNT();
12215   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParametersI4uiv );
12216   glContext()->m_glFunctions->glProgramLocalParametersI4uiv( target, index, count, params );
12217   ASSERT_GL_NO_ERROR;
12218 }
12219
12221
12222 inline  void  GLProgramLocalParameterI4i( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w )
12223 {
12224   NVSG_GL_STATS_FCT_COUNT();
12225   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameterI4i );
12226   glContext()->m_glFunctions->glProgramLocalParameterI4i( target, index, x, y, z, w );
12227   ASSERT_GL_NO_ERROR;
12228 }
12229
12231
12232 inline  void  GLProgramLocalParameterI4iv( GLenum target, GLuint index, const GLint *params )
12233 {
12234   NVSG_GL_STATS_FCT_COUNT();
12235   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameterI4iv );
12236   glContext()->m_glFunctions->glProgramLocalParameterI4iv( target, index, params );
12237   ASSERT_GL_NO_ERROR;
12238 }
12239
12241
12242 inline  void  GLProgramLocalParameterI4ui( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
12243 {
12244   NVSG_GL_STATS_FCT_COUNT();
12245   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameterI4ui );
12246   glContext()->m_glFunctions->glProgramLocalParameterI4ui( target, index, x, y, z, w );
12247   ASSERT_GL_NO_ERROR;
12248 }
12249
12251
12252 inline  void  GLProgramLocalParameterI4uiv( GLenum target, GLuint index, const GLuint *params )
12253 {
12254   NVSG_GL_STATS_FCT_COUNT();
12255   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameterI4uiv );
12256   glContext()->m_glFunctions->glProgramLocalParameterI4uiv( target, index, params );
12257   ASSERT_GL_NO_ERROR;
12258 }
12259
12261
12262 inline  void  GLProgramLocalParameters4fv( GLenum target, GLuint index, GLsizei count, const GLfloat *params )
12263 {
12264   NVSG_GL_STATS_FCT_COUNT();
12265   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramLocalParameters4fv );
12266   glContext()->m_glFunctions->glProgramLocalParameters4fv( target, index, count, params );
12267   ASSERT_GL_NO_ERROR;
12268 }
12269
12271
12272 inline  void  GLProgramNamedParameter4d( GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
12273 {
12274   NVSG_GL_STATS_FCT_COUNT();
12275   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramNamedParameter4d );
12276   glContext()->m_glFunctions->glProgramNamedParameter4d( id, len, name, x, y, z, w );
12277   ASSERT_GL_NO_ERROR;
12278 }
12279
12281
12282 inline  void  GLProgramNamedParameter4dv( GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v )
12283 {
12284   NVSG_GL_STATS_FCT_COUNT();
12285   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramNamedParameter4dv );
12286   glContext()->m_glFunctions->glProgramNamedParameter4dv( id, len, name, v );
12287   ASSERT_GL_NO_ERROR;
12288 }
12289
12291
12292 inline  void  GLProgramNamedParameter4f( GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
12293 {
12294   NVSG_GL_STATS_FCT_COUNT();
12295   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramNamedParameter4f );
12296   glContext()->m_glFunctions->glProgramNamedParameter4f( id, len, name, x, y, z, w );
12297   ASSERT_GL_NO_ERROR;
12298 }
12299
12301
12302 inline  void  GLProgramNamedParameter4fv( GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v )
12303 {
12304   NVSG_GL_STATS_FCT_COUNT();
12305   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramNamedParameter4fv );
12306   glContext()->m_glFunctions->glProgramNamedParameter4fv( id, len, name, v );
12307   ASSERT_GL_NO_ERROR;
12308 }
12309
12311
12312 inline  void  GLProgramParameter4d( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
12313 {
12314   NVSG_GL_STATS_FCT_COUNT();
12315   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramParameter4dNV );
12316   glContext()->m_glFunctions->glProgramParameter4dNV( target, index, x, y, z, w );
12317   ASSERT_GL_NO_ERROR;
12318 }
12319
12321
12322 inline  void  GLProgramParameter4dv( GLenum target, GLuint index, const GLdouble *v )
12323 {
12324   NVSG_GL_STATS_FCT_COUNT();
12325   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramParameter4dvNV );
12326   glContext()->m_glFunctions->glProgramParameter4dvNV( target, index, v );
12327   ASSERT_GL_NO_ERROR;
12328 }
12329
12331
12332 inline  void  GLProgramParameter4f( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
12333 {
12334   NVSG_GL_STATS_FCT_COUNT();
12335   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramParameter4fNV );
12336   glContext()->m_glFunctions->glProgramParameter4fNV( target, index, x, y, z, w );
12337   ASSERT_GL_NO_ERROR;
12338 }
12339
12341
12342 inline  void  GLProgramParameter4fv( GLenum target, GLuint index, const GLfloat *v )
12343 {
12344   NVSG_GL_STATS_FCT_COUNT();
12345   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramParameter4fvNV );
12346   glContext()->m_glFunctions->glProgramParameter4fvNV( target, index, v );
12347   ASSERT_GL_NO_ERROR;
12348 }
12349
12351
12352 inline  void  GLProgramParameteri( GLuint program, GLenum pname, GLint value )
12353 {
12354   NVSG_GL_STATS_FCT_COUNT();
12355   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramParameteri );
12356   glContext()->m_glFunctions->glProgramParameteri( program, pname, value );
12357   ASSERT_GL_NO_ERROR;
12358 }
12359
12361
12362 inline  void  GLProgramParameters4dv( GLenum target, GLuint index, GLsizei count, const GLdouble *v )
12363 {
12364   NVSG_GL_STATS_FCT_COUNT();
12365   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramParameters4dvNV );
12366   glContext()->m_glFunctions->glProgramParameters4dvNV( target, index, count, v );
12367   ASSERT_GL_NO_ERROR;
12368 }
12369
12371
12372 inline  void  GLProgramParameters4fv( GLenum target, GLuint index, GLsizei count, const GLfloat *v )
12373 {
12374   NVSG_GL_STATS_FCT_COUNT();
12375   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramParameters4fvNV );
12376   glContext()->m_glFunctions->glProgramParameters4fvNV( target, index, count, v );
12377   ASSERT_GL_NO_ERROR;
12378 }
12379
12381
12382 inline  void  GLProgramString( GLenum target, GLenum format, GLsizei len, const GLvoid *string )
12383 {
12384   NVSG_GL_STATS_FCT_COUNT();
12385   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramStringARB );
12386   glContext()->m_glFunctions->glProgramStringARB( target, format, len, string );
12387   ASSERT_GL_NO_ERROR;
12388 }
12389
12391
12392 inline  void  GLProgramVertexLimit( GLenum target, GLint limit )
12393 {
12394   NVSG_GL_STATS_FCT_COUNT();
12395   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramVertexLimit );
12396   glContext()->m_glFunctions->glProgramVertexLimit( target, limit );
12397   ASSERT_GL_NO_ERROR;
12398 }
12399
12401
12405 inline  void  GLPushAttrib( GLbitfield mask )
12406 {
12407   NVSG_GL_STATS_PUSH_ATTRIB( mask );
12408   glPushAttrib( mask );
12409   ASSERT_GL_NO_ERROR;
12410 #if defined( GL_CACHING )
12411   GLContext * ctx = glContext();
12412   ctx->m_pushMasks.push( mask );
12413   if ( mask == GL_ALL_ATTRIB_BITS )
12414   {
12415     ctx->m_colorBufferAttributesStack.push( ctx->m_colorBufferAttributes );
12416     ctx->m_colorBufferEnableAttributesStack.push( ctx->m_colorBufferEnableAttributes );
12417     ctx->m_depthBufferAttributesStack.push( ctx->m_depthBufferAttributes );
12418     ctx->m_depthBufferEnableAttributesStack.push( ctx->m_depthBufferEnableAttributes );
12419     ctx->m_evalAttributesStack.push( ctx->m_evalAttributes );
12420     ctx->m_fogAttributesStack.push( ctx->m_fogAttributes );
12421     ctx->m_fogEnableAttributesStack.push( ctx->m_fogEnableAttributes );
12422     ctx->m_lightingAttributesStack.push( ctx->m_lightingAttributes );
12423     ctx->m_lightingEnableAttributesStack.push( ctx->m_lightingEnableAttributes );
12424     ctx->m_lineAttributesStack.push( ctx->m_lineAttributes );
12425     ctx->m_lineEnableAttributesStack.push( ctx->m_lineEnableAttributes );
12426     ctx->m_pointAttributesStack.push( ctx->m_pointAttributes );
12427     ctx->m_pointEnableAttributesStack.push( ctx->m_pointEnableAttributes );
12428     ctx->m_polygonAttributesStack.push( ctx->m_polygonAttributes );
12429     ctx->m_polygonEnableAttributesStack.push( ctx->m_polygonEnableAttributes );
12430     ctx->m_scissorAttributesStack.push( ctx->m_scissorAttributes );
12431     ctx->m_scissorEnableAttributesStack.push( ctx->m_scissorEnableAttributes );
12432     ctx->m_stencilBufferAttributesStack.push( ctx->m_stencilBufferAttributes );
12433     ctx->m_stencilBufferEnableAttributesStack.push( ctx->m_stencilBufferEnableAttributes );
12434     ctx->m_textureAttributesStack.push( ctx->m_textureAttributes );
12435     ctx->m_textureEnableAttributesStack.push( ctx->m_textureEnableAttributes );
12436     ctx->m_transformAttributesStack.push( ctx->m_transformAttributes );
12437     ctx->m_transformEnableAttributesStack.push( ctx->m_transformEnableAttributes );
12438     ctx->m_viewportAttributesStack.push( ctx->m_viewportAttributes );
12439   }
12440   else
12441   {
12442     if ( mask & GL_COLOR_BUFFER_BIT )
12443     {
12444       ctx->m_colorBufferAttributesStack.push( ctx->m_colorBufferAttributes );
12445     }
12446     if ( mask & GL_DEPTH_BUFFER_BIT )
12447     {
12448       ctx->m_depthBufferAttributesStack.push( ctx->m_depthBufferAttributes );
12449     }
12450     if ( mask & ( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT ) )
12451     {
12452       ctx->m_colorBufferEnableAttributesStack.push( ctx->m_colorBufferEnableAttributes );
12453     }
12454     if ( mask & ( GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT ) )
12455     {
12456       ctx->m_depthBufferEnableAttributesStack.push( ctx->m_depthBufferEnableAttributes );
12457     }
12458     if ( mask & ( GL_ENABLE_BIT | GL_FOG_BIT ) )
12459     {
12460       ctx->m_fogEnableAttributesStack.push( ctx->m_fogEnableAttributes );
12461     }
12462     if ( mask & ( GL_ENABLE_BIT | GL_LIGHTING_BIT ) )
12463     {
12464       ctx->m_lightingEnableAttributesStack.push( ctx->m_lightingEnableAttributes );
12465     }
12466     if ( mask & ( GL_ENABLE_BIT | GL_LINE_BIT ) )
12467     {
12468       ctx->m_lineEnableAttributesStack.push( ctx->m_lineEnableAttributes );
12469     }
12470     if ( mask & ( GL_ENABLE_BIT | GL_POINT_BIT ) )
12471     {
12472       ctx->m_pointEnableAttributesStack.push( ctx->m_pointEnableAttributes );
12473     }
12474     if ( mask & ( GL_ENABLE_BIT | GL_POLYGON_BIT ) )
12475     {
12476       ctx->m_polygonEnableAttributesStack.push( ctx->m_polygonEnableAttributes );
12477     }
12478     if ( mask & ( GL_ENABLE_BIT | GL_SCISSOR_BIT ) )
12479     {
12480       ctx->m_scissorEnableAttributesStack.push( ctx->m_scissorEnableAttributes );
12481     }
12482     if ( mask & ( GL_ENABLE_BIT | GL_STENCIL_BUFFER_BIT ) )
12483     {
12484       ctx->m_stencilBufferEnableAttributesStack.push( ctx->m_stencilBufferEnableAttributes );
12485     }
12486     if ( mask & ( GL_ENABLE_BIT | GL_TEXTURE_BIT ) )
12487     {
12488       ctx->m_textureEnableAttributesStack.push( ctx->m_textureEnableAttributes );
12489     }
12490     if ( mask & ( GL_ENABLE_BIT | GL_TRANSFORM_BIT ) )
12491     {
12492       ctx->m_transformEnableAttributesStack.push( ctx->m_transformEnableAttributes );
12493     }
12494     if ( mask & GL_EVAL_BIT )
12495     {
12496       ctx->m_evalAttributesStack.push( ctx->m_evalAttributes );
12497     }
12498     if ( mask & GL_FOG_BIT )
12499     {
12500       ctx->m_fogAttributesStack.push( ctx->m_fogAttributes );
12501     }
12502     if ( mask & GL_LIGHTING_BIT )
12503     {
12504       ctx->m_lightingAttributesStack.push( ctx->m_lightingAttributes );
12505     }
12506     if ( mask & GL_LINE_BIT )
12507     {
12508       ctx->m_lineAttributesStack.push( ctx->m_lineAttributes );
12509     }
12510     if ( mask & GL_POINT_BIT )
12511     {
12512       ctx->m_pointAttributesStack.push( ctx->m_pointAttributes );
12513     }
12514     if ( mask & GL_POLYGON_BIT )
12515     {
12516       ctx->m_polygonAttributesStack.push( ctx->m_polygonAttributes );
12517     }
12518     if ( mask & GL_SCISSOR_BIT )
12519     {
12520       ctx->m_scissorAttributesStack.push( ctx->m_scissorAttributes );
12521     }
12522     if ( mask & GL_STENCIL_BUFFER_BIT )
12523     {
12524       ctx->m_stencilBufferAttributesStack.push( ctx->m_stencilBufferAttributes );
12525     }
12526     if ( mask & GL_TEXTURE_BIT )
12527     {
12528       ctx->m_textureAttributesStack.push( ctx->m_textureAttributes );
12529     }
12530     if ( mask & GL_TRANSFORM_BIT )
12531     {
12532       ctx->m_transformAttributesStack.push( ctx->m_transformAttributes );
12533     }
12534     if ( mask & GL_VIEWPORT_BIT )
12535     {
12536       ctx->m_viewportAttributesStack.push( ctx->m_viewportAttributes );
12537     }
12538   }
12539 #endif
12540 }
12541
12543
12547 inline  void  GLPushClientAttrib( GLbitfield mask )
12548 {
12549   NVSG_GL_STATS_FCT_COUNT();
12550   glPushClientAttrib( mask );
12551   ASSERT_GL_NO_ERROR;
12552 #if defined( GL_CACHING )
12553   GLContext * ctx = glContext();
12554   ctx->m_clientPushMasks.push( mask );
12555   if ( mask & GL_CLIENT_VERTEX_ARRAY_BIT )
12556   {
12557     // note: vertex buffer binding states will be pushed/popped along with the vertex array client state
12558     ctx->m_vertexBufferBindingAttributesStack.push(ctx->m_bufferBindingAttributes.getVertexBufferBinding());
12559     ctx->m_vertexArrayAttributesStack.push( ctx->m_vertexArrayAttributes );
12560   }
12561   if ( mask & GL_CLIENT_PIXEL_STORE_BIT )
12562   {
12563     // note: pixel buffer binding states will be pushed/popped along with the pixel store client state
12564     ctx->m_pixelBufferBindingAttributesStack.push(ctx->m_bufferBindingAttributes.getPixelBufferBinding());
12565   }
12566 #endif
12567 }
12568
12570
12571 inline  void  GLPushMatrix( void )
12572 {
12573   NVSG_GL_STATS_PUSH_MATRIX();
12574 #if defined( GL_CACHING )
12575   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
12576   { // note: we have a texture matrix stack per unit
12577     _GLUpdateActiveTexture();
12578   }
12579 #endif
12580   glPushMatrix();
12581   ASSERT_GL_NO_ERROR;
12582 }
12583
12585
12586 inline  void  GLPushName( GLuint name )
12587 {
12588   NVSG_GL_STATS_FCT_COUNT();
12589   glPushName( name );
12590   ASSERT_GL_NO_ERROR;
12591 }
12592
12594
12595 inline  void  GLRasterPos2d( GLdouble x, GLdouble y )
12596 {
12597   NVSG_GL_STATS_FCT_COUNT();
12598   glRasterPos2d( x, y );
12599   ASSERT_GL_NO_ERROR;
12600 }
12601
12603
12604 inline  void  GLRasterPos2f( GLfloat x, GLfloat y )
12605 {
12606   NVSG_GL_STATS_FCT_COUNT();
12607   glRasterPos2f( x, y );
12608   ASSERT_GL_NO_ERROR;
12609 }
12610
12612
12613 inline  void  GLRasterPos2i( GLint x, GLint y )
12614 {
12615   NVSG_GL_STATS_FCT_COUNT();
12616   glRasterPos2i( x, y );
12617   ASSERT_GL_NO_ERROR;
12618 }
12619
12621
12622 inline  void  GLRasterPos2s( GLshort x, GLshort y )
12623 {
12624   NVSG_GL_STATS_FCT_COUNT();
12625   glRasterPos2s( x, y );
12626   ASSERT_GL_NO_ERROR;
12627 }
12628
12630
12631 inline  void  GLRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
12632 {
12633   NVSG_GL_STATS_FCT_COUNT();
12634   glRasterPos3d( x, y, z );
12635   ASSERT_GL_NO_ERROR;
12636 }
12637
12639
12640 inline  void  GLRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
12641 {
12642   NVSG_GL_STATS_FCT_COUNT();
12643   glRasterPos3f( x, y, z );
12644   ASSERT_GL_NO_ERROR;
12645 }
12646
12648
12649 inline  void  GLRasterPos3i( GLint x, GLint y, GLint z )
12650 {
12651   NVSG_GL_STATS_FCT_COUNT();
12652   glRasterPos3i( x, y, z );
12653   ASSERT_GL_NO_ERROR;
12654 }
12655
12657
12658 inline  void  GLRasterPos3s( GLshort x, GLshort y, GLshort z )
12659 {
12660   NVSG_GL_STATS_FCT_COUNT();
12661   glRasterPos3s( x, y, z );
12662   ASSERT_GL_NO_ERROR;
12663 }
12664
12666
12667 inline  void  GLRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
12668 {
12669   NVSG_GL_STATS_FCT_COUNT();
12670   glRasterPos4d( x, y, z, w );
12671   ASSERT_GL_NO_ERROR;
12672 }
12673
12675
12676 inline  void  GLRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
12677 {
12678   NVSG_GL_STATS_FCT_COUNT();
12679   glRasterPos4f( x, y, z, w );
12680   ASSERT_GL_NO_ERROR;
12681 }
12682
12684
12685 inline  void  GLRasterPos4i( GLint x, GLint y, GLint z, GLint w )
12686 {
12687   NVSG_GL_STATS_FCT_COUNT();
12688   glRasterPos4i( x, y, z, w );
12689   ASSERT_GL_NO_ERROR;
12690 }
12691
12693
12694 inline  void  GLRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
12695 {
12696   NVSG_GL_STATS_FCT_COUNT();
12697   glRasterPos4s( x, y, z, w );
12698   ASSERT_GL_NO_ERROR;
12699 }
12700
12702
12703 inline  void  GLReadBuffer( GLenum mode )
12704 {
12705   NVSG_GL_STATS_FCT_COUNT();
12706   glReadBuffer( mode );
12707   ASSERT_GL_NO_ERROR;
12708 }
12709
12711
12712 inline  void  GLReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
12713 {
12714   NVSG_GL_STATS_FCT_COUNT();
12715   glReadPixels( x, y, width, height, format, type, pixels );
12716   ASSERT_GL_NO_ERROR;
12717 }
12718
12720
12721 inline  void  GLRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
12722 {
12723   NVSG_GL_STATS_FCT_COUNT();
12724   glRectd( x1, y1, x2, y2 );
12725   ASSERT_GL_NO_ERROR;
12726 }
12727
12729
12730 inline  void  GLRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
12731 {
12732   NVSG_GL_STATS_FCT_COUNT();
12733   glRectf( x1, y1, x2, y2 );
12734   ASSERT_GL_NO_ERROR;
12735 }
12736
12738
12739 inline  void  GLRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
12740 {
12741   NVSG_GL_STATS_FCT_COUNT();
12742   glRecti( x1, y1, x2, y2 );
12743   ASSERT_GL_NO_ERROR;
12744 }
12745
12747
12748 inline  void  GLRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
12749 {
12750   NVSG_GL_STATS_FCT_COUNT();
12751   glRects( x1, y1, x2, y2 );
12752   ASSERT_GL_NO_ERROR;
12753 }
12754
12756
12757 inline  void  GLRenderMode( GLenum mode )
12758 {
12759   NVSG_GL_STATS_FCT_COUNT();
12760   glRenderMode( mode );
12761   ASSERT_GL_NO_ERROR;
12762 }
12763
12765
12766 inline  void  GLRequestResidentPrograms( GLsizei n, const GLuint *programs )
12767 {
12768   NVSG_GL_STATS_FCT_COUNT();
12769   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glRequestResidentProgramsNV );
12770   glContext()->m_glFunctions->glRequestResidentProgramsNV( n, programs );
12771   ASSERT_GL_NO_ERROR;
12772 }
12773
12775
12776 inline  void  GLResetHistogram( GLenum target )
12777 {
12778   NVSG_GL_STATS_FCT_COUNT();
12779   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glResetHistogram );
12780   glContext()->m_glFunctions->glResetHistogram( target );
12781   ASSERT_GL_NO_ERROR;
12782 }
12783
12785
12786 inline  void  GLResetMinmax( GLenum target )
12787 {
12788   NVSG_GL_STATS_FCT_COUNT();
12789   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glResetMinmax );
12790   glContext()->m_glFunctions->glResetMinmax( target );
12791   ASSERT_GL_NO_ERROR;
12792 }
12793
12795
12796 inline  void  GLRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
12797 {
12798   NVSG_GL_STATS_ROTATED( angle, x, y, z );
12799 #if defined( GL_CACHING )
12800   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
12801   { // note: we have a texture matrix stack per unit
12802     _GLUpdateActiveTexture();
12803   }
12804 #endif
12805   glRotated( angle, x, y, z );
12806   ASSERT_GL_NO_ERROR;
12807 }
12808
12810
12811 inline  void  GLRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
12812 {
12813   NVSG_GL_STATS_ROTATEF( angle, x, y, z );
12814 #if defined( GL_CACHING )
12815   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
12816   { // note: we have a texture matrix stack per unit
12817     _GLUpdateActiveTexture();
12818   }
12819 #endif
12820   glRotatef( angle, x, y, z );
12821   ASSERT_GL_NO_ERROR;
12822 }
12823
12825
12826 inline  void  GLScaled( GLdouble x, GLdouble y, GLdouble z )
12827 {
12828   NVSG_GL_STATS_SCALED( x, y, z );
12829 #if defined( GL_CACHING )
12830   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
12831   { // note: we have a texture matrix stack per unit
12832     _GLUpdateActiveTexture();
12833   }
12834 #endif
12835   glScaled( x, y, z );
12836   ASSERT_GL_NO_ERROR;
12837 }
12838
12840
12841 inline  void  GLScalef( GLfloat x, GLfloat y, GLfloat z )
12842 {
12843   NVSG_GL_STATS_SCALEF( x, y, z );
12844 #if defined( GL_CACHING )
12845   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
12846   { // note: we have a texture matrix stack per unit
12847     _GLUpdateActiveTexture();
12848   }
12849 #endif
12850   glScalef( x, y, z );
12851   ASSERT_GL_NO_ERROR;
12852 }
12853
12855
12856 inline  void  GLSampleCoverage( GLclampf value, GLboolean invert )
12857 {
12858   NVSG_GL_STATS_FCT_COUNT();
12859   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSampleCoverage );
12860   glContext()->m_glFunctions->glSampleCoverage( value, invert );
12861   ASSERT_GL_NO_ERROR;
12862 }
12863
12865
12866 inline  void  GLScissor( GLint x, GLint y, GLsizei width, GLsizei height )
12867 {
12868 #if defined( GL_CACHING )
12869   GLContext * ctx = glContext();
12870 # if defined(GL_SUPPORT_RESET)
12871   ctx->m_previousAttributes.m_scissorX      = ctx->m_scissorAttributes.m_x;
12872   ctx->m_previousAttributes.m_scissorY      = ctx->m_scissorAttributes.m_y;
12873   ctx->m_previousAttributes.m_scissorWidth  = ctx->m_scissorAttributes.m_width;
12874   ctx->m_previousAttributes.m_scissorHeight = ctx->m_scissorAttributes.m_height;
12875 # endif
12876   if (    ( ctx->m_scissorAttributes.m_x != x )
12877       ||  ( ctx->m_scissorAttributes.m_y != y )
12878       ||  ( ctx->m_scissorAttributes.m_width != width )
12879       ||  ( ctx->m_scissorAttributes.m_height != height ) )
12880 #endif
12881   {
12882     NVSG_GL_STATS_FCT_COUNT();
12883     glScissor( x, y, width, height );
12884     ASSERT_GL_NO_ERROR;
12885 #if defined( GL_CACHING )
12886     ctx->m_scissorAttributes.m_x = x;
12887     ctx->m_scissorAttributes.m_y = y;
12888     ctx->m_scissorAttributes.m_width = width;
12889     ctx->m_scissorAttributes.m_height = height;
12890 #endif
12891   }
12892 }
12893
12898 inline void GLResetScissor()
12899 {
12900 #if defined(GL_SUPPORT_RESET)
12901   GLContext * ctx = glContext();
12902   GLScissor( ctx->m_previousAttributes.m_scissorX, ctx->m_previousAttributes.m_scissorY
12903            , ctx->m_previousAttributes.m_scissorWidth, ctx->m_previousAttributes.m_scissorHeight );
12904 #else
12905 #endif
12906 }
12907
12909
12910 inline  void  GLSecondaryColor3b( GLbyte red, GLbyte green, GLbyte blue )
12911 {
12912   NVSG_GL_STATS_FCT_COUNT();
12913   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3b );
12914   glContext()->m_glFunctions->glSecondaryColor3b( red, green, blue );
12915   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12916 }
12917
12919
12920 inline  void  GLSecondaryColor3bv( const GLbyte *v )
12921 {
12922   NVSG_GL_STATS_FCT_COUNT();
12923   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3bv );
12924   glContext()->m_glFunctions->glSecondaryColor3bv( v );
12925   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12926 }
12927
12929
12930 inline  void  GLSecondaryColor3d( GLdouble red, GLdouble green, GLdouble blue )
12931 {
12932   NVSG_GL_STATS_FCT_COUNT();
12933   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3d );
12934   glContext()->m_glFunctions->glSecondaryColor3d( red, green, blue );
12935   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12936 }
12937
12939
12940 inline  void  GLSecondaryColor3dv( const GLdouble *v )
12941 {
12942   NVSG_GL_STATS_FCT_COUNT();
12943   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3dv );
12944   glContext()->m_glFunctions->glSecondaryColor3dv( v );
12945   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12946 }
12947
12949
12950 inline  void  GLSecondaryColor3f( GLfloat red, GLfloat green, GLfloat blue )
12951 {
12952   NVSG_GL_STATS_FCT_COUNT();
12953   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3f );
12954   glContext()->m_glFunctions->glSecondaryColor3f( red, green, blue );
12955   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12956 }
12957
12959
12960 inline  void  GLSecondaryColor3fv( const GLfloat *v )
12961 {
12962   NVSG_GL_STATS_FCT_COUNT();
12963   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3fv );
12964   glContext()->m_glFunctions->glSecondaryColor3fv( v );
12965   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12966 }
12967
12969
12970 inline  void  GLSecondaryColor3h( GLhalf red, GLhalf green, GLhalf blue )
12971 {
12972   NVSG_GL_STATS_FCT_COUNT();
12973   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3h );
12974   glContext()->m_glFunctions->glSecondaryColor3h( red, green, blue );
12975   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12976 }
12977
12979
12980 inline  void  GLSecondaryColor3hv( const GLhalf *v )
12981 {
12982   NVSG_GL_STATS_FCT_COUNT();
12983   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3hv );
12984   glContext()->m_glFunctions->glSecondaryColor3hv( v );
12985   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12986 }
12987
12989
12990 inline  void  GLSecondaryColor3i( GLint red, GLint green, GLint blue )
12991 {
12992   NVSG_GL_STATS_FCT_COUNT();
12993   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3i );
12994   glContext()->m_glFunctions->glSecondaryColor3i( red, green, blue );
12995   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
12996 }
12997
12999
13000 inline  void  GLSecondaryColor3iv( const GLint *v )
13001 {
13002   NVSG_GL_STATS_FCT_COUNT();
13003   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3iv );
13004   glContext()->m_glFunctions->glSecondaryColor3iv( v );
13005   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13006 }
13007
13009
13010 inline  void  GLSecondaryColor3s( GLshort red, GLshort green, GLshort blue )
13011 {
13012   NVSG_GL_STATS_FCT_COUNT();
13013   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3s );
13014   glContext()->m_glFunctions->glSecondaryColor3s( red, green, blue );
13015   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13016 }
13017
13019
13020 inline  void  GLSecondaryColor3sv( const GLshort *v )
13021 {
13022   NVSG_GL_STATS_FCT_COUNT();
13023   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3sv );
13024   glContext()->m_glFunctions->glSecondaryColor3sv( v );
13025   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13026 }
13027
13029
13030 inline  void  GLSecondaryColor3ub( GLubyte red, GLubyte green, GLubyte blue )
13031 {
13032   NVSG_GL_STATS_FCT_COUNT();
13033   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3ub );
13034   glContext()->m_glFunctions->glSecondaryColor3ub( red, green, blue );
13035   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13036 }
13037
13039
13040 inline  void  GLSecondaryColor3ubv( const GLubyte *v )
13041 {
13042   NVSG_GL_STATS_FCT_COUNT();
13043   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3ubv );
13044   glContext()->m_glFunctions->glSecondaryColor3ubv( v );
13045   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13046 }
13047
13049
13050 inline  void  GLSecondaryColor3ui( GLuint red, GLuint green, GLuint blue )
13051 {
13052   NVSG_GL_STATS_FCT_COUNT();
13053   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3ui );
13054   glContext()->m_glFunctions->glSecondaryColor3ui( red, green, blue );
13055   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13056 }
13057
13059
13060 inline  void  GLSecondaryColor3uiv( const GLuint *v )
13061 {
13062   NVSG_GL_STATS_FCT_COUNT();
13063   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3uiv );
13064   glContext()->m_glFunctions->glSecondaryColor3uiv( v );
13065   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13066 }
13067
13069
13070 inline  void  GLSecondaryColor3us( GLushort red, GLushort green, GLushort blue )
13071 {
13072   NVSG_GL_STATS_FCT_COUNT();
13073   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3us );
13074   glContext()->m_glFunctions->glSecondaryColor3us( red, green, blue );
13075   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13076 }
13077
13079
13080 inline  void  GLSecondaryColor3usv( const GLushort *v )
13081 {
13082   NVSG_GL_STATS_FCT_COUNT();
13083   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColor3usv );
13084   glContext()->m_glFunctions->glSecondaryColor3usv( v );
13085   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13086 }
13087
13089
13090 inline  void  GLSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
13091 {
13092   NVSG_GL_STATS_FCT_COUNT();
13093   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSecondaryColorPointer );
13094   glContext()->m_glFunctions->glSecondaryColorPointer( size, type, stride, pointer );
13095   ASSERT_GL_NO_ERROR;
13096 }
13097
13099
13100 inline  void  GLSelectBuffer( GLsizei size, GLuint *buffer )
13101 {
13102   NVSG_GL_STATS_FCT_COUNT();
13103   glSelectBuffer( size, buffer );
13104   ASSERT_GL_NO_ERROR;
13105 }
13106
13108
13109 inline  void  GLSelectTexture( GLenum target )
13110 {
13111   GLActiveTexture( target );
13112 }
13113
13115
13116 inline  void  GLSelectTextureCoordSet( GLenum target )
13117 {
13118   GLClientActiveTexture( target );
13119 }
13120
13122
13123 inline  void  GLSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column )
13124 {
13125   NVSG_GL_STATS_FCT_COUNT();
13126   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSeparableFilter2D );
13127   glContext()->m_glFunctions->glSeparableFilter2D( target, internalformat, width, height, format, type, row, column );
13128   ASSERT_GL_NO_ERROR;
13129 }
13130
13132 inline  void  GLSetFence( GLuint fence, GLenum condition )
13133 {
13134   NVSG_GL_STATS_FCT_COUNT();
13135   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSetFence );
13136   glContext()->m_glFunctions->glSetFence( fence, condition );
13137   ASSERT_GL_NO_ERROR;
13138 }
13139
13141
13142 inline  void  GLSetWindowStereoMode( GLboolean displayMode )
13143 {
13144   NVSG_GL_STATS_FCT_COUNT();
13145   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glSetWindowStereoMode );
13146   glContext()->m_glFunctions->glSetWindowStereoMode( displayMode );
13147   ASSERT_GL_NO_ERROR;
13148 }
13149
13151
13152 inline  void  GLShadeModel( GLenum mode )
13153 {
13154 #if defined( GL_CACHING )
13155   GLContext * ctx = glContext();
13156 # if defined(GL_SUPPORT_RESET)
13157   ctx->m_previousAttributes.m_shadeModel = ctx->m_lightingAttributes.m_shadeModel;
13158 # endif
13159   if ( ctx->m_lightingAttributes.m_shadeModel != mode )
13160 #endif
13161   {
13162     NVSG_GL_STATS_FCT_COUNT();
13163     glShadeModel( mode );
13164     ASSERT_GL_NO_ERROR;
13165 #if defined( GL_CACHING )
13166     ctx->m_lightingAttributes.m_shadeModel = mode;
13167 #endif
13168   }
13169 }
13170
13175 inline void GLResetShadeModel()
13176 {
13177 #if defined(GL_SUPPORT_RESET)
13178   GLShadeModel( glContext()->m_previousAttributes.m_shadeModel );
13179 #else
13180   GLShadeModel( GL_SMOOTH );
13181 #endif
13182 }
13183
13185 inline  void  GLShaderSource( GLuint shader, GLsizei count, const GLcharARB* *string, const GLint *length )
13186 {
13187   NVSG_GL_STATS_FCT_COUNT();
13188   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glShaderSource );
13189   glContext()->m_glFunctions->glShaderSource( shader, count, string, length );
13190   ASSERT_GL_NO_ERROR;
13191 }
13192
13194 inline  void  GLStencilClearTag( GLsizei tagBits, GLuint clearTag )
13195 {
13196   NVSG_GL_STATS_FCT_COUNT();
13197   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glStencilClearTag );
13198   glContext()->m_glFunctions->glStencilClearTag( tagBits, clearTag );
13199   ASSERT_GL_NO_ERROR;
13200 }
13201
13203
13204 inline  void  GLStencilFunc( GLenum func, GLint ref, GLuint mask )
13205 {
13206 #if defined( GL_CACHING )
13207   GLContext * ctx = glContext();
13208 # if defined(GL_SUPPORT_RESET)
13209   ctx->m_previousAttributes.m_stencilFunc      = ctx->m_stencilBufferAttributes.m_stencilFunc;
13210   ctx->m_previousAttributes.m_stencilRef       = ctx->m_stencilBufferAttributes.m_stencilRef;
13211   ctx->m_previousAttributes.m_stencilValueMask = ctx->m_stencilBufferAttributes.m_stencilValueMask;
13212 # endif
13213   if (    ( ctx->m_stencilBufferAttributes.m_stencilFunc != func )
13214       ||  ( ctx->m_stencilBufferAttributes.m_stencilRef != ref )
13215       ||  ( ctx->m_stencilBufferAttributes.m_stencilValueMask != mask ) )
13216 #endif
13217   {
13218     NVSG_GL_STATS_FCT_COUNT();
13219     glStencilFunc( func, ref, mask );
13220     ASSERT_GL_NO_ERROR;
13221 #if defined( GL_CACHING )
13222     ctx->m_stencilBufferAttributes.m_stencilFunc = func;
13223     ctx->m_stencilBufferAttributes.m_stencilRef = ref;
13224     ctx->m_stencilBufferAttributes.m_stencilValueMask = mask;
13225 #endif
13226   }
13227 }
13228
13230 inline  void  GLStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask )
13231 {
13232   // NOTE: we should extend the cache for the stencil func to support values per face !
13233   NVSG_GL_STATS_FCT_COUNT();
13234   GLContext * ctx = glContext();
13235 # if defined(GL_SUPPORT_RESET)
13236   ctx->m_previousAttributes.m_stencilFunc      = ctx->m_stencilBufferAttributes.m_stencilFunc;
13237   ctx->m_previousAttributes.m_stencilRef       = ctx->m_stencilBufferAttributes.m_stencilRef;
13238   ctx->m_previousAttributes.m_stencilValueMask = ctx->m_stencilBufferAttributes.m_stencilValueMask;
13239 # endif
13240   if (    ( ctx->m_stencilBufferAttributes.m_stencilFunc != func )
13241       ||  ( ctx->m_stencilBufferAttributes.m_stencilRef != ref )
13242       ||  ( ctx->m_stencilBufferAttributes.m_stencilValueMask != mask ) )
13243   {
13244     NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glStencilFuncSeparate );
13245     glContext()->m_glFunctions->glStencilFuncSeparate( face, func, ref, mask );
13246     ASSERT_GL_NO_ERROR;
13247 #if defined( GL_CACHING )
13248     ctx->m_stencilBufferAttributes.m_stencilFunc = func;
13249     ctx->m_stencilBufferAttributes.m_stencilRef = ref;
13250     ctx->m_stencilBufferAttributes.m_stencilValueMask = mask;
13251 #endif
13252   }
13253 }
13254
13256 inline  void  GLStencilOpSeparate( GLenum face, GLenum fail, GLenum zfail, GLenum zpass )
13257 {
13258   NVSG_GL_STATS_FCT_COUNT();
13259   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glStencilOpSeparate );
13260   glContext()->m_glFunctions->glStencilOpSeparate( face, fail, zfail, zpass );
13261   ASSERT_GL_NO_ERROR;
13262 }
13263
13265 inline  void  GLStencilMaskSeparate( GLenum face, GLuint mask )
13266 {
13267   NVSG_GL_STATS_FCT_COUNT();
13268   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glStencilMaskSeparate );
13269   glContext()->m_glFunctions->glStencilMaskSeparate( face, mask );
13270   ASSERT_GL_NO_ERROR;
13271 }
13272
13278 inline void GLResetStencilFunc()
13279 {
13280 #if defined(GL_SUPPORT_RESET)
13281   GLContext * ctx = glContext();
13282   GLStencilFunc( ctx->m_previousAttributes.m_stencilFunc, ctx->m_previousAttributes.m_stencilRef
13283                , ctx->m_previousAttributes.m_stencilValueMask );
13284 #else
13285   GLStencilFunc( GL_ALWAYS, 0, ~0 );
13286 #endif
13287 }
13288
13290
13291 inline  void  GLStencilMask( GLuint mask )
13292 {
13293 #if defined( GL_CACHING )
13294   GLContext * ctx = glContext();
13295 # if defined(GL_SUPPORT_RESET)
13296   ctx->m_previousAttributes.m_stencilWriteMask = ctx->m_stencilBufferAttributes.m_stencilWriteMask;
13297 # endif
13298   if ( ctx->m_stencilBufferAttributes.m_stencilWriteMask != mask )
13299 #endif
13300   {
13301     NVSG_GL_STATS_FCT_COUNT();
13302     glStencilMask( mask );
13303     ASSERT_GL_NO_ERROR;
13304 #if defined( GL_CACHING )
13305     ctx->m_stencilBufferAttributes.m_stencilWriteMask = mask;
13306 #endif
13307   }
13308 }
13309
13314 inline void GLResetStencilMask()
13315 {
13316 #if defined(GL_SUPPORT_RESET)
13317   GLStencilMask( glContext()->m_previousAttributes.m_stencilWriteMask );
13318 #else
13319   GLStencilMask( ~0 );
13320 #endif
13321 }
13322
13324
13325 inline  void  GLStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
13326 {
13327 #if defined( GL_CACHING )
13328   GLContext * ctx = glContext();
13329 # if defined(GL_SUPPORT_RESET)
13330   ctx->m_previousAttributes.m_stencilFail          = ctx->m_stencilBufferAttributes.m_stencilFail;
13331   ctx->m_previousAttributes.m_stencilPassDepthFail = ctx->m_stencilBufferAttributes.m_stencilPassDepthFail;
13332   ctx->m_previousAttributes.m_stencilPassDepthPass = ctx->m_stencilBufferAttributes.m_stencilPassDepthPass;
13333 # endif
13334   if (    ( ctx->m_stencilBufferAttributes.m_stencilFail != fail )
13335       ||  ( ctx->m_stencilBufferAttributes.m_stencilPassDepthFail != zfail )
13336       ||  ( ctx->m_stencilBufferAttributes.m_stencilPassDepthPass != zpass ) )
13337 #endif
13338   {
13339     NVSG_GL_STATS_FCT_COUNT();
13340     glStencilOp( fail, zfail, zpass );
13341     ASSERT_GL_NO_ERROR;
13342 #if defined( GL_CACHING )
13343     ctx->m_stencilBufferAttributes.m_stencilFail = fail;
13344     ctx->m_stencilBufferAttributes.m_stencilPassDepthFail = zfail;
13345     ctx->m_stencilBufferAttributes.m_stencilPassDepthPass = zpass;
13346 #endif
13347   }
13348 }
13349
13355 inline void GLResetStencilOp()
13356 {
13357 #if defined(GL_SUPPORT_RESET)
13358   GLContext * ctx = glContext();
13359   GLStencilOp( ctx->m_previousAttributes.m_stencilFail
13360              , ctx->m_previousAttributes.m_stencilPassDepthFail
13361              , ctx->m_previousAttributes.m_stencilPassDepthPass );
13362 #else
13363   GLStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
13364 #endif
13365 }
13366
13368
13369 inline void GLStringMarker( GLsizei len, const GLvoid * string )
13370 {
13371   if( glContext()->m_glFunctions && glContext()->m_glFunctions->glStringMarker )
13372   {
13373     glContext()->m_glFunctions->glStringMarker( len, string );
13374     ASSERT_GL_NO_ERROR;
13375   }
13376 }
13377
13379
13380 inline void GLFrameTerminator( void )
13381 {
13382   if( glContext()->m_glFunctions &&
13383                             glContext()->m_glFunctions->glFrameTerminator )
13384   {
13385     glContext()->m_glFunctions->glFrameTerminator();
13386     ASSERT_GL_NO_ERROR;
13387   }
13388 }
13389
13391
13392 inline  GLboolean GLTestFence( GLuint fence )
13393 {
13394   NVSG_GL_STATS_FCT_COUNT();
13395   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTestFence );
13396   GLboolean ok = glContext()->m_glFunctions->glTestFence( fence );
13397   ASSERT_GL_NO_ERROR;
13398   return( ok );
13399 }
13400
13402
13403 inline  void  GLTexBuffer( GLenum target, GLenum internalformat, GLuint buffer )
13404 {
13405   NVSG_GL_STATS_FCT_COUNT();
13406   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexBuffer );
13407   glContext()->m_glFunctions->glTexBuffer( target, internalformat, buffer );
13408   ASSERT_GL_NO_ERROR;
13409 }
13410
13412
13413 inline  void  GLTexCoord1d( GLdouble s )
13414 {
13415   NVSG_GL_STATS_FCT_COUNT();
13416   glTexCoord1d( s );
13417   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13418 }
13419
13421
13422 inline  void  GLTexCoord1dv( const GLdouble *v )
13423 {
13424   NVSG_GL_STATS_FCT_COUNT();
13425   glTexCoord1dv( v );
13426   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13427 }
13428
13430
13431 inline  void  GLTexCoord1f( GLfloat s )
13432 {
13433   NVSG_GL_STATS_FCT_COUNT();
13434   glTexCoord1f( s );
13435   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13436 }
13437
13439
13440 inline  void  GLTexCoord1fv( const GLfloat *v )
13441 {
13442   NVSG_GL_STATS_FCT_COUNT();
13443   glTexCoord1fv( v );
13444   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13445 }
13446
13448
13449 inline  void  GLTexCoord1h( GLhalf s )
13450 {
13451   NVSG_GL_STATS_FCT_COUNT();
13452   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexCoord1h );
13453   glContext()->m_glFunctions->glTexCoord1h( s );
13454   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13455 }
13456
13458
13459 inline  void  GLTexCoord1hv( const GLhalf *v )
13460 {
13461   NVSG_GL_STATS_FCT_COUNT();
13462   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexCoord1hv );
13463   glContext()->m_glFunctions->glTexCoord1hv( v );
13464   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13465 }
13466
13468
13469 inline  void  GLTexCoord1i( GLint s )
13470 {
13471   NVSG_GL_STATS_FCT_COUNT();
13472   glTexCoord1i( s );
13473   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13474 }
13475
13477
13478 inline  void  GLTexCoord1iv( const GLint *v )
13479 {
13480   NVSG_GL_STATS_FCT_COUNT();
13481   glTexCoord1iv( v );
13482   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13483 }
13484
13486
13487 inline  void  GLTexCoord1s( GLshort s )
13488 {
13489   NVSG_GL_STATS_FCT_COUNT();
13490   glTexCoord1s( s );
13491   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13492 }
13493
13495
13496 inline  void  GLTexCoord1sv( const GLshort *v )
13497 {
13498   NVSG_GL_STATS_FCT_COUNT();
13499   glTexCoord1sv( v );
13500   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13501 }
13502
13504
13505 inline  void  GLTexCoord2d( GLdouble s, GLdouble t )
13506 {
13507   NVSG_GL_STATS_FCT_COUNT();
13508   glTexCoord2d( s, t );
13509   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13510 }
13511
13513
13514 inline  void  GLTexCoord2dv( const GLdouble *v )
13515 {
13516   NVSG_GL_STATS_FCT_COUNT();
13517   glTexCoord2dv( v );
13518   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13519 }
13520
13522
13523 inline  void  GLTexCoord2f( GLfloat s, GLfloat t )
13524 {
13525   NVSG_GL_STATS_FCT_COUNT();
13526   glTexCoord2f( s, t );
13527   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13528 }
13529
13531
13532 inline  void  GLTexCoord2fv( const GLfloat *v )
13533 {
13534   NVSG_GL_STATS_FCT_COUNT();
13535   glTexCoord2fv( v );
13536   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13537 }
13538
13540
13541 inline  void  GLTexCoord2h( GLhalf s, GLhalf t )
13542 {
13543   NVSG_GL_STATS_FCT_COUNT();
13544   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexCoord2h );
13545   glContext()->m_glFunctions->glTexCoord2h( s, t );
13546   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13547 }
13548
13550
13551 inline  void  GLTexCoord2hv( const GLhalf *v )
13552 {
13553   NVSG_GL_STATS_FCT_COUNT();
13554   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexCoord2hv );
13555   glContext()->m_glFunctions->glTexCoord2hv( v );
13556   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13557 }
13558
13560
13561 inline  void  GLTexCoord2i( GLint s, GLint t )
13562 {
13563   NVSG_GL_STATS_FCT_COUNT();
13564   glTexCoord2i( s, t );
13565   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13566 }
13567
13569
13570 inline  void  GLTexCoord2iv( const GLint *v )
13571 {
13572   NVSG_GL_STATS_FCT_COUNT();
13573   glTexCoord2iv( v );
13574   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13575 }
13576
13578
13579 inline  void  GLTexCoord2s( GLshort s, GLshort t )
13580 {
13581   NVSG_GL_STATS_FCT_COUNT();
13582   glTexCoord2s( s, t );
13583   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13584 }
13585
13587
13588 inline  void  GLTexCoord2sv( const GLshort *v )
13589 {
13590   NVSG_GL_STATS_FCT_COUNT();
13591   glTexCoord2sv( v );
13592   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13593 }
13594
13596
13597 inline  void  GLTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
13598 {
13599   NVSG_GL_STATS_FCT_COUNT();
13600   glTexCoord3d( s, t, r );
13601   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13602 }
13603
13605
13606 inline  void  GLTexCoord3dv( const GLdouble *v )
13607 {
13608   NVSG_GL_STATS_FCT_COUNT();
13609   glTexCoord3dv( v );
13610   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13611 }
13612
13614
13615 inline  void  GLTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
13616 {
13617   NVSG_GL_STATS_FCT_COUNT();
13618   glTexCoord3f( s, t, r );
13619   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13620 }
13621
13623
13624 inline  void  GLTexCoord3fv( const GLfloat *v )
13625 {
13626   NVSG_GL_STATS_FCT_COUNT();
13627   glTexCoord3fv( v );
13628   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13629 }
13630
13632
13633 inline  void  GLTexCoord3h( GLhalf s, GLhalf t, GLhalf r )
13634 {
13635   NVSG_GL_STATS_FCT_COUNT();
13636   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexCoord3h );
13637   glContext()->m_glFunctions->glTexCoord3h( s, t, r );
13638   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13639 }
13640
13642
13643 inline  void  GLTexCoord3hv( const GLhalf *v )
13644 {
13645   NVSG_GL_STATS_FCT_COUNT();
13646   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexCoord3hv );
13647   glContext()->m_glFunctions->glTexCoord3hv( v );
13648   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13649 }
13650
13652
13653 inline  void  GLTexCoord3i( GLint s, GLint t, GLint r )
13654 {
13655   NVSG_GL_STATS_FCT_COUNT();
13656   glTexCoord3i( s, t, r );
13657   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13658 }
13659
13661
13662 inline  void  GLTexCoord3iv( const GLint *v )
13663 {
13664   NVSG_GL_STATS_FCT_COUNT();
13665   glTexCoord3iv( v );
13666   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13667 }
13668
13670
13671 inline  void  GLTexCoord3s( GLshort s, GLshort t, GLshort r )
13672 {
13673   NVSG_GL_STATS_FCT_COUNT();
13674   glTexCoord3s( s, t, r );
13675   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13676 }
13677
13679
13680 inline  void  GLTexCoord3sv( const GLshort *v )
13681 {
13682   NVSG_GL_STATS_FCT_COUNT();
13683   glTexCoord3sv( v );
13684   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13685 }
13686
13688
13689 inline  void  GLTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
13690 {
13691   NVSG_GL_STATS_FCT_COUNT();
13692   glTexCoord4d( s, t, r, q );
13693   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13694 }
13695
13697
13698 inline  void  GLTexCoord4dv( const GLdouble *v )
13699 {
13700   NVSG_GL_STATS_FCT_COUNT();
13701   glTexCoord4dv( v );
13702   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13703 }
13704
13706
13707 inline  void  GLTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
13708 {
13709   NVSG_GL_STATS_FCT_COUNT();
13710   glTexCoord4f( s, t, r, q );
13711   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13712 }
13713
13715
13716 inline  void  GLTexCoord4fv( const GLfloat *v )
13717 {
13718   NVSG_GL_STATS_FCT_COUNT();
13719   glTexCoord4fv( v );
13720   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13721 }
13722
13724
13725 inline  void  GLTexCoord4h( GLhalf s, GLhalf t, GLhalf r, GLhalf q )
13726 {
13727   NVSG_GL_STATS_FCT_COUNT();
13728   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexCoord4h );
13729   glContext()->m_glFunctions->glTexCoord4h( s, t, r, q );
13730   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13731 }
13732
13734
13735 inline  void  GLTexCoord4hv( const GLhalf *v )
13736 {
13737   NVSG_GL_STATS_FCT_COUNT();
13738   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexCoord4hv );
13739   glContext()->m_glFunctions->glTexCoord4hv( v );
13740   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13741 }
13742
13744
13745 inline  void  GLTexCoord4i( GLint s, GLint t, GLint r, GLint q )
13746 {
13747   NVSG_GL_STATS_FCT_COUNT();
13748   glTexCoord4i( s, t, r, q );
13749   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13750 }
13751
13753
13754 inline  void  GLTexCoord4iv( const GLint *v )
13755 {
13756   NVSG_GL_STATS_FCT_COUNT();
13757   glTexCoord4iv( v );
13758   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13759 }
13760
13762
13763 inline  void  GLTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
13764 {
13765   NVSG_GL_STATS_FCT_COUNT();
13766   glTexCoord4s( s, t, r, q );
13767   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13768 }
13769
13771
13772 inline  void  GLTexCoord4sv( const GLshort *v )
13773 {
13774   NVSG_GL_STATS_FCT_COUNT();
13775   glTexCoord4sv( v );
13776   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
13777 }
13778
13780
13781 inline  void  GLTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
13782 {
13783 #if defined( GL_CACHING )
13784   _GLUpdateClientActiveTexture();
13785   NVSG_ASSERT(glContext()->m_vertexArrayAttributes.m_clientTextureActive<8);
13786 #endif
13787   NVSG_GL_STATS_TEX_COORD_POINTER( size, type, stride, pointer );
13788   glTexCoordPointer( size, type, stride, pointer );
13789   ASSERT_GL_NO_ERROR;
13790 }
13791
13793
13795 inline  void  GLTextureEnvColor( const GLfloat * params )
13796 {
13797 #if defined( GL_CACHING )
13798   if ( !equal4fv( &glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envColor[0], params ) )
13799   {
13800     _GLUpdateActiveTexture();
13801 # if !defined(NDEBUG)
13802     GLfloat tmp[4];
13803     glGetTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, tmp );
13804     NVSG_ASSERT( equal4fv(&glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envColor[0], tmp ) );
13805 # endif
13806 #endif
13807     _GLTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params );
13808 #if defined( GL_CACHING )
13809     memcpy( &glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envColor[0], params, 4*sizeof(float) );
13810   }
13811 #endif
13812 }
13813
13815
13817 inline  void  GLTextureEnvMode( GLint param )
13818 {
13819 #if defined( GL_CACHING )
13820   if ( glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envMode != param )
13821   {
13822     _GLUpdateActiveTexture();
13823 # if !defined(NDEBUG)
13824     GLint tem;
13825     glGetTexEnviv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &tem );
13826     NVSG_ASSERT( glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envMode == tem );
13827 # endif
13828 #endif
13829     _GLTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, param );
13830 #if defined( GL_CACHING )
13831     glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envMode = param;
13832   }
13833 #endif
13834 }
13835
13837
13838 inline  void  GLTexEnvf( GLenum target, GLenum pname, GLfloat param )
13839 {
13840   NVSG_ASSERT( ( target == GL_TEXTURE_ENV ) );
13841 #if defined( GL_CACHING )
13842   switch( pname )
13843   {
13844     case GL_TEXTURE_ENV_MODE :
13845       GLTextureEnvMode( (GLint)param );
13846       break;
13847     default :
13848       _GLUpdateActiveTexture();
13849       _GLTexEnvf( target, pname, param );
13850       break;
13851   }
13852 #else
13853   _GLTexEnvf( target, pname, param );
13854 #endif
13855 }
13856
13858
13859 inline  void  GLTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
13860 {
13861   NVSG_ASSERT( ( target == GL_TEXTURE_ENV ) );
13862 #if defined( GL_CACHING )
13863   switch( pname )
13864   {
13865     case GL_TEXTURE_ENV_COLOR :
13866       GLTextureEnvColor( params );
13867       break;
13868     case GL_TEXTURE_ENV_MODE :
13869       GLTextureEnvMode( (GLint)params[0] );
13870       break;
13871     default :
13872       _GLUpdateActiveTexture();
13873       _GLTexEnvfv( target, pname, params );
13874       break;
13875   }
13876 #else
13877   _GLTexEnvfv( target, pname, params );
13878 #endif
13879 }
13880
13882
13883 inline  void  GLTexEnvi( GLenum target, GLenum pname, GLint param )
13884 {
13885 #if defined( GL_CACHING )
13886   switch( pname )
13887   {
13888     case GL_TEXTURE_ENV_MODE :
13889       GLTextureEnvMode( param );
13890       break;
13891     default :
13892       _GLUpdateActiveTexture();
13893       _GLTexEnvi( target, pname, param );
13894       break;
13895   }
13896 #else
13897   _GLTexEnvi( target, pname, param );
13898 #endif
13899 }
13900
13902
13903 inline  void  GLTexEnviv( GLenum target, GLenum pname, const GLint *params )
13904 {
13905 #if defined( GL_CACHING )
13906   switch( pname )
13907   {
13908     case GL_TEXTURE_ENV_MODE :
13909       GLTextureEnvMode( params[0] );
13910       break;
13911     default :
13912       _GLUpdateActiveTexture();
13913       _GLTexEnviv( target, pname, params );
13914       break;
13915   }
13916 #else
13917   _GLTexEnviv( target, pname, params );
13918 #endif
13919 }
13920
13922
13923 inline  void  GLTexGend( GLenum coord, GLenum pname, GLdouble param )
13924 {
13925 #if defined(GL_CACHING)
13926   _GLUpdateActiveTexture();
13927 #endif
13928   NVSG_GL_STATS_FCT_COUNT();
13929   glTexGend( coord, pname, param );
13930   ASSERT_GL_NO_ERROR;
13931 }
13932
13934
13935 inline  void  GLTexGenf( GLenum coord, GLenum pname, GLfloat param )
13936 {
13937 #if defined(GL_CACHING)
13938   _GLUpdateActiveTexture();
13939 #endif
13940   NVSG_GL_STATS_FCT_COUNT();
13941   glTexGenf( coord, pname, param );
13942   ASSERT_GL_NO_ERROR;
13943 }
13944
13946
13947 inline  void  GLTexGenfv( GLenum coord, GLenum pname, const GLfloat *param )
13948 {
13949 #if defined(GL_CACHING)
13950   _GLUpdateActiveTexture();
13951 #endif
13952   NVSG_GL_STATS_FCT_COUNT();
13953   glTexGenfv( coord, pname, param );
13954   ASSERT_GL_NO_ERROR;
13955 }
13956
13958
13959 inline  void  GLTexGeni( GLenum coord, GLenum pname, GLint param )
13960 {
13961 #if defined(GL_CACHING)
13962   _GLUpdateActiveTexture();
13963 #endif
13964   NVSG_GL_STATS_FCT_COUNT();
13965   glTexGeni( coord, pname, param );
13966   ASSERT_GL_NO_ERROR;
13967 }
13968
13970
13971 inline  void  GLTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
13972 {
13973 #if defined(GL_CACHING)
13974   _GLUpdateActiveTexture();
13975 #endif
13976   NVSG_GL_STATS_FCT_COUNT();
13977   glTexImage1D( target, level, internalformat, width, border, format, type, pixels );
13978   ASSERT_GL_NO_ERROR;
13979 }
13980
13982
13983 inline  void  GLTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border
13984                           , GLenum format, GLenum type, const GLvoid *pixels )
13985 {
13986 #if defined(GL_CACHING)
13987   _GLUpdateActiveTexture();
13988 #endif
13989   NVSG_GL_STATS_TEX_IMAGE2D( target, level, internalformat, width, height, border, format, type, pixels );
13990   glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
13991   ASSERT_GL_NO_ERROR;
13992 }
13993
13995
13997 inline  void  GLTexImage3D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type, const void* pixels)
13998 {
13999 #if defined(GL_CACHING)
14000   _GLUpdateActiveTexture();
14001 #endif
14002   NVSG_GL_STATS_FCT_COUNT();
14003   NVSG_ASSERT(GLGetVersion()>=12 || GLIsExtensionAvailable("GL_EXT_texture3D"));
14004   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexImage3D );
14005   glContext()->m_glFunctions->glTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels );
14006   ASSERT_GL_NO_ERROR;
14007 }
14008
14010
14012 inline  void  GLTextureBorderColor( GLenum target, const GLfloat *params )
14013 {
14014 #if defined( GL_CACHING )
14015   _GLUpdateActiveTexture();
14016 #endif
14017   _GLTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, params );
14018 }
14019
14021
14023 inline  void  GLTextureMagFilter( GLenum target, GLint param )
14024 {
14025 #if defined( GL_CACHING )
14026   _GLUpdateActiveTexture();
14027 #endif
14028   _GLTexParameteri( target, GL_TEXTURE_MAG_FILTER, param );
14029 }
14030
14032
14034 inline  void  GLTextureMinFilter( GLenum target, GLint param )
14035 {
14036 #if defined( GL_CACHING )
14037   _GLUpdateActiveTexture();
14038 #endif
14039   _GLTexParameteri( target, GL_TEXTURE_MIN_FILTER, param );
14040 }
14041
14043
14045 inline  void  GLTextureWrapR( GLenum target, GLint param )
14046 {
14047 #if defined( GL_CACHING )
14048   _GLUpdateActiveTexture();
14049 #endif
14050   _GLTexParameteri( target, GL_TEXTURE_WRAP_R, param );
14051 }
14052
14054
14056 inline  void  GLTextureWrapS( GLenum target, GLint param )
14057 {
14058 #if defined( GL_CACHING )
14059   _GLUpdateActiveTexture();
14060 #endif
14061   _GLTexParameteri( target, GL_TEXTURE_WRAP_S, param );
14062 }
14063
14065
14067 inline  void  GLTextureWrapT( GLenum target, GLint param )
14068 {
14069 #if defined( GL_CACHING )
14070   _GLUpdateActiveTexture();
14071 #endif
14072   _GLTexParameteri( target, GL_TEXTURE_WRAP_T, param );
14073 }
14074
14076
14077 inline  void  GLTrackMatrix( GLenum target, GLuint address, GLenum matrix, GLenum transform )
14078 {
14079   NVSG_GL_STATS_FCT_COUNT();
14080   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTrackMatrixNV );
14081   glContext()->m_glFunctions->glTrackMatrixNV( target, address, matrix, transform );
14082   ASSERT_GL_NO_ERROR;
14083 }
14084
14086
14087 inline  void  GLTransformFeedbackAttribs( GLuint count, const GLint *attribs, GLenum bufferMode )
14088 {
14089   NVSG_GL_STATS_FCT_COUNT();
14090   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTransformFeedbackAttribsNV );
14091   glContext()->m_glFunctions->glTransformFeedbackAttribsNV( count, attribs, bufferMode );
14092   ASSERT_GL_NO_ERROR;
14093 }
14094
14096
14097 inline  void  GLTransformFeedbackVaryings( GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode )
14098 {
14099   NVSG_GL_STATS_FCT_COUNT();
14100   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTransformFeedbackVaryingsNV );
14101   glContext()->m_glFunctions->glTransformFeedbackVaryingsNV( program, count, locations, bufferMode );
14102   ASSERT_GL_NO_ERROR;
14103 }
14104
14106
14107 inline  void  GLTexParameterf( GLenum target, GLenum pname, GLfloat param )
14108 {
14109 #if defined( GL_CACHING )
14110   switch( pname )
14111   {
14112     case GL_TEXTURE_BORDER_COLOR :
14113       NVSG_ASSERT( false );
14114       break;
14115     case GL_TEXTURE_MAG_FILTER :
14116       GLTextureMagFilter( target, (GLint)param );
14117       break;
14118     case GL_TEXTURE_MIN_FILTER :
14119       GLTextureMinFilter( target, (GLint)param );
14120       break;
14121     case GL_TEXTURE_WRAP_R :
14122       GLTextureWrapR( target, (GLint)param );
14123       break;
14124     case GL_TEXTURE_WRAP_S :
14125       GLTextureWrapS( target, (GLint)param );
14126       break;
14127     case GL_TEXTURE_WRAP_T :
14128       GLTextureWrapT( target, (GLint)param );
14129       break;
14130     default :
14131       _GLUpdateActiveTexture();
14132       _GLTexParameterf( target, pname, param );
14133       break;
14134   }
14135 #else
14136   _GLTexParameterf( target, pname, param );
14137 #endif
14138 }
14139
14141
14142 inline  void  GLTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
14143 {
14144 #if defined( GL_CACHING )
14145   switch( pname )
14146   {
14147     case GL_TEXTURE_BORDER_COLOR :
14148       GLTextureBorderColor( target, params );
14149       break;
14150     case GL_TEXTURE_MAG_FILTER :
14151       GLTextureMagFilter( target, (GLint)params[0] );
14152       break;
14153     case GL_TEXTURE_MIN_FILTER :
14154       GLTextureMinFilter( target, (GLint)params[0] );
14155       break;
14156     case GL_TEXTURE_WRAP_R :
14157       GLTextureWrapR( target, (GLint)params[0] );
14158       break;
14159     case GL_TEXTURE_WRAP_S :
14160       GLTextureWrapS( target, (GLint)params[0] );
14161       break;
14162     case GL_TEXTURE_WRAP_T :
14163       GLTextureWrapT( target, (GLint)params[0] );
14164       break;
14165     default :
14166       _GLUpdateActiveTexture();
14167       _GLTexParameterfv( target, pname, params );
14168       break;
14169   }
14170 #else
14171   _GLTexParameterfv( target, pname, params );
14172 #endif
14173 }
14174
14176
14177 inline  void  GLTexParameteri( GLenum target, GLenum pname, GLint param )
14178 {
14179 #if defined( GL_CACHING )
14180   switch( pname )
14181   {
14182     case GL_TEXTURE_BORDER_COLOR :
14183       NVSG_ASSERT( false );
14184       break;
14185     case GL_TEXTURE_MAG_FILTER :
14186       GLTextureMagFilter( target, param );
14187       break;
14188     case GL_TEXTURE_MIN_FILTER :
14189       GLTextureMinFilter( target, param );
14190       break;
14191     case GL_TEXTURE_WRAP_R :
14192       GLTextureWrapR( target, param );
14193       break;
14194     case GL_TEXTURE_WRAP_S :
14195       GLTextureWrapS( target, param );
14196       break;
14197     case GL_TEXTURE_WRAP_T :
14198       GLTextureWrapT( target, param );
14199       break;
14200     default :
14201       _GLUpdateActiveTexture();
14202       _GLTexParameteri( target, pname, param );
14203       break;
14204   }
14205 #else
14206   _GLTexParameteri( target, pname, param );
14207 #endif
14208 }
14209
14211
14212 inline  void  GLTexParameterIiv( GLenum target, GLenum pname, const GLint *params )
14213 {
14214   NVSG_GL_STATS_FCT_COUNT();
14215   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexParameterIiv );
14216   glContext()->m_glFunctions->glTexParameterIiv( target, pname, params );
14217   ASSERT_GL_NO_ERROR;
14218 }
14219
14221
14222 inline  void  GLTexParameterIuiv( GLenum target, GLenum pname, const GLuint *params )
14223 {
14224   NVSG_GL_STATS_FCT_COUNT();
14225   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexParameterIuiv );
14226   glContext()->m_glFunctions->glTexParameterIuiv( target, pname, params );
14227   ASSERT_GL_NO_ERROR;
14228 }
14229
14231
14232 inline  void  GLTexParameteriv( GLenum target, GLenum pname, const GLint *params )
14233 {
14234 #if defined( GL_CACHING )
14235   switch( pname )
14236   {
14237     case GL_TEXTURE_BORDER_COLOR :
14238       {
14239         GLfloat fParams[4];
14240         GLintToGLfloat( params, fParams );
14241         GLTextureBorderColor( target, fParams );
14242       }
14243       break;
14244     case GL_TEXTURE_MAG_FILTER :
14245       GLTextureMagFilter( target, params[0] );
14246       break;
14247     case GL_TEXTURE_MIN_FILTER :
14248       GLTextureMinFilter( target, params[0] );
14249       break;
14250     case GL_TEXTURE_WRAP_R :
14251       GLTextureWrapR( target, params[0] );
14252       break;
14253     case GL_TEXTURE_WRAP_S :
14254       GLTextureWrapS( target, params[0] );
14255       break;
14256     case GL_TEXTURE_WRAP_T :
14257       GLTextureWrapT( target, params[0] );
14258       break;
14259     default :
14260       _GLUpdateActiveTexture();
14261       _GLTexParameteriv( target, pname, params );
14262       break;
14263   }
14264 #else
14265   _GLTexParameteriv( target, pname, params );
14266 #endif
14267 }
14268
14270
14271 inline  void  GLTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
14272 {
14273 #if defined(GL_CACHING)
14274   _GLUpdateActiveTexture();
14275 #endif
14276   NVSG_GL_STATS_FCT_COUNT();
14277   glTexSubImage1D( target, level, xoffset, width, format, type, pixels );
14278   ASSERT_GL_NO_ERROR;
14279 }
14280
14282
14283 inline  void  GLTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
14284 {
14285 #if defined(GL_CACHING)
14286   _GLUpdateActiveTexture();
14287 #endif
14288   NVSG_GL_STATS_FCT_COUNT();
14289   glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
14290   ASSERT_GL_NO_ERROR;
14291 }
14292
14294
14295 inline  void  GLTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels )
14296 {
14297 #if defined(GL_CACHING)
14298   _GLUpdateActiveTexture();
14299 #endif
14300   NVSG_GL_STATS_FCT_COUNT();
14301   NVSG_ASSERT(GLGetVersion()>=12 || GLIsExtensionAvailable("GL_EXT_texture3D"));
14302   NVSG_ASSERT(glContext()->m_glFunctions && glContext()->m_glFunctions->glTexSubImage3D);
14303   glContext()->m_glFunctions->glTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
14304   ASSERT_GL_NO_ERROR;
14305 }
14306
14308
14309 inline  void  GLTranslated( GLdouble x, GLdouble y, GLdouble z )
14310 {
14311   NVSG_GL_STATS_TRANSLATED( x, y, z );
14312 #if defined( GL_CACHING )
14313   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
14314   { // note: we have a texture matrix stack per unit
14315     _GLUpdateActiveTexture();
14316   }
14317 #endif
14318   glTranslated( x, y, z );
14319   ASSERT_GL_NO_ERROR;
14320 }
14321
14323
14324 inline  void  GLTranslatef( GLfloat x, GLfloat y, GLfloat z )
14325 {
14326   NVSG_GL_STATS_TRANSLATEF( x, y, z );
14327 #if defined( GL_CACHING )
14328   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
14329   { // note: we have a texture matrix stack per unit
14330     _GLUpdateActiveTexture();
14331   }
14332 #endif
14333   glTranslatef( x, y, z );
14334   ASSERT_GL_NO_ERROR;
14335 }
14336
14338 inline  GLboolean GLValidBackBufferHint( GLint x, GLint y, GLsizei width, GLsizei height )
14339 {
14340   NVSG_GL_STATS_FCT_COUNT();
14341   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glValidBackBufferHint );
14342   GLboolean ok = glContext()->m_glFunctions->glValidBackBufferHint( x, y, width, height );
14343   ASSERT_GL_NO_ERROR;
14344   return( ok );
14345 }
14346
14348
14349 inline  void  GLVertex2d( GLdouble x, GLdouble y )
14350 {
14351   NVSG_GL_STATS_FCT_COUNT();
14352   glVertex2d( x, y );
14353   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14354 }
14355
14357
14358 inline  void  GLVertex2dv( const GLdouble *v )
14359 {
14360   NVSG_GL_STATS_FCT_COUNT();
14361   glVertex2dv( v );
14362   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14363 }
14364
14366
14367 inline  void  GLVertex2f( GLfloat x, GLfloat y )
14368 {
14369   NVSG_GL_STATS_FCT_COUNT();
14370   glVertex2f( x, y );
14371   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14372 }
14373
14375
14376 inline  void  GLVertex2fv( const GLfloat *v )
14377 {
14378   NVSG_GL_STATS_FCT_COUNT();
14379   glVertex2fv( v );
14380   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14381 }
14382
14384
14385 inline  void  GLVertex2h( GLhalf x, GLhalf y )
14386 {
14387   NVSG_GL_STATS_FCT_COUNT();
14388   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertex2h );
14389   glContext()->m_glFunctions->glVertex2h( x, y );
14390   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14391 }
14392
14394
14395 inline  void  GLVertex2hv( const GLhalf *v )
14396 {
14397   NVSG_GL_STATS_FCT_COUNT();
14398   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertex2hv );
14399   glContext()->m_glFunctions->glVertex2hv( v );
14400   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14401 }
14402
14404
14405 inline  void  GLVertex2i( GLint x, GLint y )
14406 {
14407   NVSG_GL_STATS_FCT_COUNT();
14408   glVertex2i( x, y );
14409   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14410 }
14411
14413
14414 inline  void  GLVertex2iv( const GLint *v )
14415 {
14416   NVSG_GL_STATS_FCT_COUNT();
14417   glVertex2iv( v );
14418   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14419 }
14420
14422
14423 inline  void  GLVertex2s( GLshort x, GLshort y )
14424 {
14425   NVSG_GL_STATS_FCT_COUNT();
14426   glVertex2s( x, y );
14427   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14428 }
14429
14431
14432 inline  void  GLVertex2sv( const GLshort *v )
14433 {
14434   NVSG_GL_STATS_FCT_COUNT();
14435   glVertex2sv( v );
14436   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14437 }
14438
14440
14441 inline  void  GLVertex3d( GLdouble x, GLdouble y, GLdouble z )
14442 {
14443   NVSG_GL_STATS_FCT_COUNT();
14444   glVertex3d( x, y, z );
14445   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14446 }
14447
14449
14450 inline  void  GLVertex3dv( const GLdouble *v )
14451 {
14452   NVSG_GL_STATS_FCT_COUNT();
14453   glVertex3dv( v );
14454   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14455 }
14456
14458
14459 inline  void  GLVertex3f( GLfloat x, GLfloat y, GLfloat z )
14460 {
14461   NVSG_GL_STATS_FCT_COUNT();
14462   glVertex3f( x, y, z );
14463   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14464 }
14465
14467
14468 inline  void  GLVertex3fv( const GLfloat *v )
14469 {
14470   NVSG_GL_STATS_FCT_COUNT();
14471   glVertex3fv( v );
14472   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14473 }
14474
14476
14477 inline  void  GLVertex3h( GLhalf x, GLhalf y, GLhalf z )
14478 {
14479   NVSG_GL_STATS_FCT_COUNT();
14480   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertex3h );
14481   glContext()->m_glFunctions->glVertex3h( x, y, z );
14482   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14483 }
14484
14486
14487 inline  void  GLVertex3hv( const GLhalf *v )
14488 {
14489   NVSG_GL_STATS_FCT_COUNT();
14490   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertex3hv );
14491   glContext()->m_glFunctions->glVertex3hv( v );
14492   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14493 }
14494
14496
14497 inline  void  GLVertex3i( GLint x, GLint y, GLint z )
14498 {
14499   NVSG_GL_STATS_FCT_COUNT();
14500   glVertex3i( x, y, z );
14501   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14502 }
14503
14505
14506 inline  void  GLVertex3iv( const GLint *v )
14507 {
14508   NVSG_GL_STATS_FCT_COUNT();
14509   glVertex3iv( v );
14510   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14511 }
14512
14514
14515 inline  void  GLVertex3s( GLshort x, GLshort y, GLshort z )
14516 {
14517   NVSG_GL_STATS_FCT_COUNT();
14518   glVertex3s( x, y, z );
14519   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14520 }
14521
14523
14524 inline  void  GLVertex3sv( const GLshort *v )
14525 {
14526   NVSG_GL_STATS_FCT_COUNT();
14527   glVertex3sv( v );
14528   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14529 }
14530
14532
14533 inline  void  GLVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
14534 {
14535   NVSG_GL_STATS_FCT_COUNT();
14536   glVertex4d( x, y, z, w );
14537   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14538 }
14539
14541
14542 inline  void  GLVertex4dv( const GLdouble *v )
14543 {
14544   NVSG_GL_STATS_FCT_COUNT();
14545   glVertex4dv( v );
14546   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14547 }
14548
14550
14551 inline  void  GLVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
14552 {
14553   NVSG_GL_STATS_FCT_COUNT();
14554   glVertex4f( x, y, z, w );
14555   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14556 }
14557
14559
14560 inline  void  GLVertex4fv( const GLfloat *v )
14561 {
14562   NVSG_GL_STATS_FCT_COUNT();
14563   glVertex4fv( v );
14564   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14565 }
14566
14568
14569 inline  void  GLVertex4h( GLhalf x, GLhalf y, GLhalf z, GLhalf w )
14570 {
14571   NVSG_GL_STATS_FCT_COUNT();
14572   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertex4h );
14573   glContext()->m_glFunctions->glVertex4h( x, y, z, w );
14574   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14575 }
14576
14578
14579 inline  void  GLVertex4hv( const GLhalf *v )
14580 {
14581   NVSG_GL_STATS_FCT_COUNT();
14582   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertex4hv );
14583   glContext()->m_glFunctions->glVertex4hv( v );
14584   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14585 }
14586
14588
14589 inline  void  GLVertex4i( GLint x, GLint y, GLint z, GLint w )
14590 {
14591   NVSG_GL_STATS_FCT_COUNT();
14592   glVertex4i( x, y, z, w );
14593   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14594 }
14595
14597
14598 inline  void  GLVertex4iv( const GLint *v )
14599 {
14600   NVSG_GL_STATS_FCT_COUNT();
14601   glVertex4iv( v );
14602   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14603 }
14604
14606
14607 inline  void  GLVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
14608 {
14609   NVSG_GL_STATS_FCT_COUNT();
14610   glVertex4s( x, y, z, w );
14611   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14612 }
14613
14615
14616 inline  void  GLVertex4sv( const GLshort *v )
14617 {
14618   NVSG_GL_STATS_FCT_COUNT();
14619   glVertex4sv( v );
14620   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14621 }
14622
14624
14625 inline  void  GLVertexArrayRange( GLsizei size, const GLvoid *pointer )
14626 {
14627   NVSG_GL_STATS_FCT_COUNT();
14628   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexArrayRange );
14629   glContext()->m_glFunctions->glVertexArrayRange( size, pointer );
14630   ASSERT_GL_NO_ERROR;
14631 }
14632
14634 inline  void  GLVertexAttrib1d( GLuint index, GLdouble x )
14635 {
14636   NVSG_GL_STATS_FCT_COUNT();
14637   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib1d );
14638   glContext()->m_glFunctions->glVertexAttrib1d( index, x );
14639   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14640 }
14641
14643 inline  void  GLVertexAttrib1dv( GLuint index, const GLdouble *v )
14644 {
14645   NVSG_GL_STATS_FCT_COUNT();
14646   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib1dv );
14647   glContext()->m_glFunctions->glVertexAttrib1dv( index, v );
14648   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14649 }
14650
14652 inline  void  GLVertexAttrib1f( GLuint index, GLfloat x )
14653 {
14654   NVSG_GL_STATS_FCT_COUNT();
14655   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib1f );
14656   glContext()->m_glFunctions->glVertexAttrib1f( index, x );
14657   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14658 }
14659
14661 inline  void  GLVertexAttrib1fv( GLuint index, const GLfloat *v )
14662 {
14663   NVSG_GL_STATS_FCT_COUNT();
14664   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib1fv );
14665   glContext()->m_glFunctions->glVertexAttrib1fv( index, v );
14666   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14667 }
14668
14670 inline  void  GLVertexAttrib1h( GLuint index, GLhalf x )
14671 {
14672   NVSG_GL_STATS_FCT_COUNT();
14673   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib1h );
14674   glContext()->m_glFunctions->glVertexAttrib1h( index, x );
14675   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14676 }
14677
14679 inline  void  GLVertexAttrib1hv( GLuint index, const GLhalf *v )
14680 {
14681   NVSG_GL_STATS_FCT_COUNT();
14682   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib1hv );
14683   glContext()->m_glFunctions->glVertexAttrib1hv( index, v );
14684   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14685 }
14686
14688 inline  void  GLVertexAttrib1s( GLuint index, GLshort x )
14689 {
14690   NVSG_GL_STATS_FCT_COUNT();
14691   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib1s );
14692   glContext()->m_glFunctions->glVertexAttrib1s( index, x );
14693   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14694 }
14695
14697 inline  void  GLVertexAttrib1sv( GLuint index, const GLshort *v )
14698 {
14699   NVSG_GL_STATS_FCT_COUNT();
14700   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib1sv );
14701   glContext()->m_glFunctions->glVertexAttrib1sv( index, v );
14702   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14703 }
14704
14706 inline  void  GLVertexAttrib2d( GLuint index, GLdouble x, GLdouble y )
14707 {
14708   NVSG_GL_STATS_FCT_COUNT();
14709   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib2d );
14710   glContext()->m_glFunctions->glVertexAttrib2d( index, x, y );
14711   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14712 }
14713
14715 inline  void  GLVertexAttrib2dv( GLuint index, const GLdouble *v )
14716 {
14717   NVSG_GL_STATS_FCT_COUNT();
14718   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib2dv );
14719   glContext()->m_glFunctions->glVertexAttrib2dv( index, v );
14720   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14721 }
14722
14724 inline  void  GLVertexAttrib2f( GLuint index, GLfloat x, GLfloat y )
14725 {
14726   NVSG_GL_STATS_FCT_COUNT();
14727   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib2f );
14728   glContext()->m_glFunctions->glVertexAttrib2f( index, x, y );
14729   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14730 }
14731
14733 inline  void  GLVertexAttrib2fv( GLuint index, const GLfloat *v )
14734 {
14735   NVSG_GL_STATS_FCT_COUNT();
14736   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib2fv );
14737   glContext()->m_glFunctions->glVertexAttrib2fv( index, v );
14738   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14739 }
14740
14742 inline  void  GLVertexAttrib2h( GLuint index, GLhalf x, GLhalf y )
14743 {
14744   NVSG_GL_STATS_FCT_COUNT();
14745   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib2h );
14746   glContext()->m_glFunctions->glVertexAttrib2h( index, x, y );
14747   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14748 }
14749
14751 inline  void  GLVertexAttrib2hv( GLuint index, const GLhalf *v )
14752 {
14753   NVSG_GL_STATS_FCT_COUNT();
14754   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib2hv );
14755   glContext()->m_glFunctions->glVertexAttrib2hv( index, v );
14756   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14757 }
14758
14760 inline  void  GLVertexAttrib2s( GLuint index, GLshort x, GLshort y )
14761 {
14762   NVSG_GL_STATS_FCT_COUNT();
14763   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib2s );
14764   glContext()->m_glFunctions->glVertexAttrib2s( index, x, y );
14765   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14766 }
14767
14769 inline  void  GLVertexAttrib2sv( GLuint index, const GLshort *v )
14770 {
14771   NVSG_GL_STATS_FCT_COUNT();
14772   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib2sv );
14773   glContext()->m_glFunctions->glVertexAttrib2sv( index, v );
14774   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14775 }
14776
14778 inline  void  GLVertexAttrib3d( GLuint index, GLdouble x, GLdouble y, GLdouble z )
14779 {
14780   NVSG_GL_STATS_FCT_COUNT();
14781   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib3d );
14782   glContext()->m_glFunctions->glVertexAttrib3d( index, x, y, z );
14783   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14784 }
14785
14787 inline  void  GLVertexAttrib3dv( GLuint index, const GLdouble *v )
14788 {
14789   NVSG_GL_STATS_FCT_COUNT();
14790   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib3dv );
14791   glContext()->m_glFunctions->glVertexAttrib3dv( index, v );
14792   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14793 }
14794
14796 inline  void  GLVertexAttrib3f( GLuint index, GLfloat x, GLfloat y, GLfloat z )
14797 {
14798   NVSG_GL_STATS_FCT_COUNT();
14799   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib3f );
14800   glContext()->m_glFunctions->glVertexAttrib3f( index, x, y, z );
14801   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14802 }
14803
14805 inline  void  GLVertexAttrib3fv( GLuint index, const GLfloat *v )
14806 {
14807   NVSG_GL_STATS_FCT_COUNT();
14808   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib3fv );
14809   glContext()->m_glFunctions->glVertexAttrib3fv( index, v );
14810   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14811 }
14812
14814 inline  void  GLVertexAttrib3h( GLuint index, GLhalf x, GLhalf y, GLhalf z )
14815 {
14816   NVSG_GL_STATS_FCT_COUNT();
14817   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib3h );
14818   glContext()->m_glFunctions->glVertexAttrib3h( index, x, y, z );
14819   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14820 }
14821
14823 inline  void  GLVertexAttrib3hv( GLuint index, const GLhalf *v )
14824 {
14825   NVSG_GL_STATS_FCT_COUNT();
14826   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib3hv );
14827   glContext()->m_glFunctions->glVertexAttrib3hv( index, v );
14828   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14829 }
14830
14832 inline  void  GLVertexAttrib3s( GLuint index, GLshort x, GLshort y, GLshort z )
14833 {
14834   NVSG_GL_STATS_FCT_COUNT();
14835   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib3s );
14836   glContext()->m_glFunctions->glVertexAttrib3s( index, x, y, z );
14837   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14838 }
14839
14841 inline  void  GLVertexAttrib3sv( GLuint index, const GLshort *v )
14842 {
14843   NVSG_GL_STATS_FCT_COUNT();
14844   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib3sv );
14845   glContext()->m_glFunctions->glVertexAttrib3sv( index, v );
14846   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14847 }
14848
14850 inline  void  GLVertexAttrib4bv( GLuint index, const GLbyte *v )
14851 {
14852   NVSG_GL_STATS_FCT_COUNT();
14853   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4bv );
14854   glContext()->m_glFunctions->glVertexAttrib4bv( index, v );
14855   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14856 }
14857
14859 inline  void  GLVertexAttrib4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
14860 {
14861   NVSG_GL_STATS_FCT_COUNT();
14862   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4d );
14863   glContext()->m_glFunctions->glVertexAttrib4d( index, x, y, z, w );
14864   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14865 }
14866
14868 inline  void  GLVertexAttrib4dv( GLuint index, const GLdouble *v )
14869 {
14870   NVSG_GL_STATS_FCT_COUNT();
14871   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4dv );
14872   glContext()->m_glFunctions->glVertexAttrib4dv( index, v );
14873   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14874 }
14875
14877 inline  void  GLVertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
14878 {
14879   NVSG_GL_STATS_FCT_COUNT();
14880   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4f );
14881   glContext()->m_glFunctions->glVertexAttrib4f( index, x, y, z, w );
14882   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14883 }
14884
14886 inline  void  GLVertexAttrib4fv( GLuint index, const GLfloat *v )
14887 {
14888   NVSG_GL_STATS_FCT_COUNT();
14889   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4fv );
14890   glContext()->m_glFunctions->glVertexAttrib4fv( index, v );
14891   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14892 }
14893
14895 inline  void  GLVertexAttrib4h( GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w )
14896 {
14897   NVSG_GL_STATS_FCT_COUNT();
14898   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4h );
14899   glContext()->m_glFunctions->glVertexAttrib4h( index, x, y, z, w );
14900   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14901 }
14902
14904 inline  void  GLVertexAttrib4hv( GLuint index, const GLhalf *v )
14905 {
14906   NVSG_GL_STATS_FCT_COUNT();
14907   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4hv );
14908   glContext()->m_glFunctions->glVertexAttrib4hv( index, v );
14909   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14910 }
14911
14913 inline  void  GLVertexAttrib4iv( GLuint index, const GLint *v )
14914 {
14915   NVSG_GL_STATS_FCT_COUNT();
14916   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4iv );
14917   glContext()->m_glFunctions->glVertexAttrib4iv( index, v );
14918   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14919 }
14920
14922 inline  void  GLVertexAttrib4s( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w )
14923 {
14924   NVSG_GL_STATS_FCT_COUNT();
14925   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4s );
14926   glContext()->m_glFunctions->glVertexAttrib4s( index, x, y, z, w );
14927   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14928 }
14929
14931 inline  void  GLVertexAttrib4sv( GLuint index, const GLshort *v )
14932 {
14933   NVSG_GL_STATS_FCT_COUNT();
14934   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4sv );
14935   glContext()->m_glFunctions->glVertexAttrib4sv( index, v );
14936   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14937 }
14938
14940 inline  void  GLVertexAttrib4ub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
14941 {
14942   NVSG_GL_STATS_FCT_COUNT();
14943   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4ubNV );
14944   glContext()->m_glFunctions->glVertexAttrib4ubNV( index, x, y, z, w );
14945   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14946 }
14947
14949 inline  void  GLVertexAttrib4ubv( GLuint index, const GLubyte *v )
14950 {
14951   NVSG_GL_STATS_FCT_COUNT();
14952   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4ubv );
14953   glContext()->m_glFunctions->glVertexAttrib4ubv( index, v );
14954   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14955 }
14956
14958 inline  void  GLVertexAttrib4uiv( GLuint index, const GLuint *v )
14959 {
14960   NVSG_GL_STATS_FCT_COUNT();
14961   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4uiv );
14962   glContext()->m_glFunctions->glVertexAttrib4uiv( index, v );
14963   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14964 }
14965
14967 inline  void  GLVertexAttrib4usv( GLuint index, const GLushort *v )
14968 {
14969   NVSG_GL_STATS_FCT_COUNT();
14970   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4usv );
14971   glContext()->m_glFunctions->glVertexAttrib4usv( index, v );
14972   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14973 }
14974
14976 inline  void  GLVertexAttrib4Nbv( GLuint index, const GLbyte *v )
14977 {
14978   NVSG_GL_STATS_FCT_COUNT();
14979   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4Nbv );
14980   glContext()->m_glFunctions->glVertexAttrib4Nbv( index, v );
14981   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14982 }
14983
14985 inline  void  GLVertexAttrib4Niv( GLuint index, const GLint *v )
14986 {
14987   NVSG_GL_STATS_FCT_COUNT();
14988   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4Niv );
14989   glContext()->m_glFunctions->glVertexAttrib4Niv( index, v );
14990   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
14991 }
14992
14994 inline  void  GLVertexAttrib4Nsv( GLuint index, const GLshort *v )
14995 {
14996   NVSG_GL_STATS_FCT_COUNT();
14997   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4Nsv );
14998   glContext()->m_glFunctions->glVertexAttrib4Nsv( index, v );
14999   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15000 }
15001
15003 inline  void  GLVertexAttrib4Nub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
15004 {
15005   NVSG_GL_STATS_FCT_COUNT();
15006   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4Nub );
15007   glContext()->m_glFunctions->glVertexAttrib4Nub( index, x, y, z, w );
15008   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15009 }
15010
15012 inline  void  GLVertexAttrib4Nubv( GLuint index, const GLubyte *v )
15013 {
15014   NVSG_GL_STATS_FCT_COUNT();
15015   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4Nubv );
15016   glContext()->m_glFunctions->glVertexAttrib4Nubv( index, v );
15017   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15018 }
15019
15021 inline  void  GLVertexAttrib4Nuiv( GLuint index, const GLuint *v )
15022 {
15023   NVSG_GL_STATS_FCT_COUNT();
15024   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4Nuiv );
15025   glContext()->m_glFunctions->glVertexAttrib4Nuiv( index, v );
15026   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15027 }
15028
15030 inline  void  GLVertexAttrib4Nusv( GLuint index, const GLushort *v )
15031 {
15032   NVSG_GL_STATS_FCT_COUNT();
15033   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttrib4Nusv );
15034   glContext()->m_glFunctions->glVertexAttrib4Nusv( index, v );
15035   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15036 }
15037
15039 inline void GLVertexAttribI1i( GLuint index, GLint x )
15040 {
15041   NVSG_GL_STATS_FCT_COUNT();
15042   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI1i );
15043   glContext()->m_glFunctions->glVertexAttribI1i( index, x );
15044   ASSERT_GL_NO_ERROR;
15045 }
15046
15048 inline void GLVertexAttribI2i( GLuint index, GLint x, GLint y )
15049 {
15050   NVSG_GL_STATS_FCT_COUNT();
15051   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI2i );
15052   glContext()->m_glFunctions->glVertexAttribI2i( index, x, y );
15053   ASSERT_GL_NO_ERROR;
15054 }
15055
15057 inline void GLVertexAttribI3i( GLuint index, GLint x, GLint y, GLint z )
15058 {
15059   NVSG_GL_STATS_FCT_COUNT();
15060   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI3i );
15061   glContext()->m_glFunctions->glVertexAttribI3i( index, x, y, z );
15062   ASSERT_GL_NO_ERROR;
15063 }
15064
15066 inline void GLVertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w )
15067 {
15068   NVSG_GL_STATS_FCT_COUNT();
15069   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI4i );
15070   glContext()->m_glFunctions->glVertexAttribI4i( index, x, y, z, w );
15071   ASSERT_GL_NO_ERROR;
15072 }
15073
15075 inline void GLVertexAttribI1ui( GLuint index, GLuint x )
15076 {
15077   NVSG_GL_STATS_FCT_COUNT();
15078   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI1ui );
15079   glContext()->m_glFunctions->glVertexAttribI1ui( index, x );
15080   ASSERT_GL_NO_ERROR;
15081 }
15082
15084 inline void GLVertexAttribI2ui( GLuint index, GLuint x, GLuint y )
15085 {
15086   NVSG_GL_STATS_FCT_COUNT();
15087   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI2ui );
15088   glContext()->m_glFunctions->glVertexAttribI2ui( index, x, y );
15089   ASSERT_GL_NO_ERROR;
15090 }
15091
15093 inline void GLVertexAttribI3ui( GLuint index, GLuint x, GLuint y, GLuint z )
15094 {
15095   NVSG_GL_STATS_FCT_COUNT();
15096   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI3ui );
15097   glContext()->m_glFunctions->glVertexAttribI3ui( index, x, y, z );
15098   ASSERT_GL_NO_ERROR;
15099 }
15100
15102 inline void GLVertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
15103 {
15104   NVSG_GL_STATS_FCT_COUNT();
15105   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI4ui );
15106   glContext()->m_glFunctions->glVertexAttribI4ui( index, x, y, z, w );
15107   ASSERT_GL_NO_ERROR;
15108 }
15109
15111 inline void GLVertexAttribI1iv( GLuint index, const GLint *v )
15112 {
15113   NVSG_GL_STATS_FCT_COUNT();
15114   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI1iv );
15115   glContext()->m_glFunctions->glVertexAttribI1iv( index, v );
15116   ASSERT_GL_NO_ERROR;
15117 }
15118
15120 inline void GLVertexAttribI2iv( GLuint index, const GLint *v )
15121 {
15122   NVSG_GL_STATS_FCT_COUNT();
15123   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI2iv );
15124   glContext()->m_glFunctions->glVertexAttribI2iv( index, v );
15125   ASSERT_GL_NO_ERROR;
15126 }
15127
15129 inline void GLVertexAttribI3iv( GLuint index, const GLint *v )
15130 {
15131   NVSG_GL_STATS_FCT_COUNT();
15132   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI3iv );
15133   glContext()->m_glFunctions->glVertexAttribI3iv( index, v );
15134   ASSERT_GL_NO_ERROR;
15135 }
15136
15138 inline void GLVertexAttribI4iv( GLuint index, const GLint *v )
15139 {
15140   NVSG_GL_STATS_FCT_COUNT();
15141   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI4iv );
15142   glContext()->m_glFunctions->glVertexAttribI4iv( index, v );
15143   ASSERT_GL_NO_ERROR;
15144 }
15145
15147 inline void GLVertexAttribI1uiv( GLuint index, const GLuint *v )
15148 {
15149   NVSG_GL_STATS_FCT_COUNT();
15150   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI1uiv );
15151   glContext()->m_glFunctions->glVertexAttribI1uiv( index, v );
15152   ASSERT_GL_NO_ERROR;
15153 }
15154
15156 inline void GLVertexAttribI2uiv( GLuint index, const GLuint *v )
15157 {
15158   NVSG_GL_STATS_FCT_COUNT();
15159   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI2uiv );
15160   glContext()->m_glFunctions->glVertexAttribI2uiv( index, v );
15161   ASSERT_GL_NO_ERROR;
15162 }
15163
15165 inline void GLVertexAttribI3uiv( GLuint index, const GLuint *v )
15166 {
15167   NVSG_GL_STATS_FCT_COUNT();
15168   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI3uiv );
15169   glContext()->m_glFunctions->glVertexAttribI3uiv( index, v );
15170   ASSERT_GL_NO_ERROR;
15171 }
15172
15174 inline void GLVertexAttribI4uiv( GLuint index, const GLuint *v )
15175 {
15176   NVSG_GL_STATS_FCT_COUNT();
15177   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI4uiv );
15178   glContext()->m_glFunctions->glVertexAttribI4uiv( index, v );
15179   ASSERT_GL_NO_ERROR;
15180 }
15181
15183 inline void GLVertexAttribI4bv( GLuint index, const GLbyte *v )
15184 {
15185   NVSG_GL_STATS_FCT_COUNT();
15186   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI4bv );
15187   glContext()->m_glFunctions->glVertexAttribI4bv( index, v );
15188   ASSERT_GL_NO_ERROR;
15189 }
15190
15192 inline void GLVertexAttribI4ubv( GLuint index, const GLubyte *v )
15193 {
15194   NVSG_GL_STATS_FCT_COUNT();
15195   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI4ubv );
15196   glContext()->m_glFunctions->glVertexAttribI4ubv( index, v );
15197   ASSERT_GL_NO_ERROR;
15198 }
15199
15201 inline void GLVertexAttribI4sv( GLuint index, const GLshort *v )
15202 {
15203   NVSG_GL_STATS_FCT_COUNT();
15204   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI4sv );
15205   glContext()->m_glFunctions->glVertexAttribI4sv( index, v );
15206   ASSERT_GL_NO_ERROR;
15207 }
15208
15210 inline void GLVertexAttribI4usv( GLuint index, const GLushort *v )
15211 {
15212   NVSG_GL_STATS_FCT_COUNT();
15213   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribI4usv );
15214   glContext()->m_glFunctions->glVertexAttribI4usv( index, v );
15215   ASSERT_GL_NO_ERROR;
15216 }
15217
15219 inline void GLVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
15220 {
15221   NVSG_GL_STATS_FCT_COUNT();
15222   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribIPointer );
15223   glContext()->m_glFunctions->glVertexAttribIPointer( index, size, type, stride, pointer );
15224   ASSERT_GL_NO_ERROR;
15225 }
15226
15228 inline void GLVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalize, GLsizei stride, const GLvoid * pointer )
15229 {
15230   NVSG_GL_STATS_FCT_COUNT();
15231   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribPointer );
15232   glContext()->m_glFunctions->glVertexAttribPointer(index, size, type, normalize, stride, pointer);
15233   ASSERT_GL_NO_ERROR;
15234 }
15235
15237 inline  void  GLVertexAttribPointerNV( GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer )
15238 {
15239   NVSG_GL_STATS_FCT_COUNT();
15240   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribPointerNV );
15241   glContext()->m_glFunctions->glVertexAttribPointerNV( index, fsize, type, stride, pointer );
15242   ASSERT_GL_NO_ERROR;
15243 }
15244
15246 inline  void  GLVertexAttribs1dvNV( GLuint index, GLsizei count, const GLdouble *v )
15247 {
15248   NVSG_GL_STATS_FCT_COUNT();
15249   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs1dvNV );
15250   glContext()->m_glFunctions->glVertexAttribs1dvNV( index, count, v );
15251   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15252 }
15253
15255 inline  void  GLVertexAttribs1fvNV( GLuint index, GLsizei count, const GLfloat *v )
15256 {
15257   NVSG_GL_STATS_FCT_COUNT();
15258   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs1fvNV );
15259   glContext()->m_glFunctions->glVertexAttribs1fvNV( index, count, v );
15260   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15261 }
15262
15264 inline  void  GLVertexAttribs1hv( GLuint index, GLsizei count, const GLhalf *v )
15265 {
15266   NVSG_GL_STATS_FCT_COUNT();
15267   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs1hv );
15268   glContext()->m_glFunctions->glVertexAttribs1hv( index, count, v );
15269   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15270 }
15271
15273 inline  void  GLVertexAttribs1svNV( GLuint index, GLsizei count, const GLshort *v )
15274 {
15275   NVSG_GL_STATS_FCT_COUNT();
15276   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs1svNV );
15277   glContext()->m_glFunctions->glVertexAttribs1svNV( index, count, v );
15278   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15279 }
15280
15282 inline  void  GLVertexAttribs2dvNV( GLuint index, GLsizei count, const GLdouble *v )
15283 {
15284   NVSG_GL_STATS_FCT_COUNT();
15285   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs2dvNV );
15286   glContext()->m_glFunctions->glVertexAttribs2dvNV( index, count, v );
15287   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15288 }
15289
15291 inline  void  GLVertexAttribs2fvNV( GLuint index, GLsizei count, const GLfloat *v )
15292 {
15293   NVSG_GL_STATS_FCT_COUNT();
15294   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs2fvNV );
15295   glContext()->m_glFunctions->glVertexAttribs2fvNV( index, count, v );
15296   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15297 }
15298
15300 inline  void  GLVertexAttribs2hv( GLuint index, GLsizei count, const GLhalf *v )
15301 {
15302   NVSG_GL_STATS_FCT_COUNT();
15303   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs2hv );
15304   glContext()->m_glFunctions->glVertexAttribs2hv( index, count, v );
15305   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15306 }
15307
15309 inline  void  GLVertexAttribs2svNV( GLuint index, GLsizei count, const GLshort *v )
15310 {
15311   NVSG_GL_STATS_FCT_COUNT();
15312   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs2svNV );
15313   glContext()->m_glFunctions->glVertexAttribs2svNV( index, count, v );
15314   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15315 }
15316
15318 inline  void  GLVertexAttribs3dvNV( GLuint index, GLsizei count, const GLdouble *v )
15319 {
15320   NVSG_GL_STATS_FCT_COUNT();
15321   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs3dvNV );
15322   glContext()->m_glFunctions->glVertexAttribs3dvNV( index, count, v );
15323   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15324 }
15325
15327 inline  void  GLVertexAttribs3fvNV( GLuint index, GLsizei count, const GLfloat *v )
15328 {
15329   NVSG_GL_STATS_FCT_COUNT();
15330   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs3fvNV );
15331   glContext()->m_glFunctions->glVertexAttribs3fvNV( index, count, v );
15332   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15333 }
15334
15336 inline  void  GLVertexAttribs3hv( GLuint index, GLsizei count, const GLhalf *v )
15337 {
15338   NVSG_GL_STATS_FCT_COUNT();
15339   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs3hv );
15340   glContext()->m_glFunctions->glVertexAttribs3hv( index, count, v );
15341   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15342 }
15343
15345 inline  void  GLVertexAttribs3svNV( GLuint index, GLsizei count, const GLshort *v )
15346 {
15347   NVSG_GL_STATS_FCT_COUNT();
15348   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs3svNV );
15349   glContext()->m_glFunctions->glVertexAttribs3svNV( index, count, v );
15350   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15351 }
15352
15354 inline  void  GLVertexAttribs4dvNV( GLuint index, GLsizei count, const GLdouble *v )
15355 {
15356   NVSG_GL_STATS_FCT_COUNT();
15357   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs4dvNV );
15358   glContext()->m_glFunctions->glVertexAttribs4dvNV( index, count, v );
15359   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15360 }
15361
15363 inline  void  GLVertexAttribs4fvNV( GLuint index, GLsizei count, const GLfloat *v )
15364 {
15365   NVSG_GL_STATS_FCT_COUNT();
15366   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs4fvNV );
15367   glContext()->m_glFunctions->glVertexAttribs4fvNV( index, count, v );
15368   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15369 }
15370
15372 inline  void  GLVertexAttribs4hv( GLuint index, GLsizei count, const GLhalf *v )
15373 {
15374   NVSG_GL_STATS_FCT_COUNT();
15375   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs4hv );
15376   glContext()->m_glFunctions->glVertexAttribs4hv( index, count, v );
15377   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15378 }
15379
15381 inline  void  GLVertexAttribs4svNV( GLuint index, GLsizei count, const GLshort *v )
15382 {
15383   NVSG_GL_STATS_FCT_COUNT();
15384   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs4svNV );
15385   glContext()->m_glFunctions->glVertexAttribs4svNV( index, count, v );
15386   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15387 }
15388
15390 inline  void  GLVertexAttribs4ubvNV( GLuint index, GLsizei count, const GLubyte *v )
15391 {
15392   NVSG_GL_STATS_FCT_COUNT();
15393   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glVertexAttribs4ubvNV );
15394   glContext()->m_glFunctions->glVertexAttribs4ubvNV( index, count, v );
15395   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
15396 }
15397
15399
15400 inline  void  GLVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
15401 {
15402   NVSG_GL_STATS_VERTEX_POINTER( size, type, stride, pointer );
15403   glVertexPointer( size, type, stride, pointer );
15404   ASSERT_GL_NO_ERROR;
15405 }
15406
15408
15409 inline  void  GLViewport( GLint x, GLint y, GLsizei width, GLsizei height )
15410 {
15411   NVSG_GL_STATS_VIEWPORT( x, y, width, height );
15412   glViewport( x, y, width, height );
15413   ASSERT_GL_NO_ERROR;
15414 }
15415
15417 inline  void  GLWindowBackBufferHint()
15418 {
15419   NVSG_GL_STATS_FCT_COUNT();
15420   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowBackBufferHint );
15421   glContext()->m_glFunctions->glWindowBackBufferHint();
15422   ASSERT_GL_NO_ERROR;
15423 }
15424
15426
15427 inline  void  GLWindowPos2d( GLdouble x, GLdouble y )
15428 {
15429   NVSG_GL_STATS_FCT_COUNT();
15430   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos2d );
15431   glContext()->m_glFunctions->glWindowPos2d( x, y );
15432   ASSERT_GL_NO_ERROR;
15433 }
15434
15436
15437 inline  void  GLWindowPos2dv( const GLdouble *p )
15438 {
15439   NVSG_GL_STATS_FCT_COUNT();
15440   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos2dv );
15441   glContext()->m_glFunctions->glWindowPos2dv( p );
15442   ASSERT_GL_NO_ERROR;
15443 }
15444
15446
15447 inline  void  GLWindowPos2f( GLfloat x, GLfloat y )
15448 {
15449   NVSG_GL_STATS_FCT_COUNT();
15450   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos2f );
15451   glContext()->m_glFunctions->glWindowPos2f( x, y );
15452   ASSERT_GL_NO_ERROR;
15453 }
15454
15456
15457 inline  void  GLWindowPos2fv( const GLfloat *p )
15458 {
15459   NVSG_GL_STATS_FCT_COUNT();
15460   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos2fv );
15461   glContext()->m_glFunctions->glWindowPos2fv( p );
15462   ASSERT_GL_NO_ERROR;
15463 }
15464
15466
15467 inline  void  GLWindowPos2i( GLint x, GLint y )
15468 {
15469   NVSG_GL_STATS_FCT_COUNT();
15470   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos2i );
15471   glContext()->m_glFunctions->glWindowPos2i( x, y );
15472   ASSERT_GL_NO_ERROR;
15473 }
15474
15476
15477 inline  void  GLWindowPos2iv( const GLint *p )
15478 {
15479   NVSG_GL_STATS_FCT_COUNT();
15480   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos2iv );
15481   glContext()->m_glFunctions->glWindowPos2iv( p );
15482   ASSERT_GL_NO_ERROR;
15483 }
15484
15486
15487 inline  void  GLWindowPos2s( GLshort x, GLshort y )
15488 {
15489   NVSG_GL_STATS_FCT_COUNT();
15490   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos2s );
15491   glContext()->m_glFunctions->glWindowPos2s( x, y );
15492   ASSERT_GL_NO_ERROR;
15493 }
15494
15496
15497 inline  void  GLWindowPos2sv( const GLshort *p )
15498 {
15499   NVSG_GL_STATS_FCT_COUNT();
15500   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos2sv );
15501   glContext()->m_glFunctions->glWindowPos2sv( p );
15502   ASSERT_GL_NO_ERROR;
15503 }
15504
15506
15507 inline  void  GLWindowPos3d( GLdouble x, GLdouble y, GLdouble z )
15508 {
15509   NVSG_GL_STATS_FCT_COUNT();
15510   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos3d );
15511   glContext()->m_glFunctions->glWindowPos3d( x, y, z );
15512   ASSERT_GL_NO_ERROR;
15513 }
15514
15516
15517 inline  void  GLWindowPos3dv( const GLdouble *p )
15518 {
15519   NVSG_GL_STATS_FCT_COUNT();
15520   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos3dv );
15521   glContext()->m_glFunctions->glWindowPos3dv( p );
15522   ASSERT_GL_NO_ERROR;
15523 }
15524
15526
15527 inline  void  GLWindowPos3f( GLfloat x, GLfloat y, GLfloat z )
15528 {
15529   NVSG_GL_STATS_FCT_COUNT();
15530   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos3f );
15531   glContext()->m_glFunctions->glWindowPos3f( x, y, z );
15532   ASSERT_GL_NO_ERROR;
15533 }
15534
15536
15537 inline  void  GLWindowPos3fv( const GLfloat *p )
15538 {
15539   NVSG_GL_STATS_FCT_COUNT();
15540   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos3fv );
15541   glContext()->m_glFunctions->glWindowPos3fv( p );
15542   ASSERT_GL_NO_ERROR;
15543 }
15544
15546
15547 inline  void  GLWindowPos3i( GLint x, GLint y, GLint z )
15548 {
15549   NVSG_GL_STATS_FCT_COUNT();
15550   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos3i );
15551   glContext()->m_glFunctions->glWindowPos3i( x, y, z );
15552   ASSERT_GL_NO_ERROR;
15553 }
15554
15556
15557 inline  void  GLWindowPos3iv( const GLint *p )
15558 {
15559   NVSG_GL_STATS_FCT_COUNT();
15560   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos3iv );
15561   glContext()->m_glFunctions->glWindowPos3iv( p );
15562   ASSERT_GL_NO_ERROR;
15563 }
15564
15566
15567 inline  void  GLWindowPos3s( GLshort x, GLshort y, GLshort z )
15568 {
15569   NVSG_GL_STATS_FCT_COUNT();
15570   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos3s );
15571   glContext()->m_glFunctions->glWindowPos3s( x, y, z );
15572   ASSERT_GL_NO_ERROR;
15573 }
15574
15576
15577 inline  void  GLWindowPos3sv( const GLshort *p )
15578 {
15579   NVSG_GL_STATS_FCT_COUNT();
15580   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glWindowPos3sv );
15581   glContext()->m_glFunctions->glWindowPos3sv( p );
15582   ASSERT_GL_NO_ERROR;
15583 }
15584
15592 inline GLboolean GLIsRenderbuffer(GLuint renderbuffer)
15593 {
15594   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15595   GLboolean isRenderBuffer = glContext()->m_glFunctions->glIsRenderbuffer(renderbuffer);
15596   ASSERT_GL_NO_ERROR;
15597   return isRenderBuffer;
15598 }
15599
15607 inline void GLBindRenderbuffer(GLenum target, GLuint renderbuffer)
15608 {
15609   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15610   glContext()->m_glFunctions->glBindRenderbuffer(target, renderbuffer);
15611   ASSERT_GL_NO_ERROR;
15612 }
15613
15621 inline void GLDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
15622 {
15623   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15624   glContext()->m_glFunctions->glDeleteRenderbuffers(n, renderbuffers);
15625   ASSERT_GL_NO_ERROR;
15626 }
15627
15635 inline void GLGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
15636 {
15637   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15638   glContext()->m_glFunctions->glGenRenderbuffers(n, renderbuffers);
15639   ASSERT_GL_NO_ERROR;
15640 }
15641
15651 inline void GLRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
15652 {
15653   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15654   glContext()->m_glFunctions->glRenderbufferStorage(target, internalformat, width, height);
15655   ASSERT_GL_NO_ERROR;
15656 }
15657
15669 inline void GLRenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
15670 {
15671   NVSG_GL_STATS_FCT_COUNT();
15672   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glRenderbufferStorageMultisample );
15673   glContext()->m_glFunctions->glRenderbufferStorageMultisample( target, samples, internalformat, width, height );
15674   ASSERT_GL_NO_ERROR;
15675 }
15676
15689 inline void GLRenderbufferStorageMultisampleCoverage(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)
15690 {
15691   NVSG_GL_STATS_FCT_COUNT();
15692   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glRenderbufferStorageMultisampleCoverage );
15693   glContext()->m_glFunctions->glRenderbufferStorageMultisampleCoverage( target, coverageSamples, colorSamples, internalformat, width, height );
15694   ASSERT_GL_NO_ERROR;
15695 }
15696
15705 inline void GLGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
15706 {
15707   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15708   glContext()->m_glFunctions->glGetRenderbufferParameteriv(target, pname, params);
15709   ASSERT_GL_NO_ERROR;
15710 }
15711
15720 inline GLboolean GLIsFramebuffer(GLuint framebuffer)
15721 {
15722   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15723   GLboolean isFramebuffer = glContext()->m_glFunctions->glIsFramebuffer(framebuffer);
15724   ASSERT_GL_NO_ERROR;
15725   return isFramebuffer;
15726 }
15727
15736 inline void GLBindFramebuffer(GLenum target, GLuint framebuffer)
15737 {
15738   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15739   glContext()->m_glFunctions->glBindFramebuffer(target, framebuffer);
15740   ASSERT_GL_NO_ERROR;
15741 }
15742
15751 inline void GLDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
15752 {
15753   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15754   glContext()->m_glFunctions->glDeleteFramebuffers(n, framebuffers);
15755   ASSERT_GL_NO_ERROR;
15756 }
15757
15766 inline void GLGenFramebuffers(GLsizei n, GLuint *framebuffers)
15767 {
15768   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15769   glContext()->m_glFunctions->glGenFramebuffers(n, framebuffers);
15770   ASSERT_GL_NO_ERROR;
15771 }
15772
15781 inline GLenum GLCheckFramebufferStatus(GLenum target)
15782 {
15783   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15784   GLenum status = glContext()->m_glFunctions->glCheckFramebufferStatus(target);
15785   ASSERT_GL_NO_ERROR;
15786   return status;
15787 }
15788
15800 inline void GLFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
15801 {
15802   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15803   glContext()->m_glFunctions->glFramebufferTexture1D(target, attachment, textarget, texture, level);
15804   ASSERT_GL_NO_ERROR;
15805 }
15806
15818 inline void GLFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
15819 {
15820   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15821   glContext()->m_glFunctions->glFramebufferTexture2D(target, attachment, textarget, texture, level);
15822   ASSERT_GL_NO_ERROR;
15823 }
15824
15837 inline void GLFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
15838 {
15839   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15840   glContext()->m_glFunctions->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
15841   ASSERT_GL_NO_ERROR;
15842 }
15843
15855 inline void GLFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
15856 {
15857   NVSG_GL_STATS_FCT_COUNT();
15858   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glFramebufferTextureLayer );
15859   glContext()->m_glFunctions->glFramebufferTextureLayer( target, attachment, texture, level, layer );
15860   ASSERT_GL_NO_ERROR;
15861 }
15862
15873 inline void GLFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
15874 {
15875   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15876   glContext()->m_glFunctions->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
15877   ASSERT_GL_NO_ERROR;
15878 }
15879
15890 inline void GLGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
15891 {
15892   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15893   glContext()->m_glFunctions->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
15894   ASSERT_GL_NO_ERROR;
15895 }
15896
15901 inline void GLGenerateMipmap(GLenum target)
15902 {
15903   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_framebuffer_object"));
15904   glContext()->m_glFunctions->glGenerateMipmap(target);
15905   ASSERT_GL_NO_ERROR;
15906 }
15907
15908
15912 inline GLenum GLGetTexWrapMode( nvsg::TextureWrapMode twm )
15913 {
15914   NVSG_ASSERT( twm <= nvsg::TWM_MIRROR_CLAMP_TO_BORDER );
15915   return( glContext()->m_glTexWrapModes[twm] );
15916 }
15917
15918 #if defined(_WIN32)
15919
15927 inline bool WGLInitializeExtensions(void)
15928 {
15929   return theWGLFunctions::instance()->Init();
15930 }
15931
15945 inline bool WGLIsExtensionAvailable(const std::string& extstr)
15946 {
15947   return theWGLFunctions::instance()->isAvailable(extstr);
15948 }
15949
15961 inline bool WGLIsExtensionExported(const std::string& extstr)
15962 {
15963   return theWGLFunctions::instance()->isExported(extstr);
15964 }
15965
15967
15968 inline  BOOL  WGLBindTexImage( HPBUFFERARB hPbuffer, int iBuffer )
15969 {
15970   NVSG_GL_STATS_FCT_COUNT();
15971   NVSG_ASSERT( theWGLFunctions::instance()->wglBindTexImageARB );
15972   return theWGLFunctions::instance()->wglBindTexImageARB( hPbuffer, iBuffer );
15973 }
15974
15976
15977 inline  BOOL  WGLChoosePixelFormat( HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats )
15978 {
15979   NVSG_GL_STATS_FCT_COUNT();
15980   NVSG_ASSERT( theWGLFunctions::instance()->wglChoosePixelFormatARB );
15981   return theWGLFunctions::instance()->wglChoosePixelFormatARB( hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats );
15982 }
15983
15985
15988 inline  HGLRC WGLCreateContext( HDC hdc )
15989 {
15990   HGLRC hglrc = wglCreateContext( hdc );
15991   WGLAttachContext(hdc, hglrc);
15992   return hglrc;
15993 }
15994
15996
15999 inline  HPBUFFERARB WGLCreatePbuffer( HDC hdc, int pixelFormat, int width, int height, const int *attribList )
16000 {
16001   NVSG_GL_STATS_FCT_COUNT();
16002   NVSG_ASSERT( wglGetCurrentContext() != NULL );
16003   NVSG_ASSERT( theWGLFunctions::instance()->wglCreatePbufferARB );
16004   HPBUFFERARB hPbuffer = theWGLFunctions::instance()->wglCreatePbufferARB( hdc, pixelFormat, width, height, attribList );
16005   return( hPbuffer );
16006 }
16007
16009
16013 inline  BOOL  WGLDeleteContext( HGLRC hglrc )
16014 {
16015   NVSG_GL_STATS_FCT_COUNT();
16016   WGLDetachContext(hglrc);
16017   return wglDeleteContext(hglrc);
16018 }
16019
16021
16022 inline  BOOL  WGLDestroyPbuffer( HPBUFFERARB hPbuffer )
16023 {
16024   NVSG_GL_STATS_FCT_COUNT();
16025   NVSG_ASSERT(theWGLFunctions::instance()->wglDestroyPbufferARB);
16026   return theWGLFunctions::instance()->wglDestroyPbufferARB( hPbuffer );
16027 }
16028
16030
16034 inline  HGLRC  WGLGetCurrentContext(void)
16035 {
16036   // !! NOTE: no NVSG_GL_STATS_FCT_COUNT macro call here, because it relies on a valid glContext !!
16037   ASSERT_GL_CURRENT_CONTEXT_CONFORMITY();
16038   return wglGetCurrentContext();
16039 }
16040
16042
16047 inline  HDC  WGLGetCurrentDC(void)
16048 {
16049   NVSG_GL_STATS_FCT_COUNT();
16050   return wglGetCurrentDC();
16051 }
16052
16054
16055 inline  HDC WGLGetPbufferDC( HPBUFFERARB hPbuffer )
16056 {
16057   NVSG_GL_STATS_FCT_COUNT();
16058   NVSG_ASSERT( theWGLFunctions::instance()->wglGetPbufferDCARB );
16059   return theWGLFunctions::instance()->wglGetPbufferDCARB( hPbuffer );
16060 }
16061
16063
16064 inline  BOOL  WGLQueryPbuffer( HPBUFFERARB hPbuffer, int attribute, int *value )
16065 {
16066   NVSG_GL_STATS_FCT_COUNT();
16067   NVSG_ASSERT( theWGLFunctions::instance()->wglQueryPbufferARB );
16068   return theWGLFunctions::instance()->wglQueryPbufferARB( hPbuffer, attribute, value );
16069 }
16070
16072
16073 inline  int WGLReleasePbufferDC( HPBUFFERARB hPbuffer, HDC hdc )
16074 {
16075   NVSG_GL_STATS_FCT_COUNT();
16076   NVSG_ASSERT( theWGLFunctions::instance()->wglReleasePbufferDCARB );
16077   int i = theWGLFunctions::instance()->wglReleasePbufferDCARB( hPbuffer, hdc );
16078   NVSG_ASSERT( i == 1 );
16079   return( i );
16080 }
16081
16083
16084 inline  BOOL  WGLReleaseTexImage( HPBUFFERARB hPbuffer, int iBuffer )
16085 {
16086   NVSG_GL_STATS_FCT_COUNT();
16087   NVSG_ASSERT( theWGLFunctions::instance()->wglReleaseTexImageARB );
16088   return theWGLFunctions::instance()->wglReleaseTexImageARB( hPbuffer, iBuffer );
16089 }
16090
16092 inline BOOL WGLJoinSwapGroupNV(HDC hDC, GLuint group)
16093 {
16094   NVSG_GL_STATS_FCT_COUNT();
16095   return theWGLFunctions::instance()->wglJoinSwapGroupNV(hDC, group);
16096 }
16097
16099 inline BOOL WGLBindSwapBarrierNV(GLuint group, GLuint barrier)
16100 {
16101   NVSG_GL_STATS_FCT_COUNT();
16102   return theWGLFunctions::instance()->wglBindSwapBarrierNV(group, barrier);
16103 }
16104
16106 inline BOOL WGLQuerySwapGroupNV(HDC hDC, GLuint * group, GLuint * barrier)
16107 {
16108   NVSG_GL_STATS_FCT_COUNT();
16109   return theWGLFunctions::instance()->wglQuerySwapGroupNV(hDC, group, barrier);
16110 }
16111
16113 inline BOOL WGLQueryMaxSwapGroupsNV(HDC hDC, GLuint * maxGroups, GLuint * maxBarriers)
16114 {
16115   NVSG_GL_STATS_FCT_COUNT();
16116   return theWGLFunctions::instance()->wglQueryMaxSwapGroupsNV(hDC, maxGroups, maxBarriers);
16117 }
16118
16120 inline BOOL WGLQueryFrameCountNV(HDC hDC, GLuint * count)
16121 {
16122   NVSG_GL_STATS_FCT_COUNT();
16123   return theWGLFunctions::instance()->wglQueryFrameCountNV(hDC, count);
16124 }
16125
16127 inline BOOL WGLResetFrameCountNV(HDC hDC)
16128 {
16129   NVSG_GL_STATS_FCT_COUNT();
16130   return theWGLFunctions::instance()->wglResetFrameCountNV(hDC);
16131 }
16132
16134 inline BOOL WGLEnumGpus(UINT iIndex, HGPUNV *hGpu)
16135 {
16136   NVSG_GL_STATS_FCT_COUNT();
16137   NVSG_ASSERT( theWGLFunctions::instance()->wglEnumGpusNV );
16138   return theWGLFunctions::instance()->wglEnumGpusNV(iIndex, hGpu);
16139 }
16140
16142 inline BOOL WGLEnumGpuDevices(HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice)
16143 {
16144   NVSG_GL_STATS_FCT_COUNT();
16145   NVSG_ASSERT( theWGLFunctions::instance()->wglEnumGpuDevicesNV );
16146   return theWGLFunctions::instance()->wglEnumGpuDevicesNV(hGpu, iIndex, pGpuDevice);
16147 }
16148
16150 inline HDC  WGLCreateAffinityDC(const HGPUNV *pGpuList)
16151 {
16152   NVSG_GL_STATS_FCT_COUNT();
16153   NVSG_ASSERT( theWGLFunctions::instance()->wglCreateAffinityDCNV );
16154   return theWGLFunctions::instance()->wglCreateAffinityDCNV(pGpuList);
16155 }
16156
16158 inline BOOL WGLEnumGpusFromAffinityDC(HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu)
16159 {
16160   NVSG_GL_STATS_FCT_COUNT();
16161   NVSG_ASSERT( theWGLFunctions::instance()->wglEnumGpusFromAffinityDCNV );
16162   return theWGLFunctions::instance()->wglEnumGpusFromAffinityDCNV(hAffinityDC, iIndex, hGpu);
16163 }
16164
16166 inline BOOL WGLDeleteDC(HDC hAffinityDC)
16167 {
16168   NVSG_GL_STATS_FCT_COUNT();
16169   NVSG_ASSERT( theWGLFunctions::instance()->wglDeleteDCNV );
16170   return theWGLFunctions::instance()->wglDeleteDCNV(hAffinityDC);
16171 }
16172
16173 // WGL_NV_video_out functions:
16174
16176 inline BOOL WGLGetVideoDevice(HDC hDC, INT iVideoStreams, HPVIDEODEVICE* phpVideoDevice)
16177 {
16178   NVSG_GL_STATS_FCT_COUNT();
16179   NVSG_ASSERT( theWGLFunctions::instance()->wglGetVideoDeviceNV );
16180   return theWGLFunctions::instance()->wglGetVideoDeviceNV(hDC, iVideoStreams, phpVideoDevice);
16181 }
16182
16184 inline BOOL WGLReleaseVideoDevice(HPVIDEODEVICE hpVideoDevice)
16185 {
16186   NVSG_GL_STATS_FCT_COUNT();
16187   NVSG_ASSERT( theWGLFunctions::instance()->wglReleaseVideoDeviceNV );
16188   return theWGLFunctions::instance()->wglReleaseVideoDeviceNV(hpVideoDevice);
16189 }
16190
16192 inline BOOL WGLBindVideoImage(HPVIDEODEVICE hpVideoDevice, HPBUFFERARB hPbuffer, INT iVideoBuffer)
16193 {
16194   NVSG_GL_STATS_FCT_COUNT();
16195   NVSG_ASSERT( theWGLFunctions::instance()->wglBindVideoImageNV );
16196   return theWGLFunctions::instance()->wglBindVideoImageNV(hpVideoDevice, hPbuffer, iVideoBuffer);
16197 }
16198
16200 inline BOOL WGLReleaseVideoImage(HPBUFFERARB hPbuffer, INT iVideoBuffer)
16201 {
16202   NVSG_GL_STATS_FCT_COUNT();
16203   NVSG_ASSERT( theWGLFunctions::instance()->wglReleaseVideoImageNV );
16204   return theWGLFunctions::instance()->wglReleaseVideoImageNV(hPbuffer, iVideoBuffer);
16205 }
16206
16208 inline BOOL WGLSendPbufferToVideo(HPBUFFERARB hPbuffer, INT iBufferType, unsigned long * pulCounterPbuffer, BOOL bBlock)
16209 {
16210   NVSG_GL_STATS_FCT_COUNT();
16211   NVSG_ASSERT( theWGLFunctions::instance()->wglSendPbufferToVideoNV );
16212   return theWGLFunctions::instance()->wglSendPbufferToVideoNV(hPbuffer, iBufferType, pulCounterPbuffer, bBlock);
16213 }
16214
16216 inline BOOL WGLGetVideoInfo(HPVIDEODEVICE hpVideoDevice, unsigned long * pulCounterOutputVideo, unsigned long * pulCounterOutputPbuffer)
16217 {
16218   NVSG_GL_STATS_FCT_COUNT();
16219   NVSG_ASSERT( theWGLFunctions::instance()->wglGetVideoInfoNV );
16220   return theWGLFunctions::instance()->wglGetVideoInfoNV(hpVideoDevice, pulCounterOutputVideo, pulCounterOutputPbuffer);
16221 }
16222
16223 #endif // _WIN32
16224
16225 #if defined(LINUX)
16226
16234 inline bool GLXInitializeExtensions( Display * dpy )
16235 {
16236   if( dpy )
16237   {
16238     return theGLXFunctions::instance()->Init( dpy );
16239   }
16240   else
16241   {
16242     return false;
16243   }
16244 }
16245
16259 inline bool GLXIsExtensionAvailable(const std::string& extstr)
16260 {
16261   return theGLXFunctions::instance()->isAvailable(extstr);
16262 }
16263
16275 inline bool GLXIsExtensionExported(const std::string& extstr)
16276 {
16277   return theGLXFunctions::instance()->isExported(extstr);
16278 }
16279
16281 inline GLXContext GLXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct)
16282 {
16283   GLXContext ctx = glXCreateContext(dpy, vis, shareList, direct);
16284   GLXAttachContext(dpy, ctx);
16285   return ctx;
16286 }
16287
16289 inline void GLXDestroyContext(Display *dpy, GLXContext ctx)
16290 {
16291   NVSG_GL_STATS_FCT_COUNT();
16292   GLXDetachContext(ctx);
16293   return glXDestroyContext(dpy, ctx);
16294 }
16295
16297 inline GLXContext GLXGetCurrentContext()
16298 {
16299   ASSERT_GL_CURRENT_CONTEXT_CONFORMITY();
16300   return glXGetCurrentContext();
16301 }
16302
16304 inline GLXDrawable GLXGetCurrentDrawable()
16305 {
16306   NVSG_GL_STATS_FCT_COUNT();
16307   return glXGetCurrentDrawable();
16308 }
16309
16310 // GLX_SGI_swap_control
16311 inline NVSG_API int GLXSwapInterval (int value )
16312 {
16313   NVSG_GL_STATS_FCT_COUNT();
16314   NVSG_ASSERT( theGLXFunctions::instance()->glXSwapIntervalSGI );
16315   return theGLXFunctions::instance()->glXSwapIntervalSGI( value );
16316 }
16317
16318 // GLX_SGI_video_sync
16319
16320 inline int GLXGetVideoSync (unsigned int * value)
16321 {
16322   NVSG_GL_STATS_FCT_COUNT();
16323   NVSG_ASSERT( theGLXFunctions::instance()->glXGetVideoSyncSGI );
16324   return theGLXFunctions::instance()->glXGetVideoSyncSGI( value );
16325 }
16326
16327 inline int GLXWaitVideoSync (int divisor, int remainder, unsigned int * cnt)
16328 {
16329   NVSG_GL_STATS_FCT_COUNT();
16330   NVSG_ASSERT( theGLXFunctions::instance()->glXWaitVideoSyncSGI );
16331   return theGLXFunctions::instance()->glXWaitVideoSyncSGI( divisor, remainder,
16332                                                                         cnt );
16333 }
16334
16335 // GLX_NV_swap_group
16336 inline  Bool GLXJoinSwapGroup(Display *dpy, GLXDrawable drawable,
16337                              GLuint group)
16338 {
16339   NVSG_GL_STATS_FCT_COUNT();
16340   NVSG_ASSERT( theGLXFunctions::instance()->glXJoinSwapGroupNV );
16341   return theGLXFunctions::instance()->glXJoinSwapGroupNV(dpy,drawable,group);
16342 }
16343
16344 inline  Bool GLXBindSwapBarrier(Display *dpy, GLuint group,
16345                                                             GLuint barrier)
16346 {
16347   NVSG_GL_STATS_FCT_COUNT();
16348   NVSG_ASSERT( theGLXFunctions::instance()->glXBindSwapBarrierNV );
16349   return theGLXFunctions::instance()->glXBindSwapBarrierNV(dpy,group,barrier);
16350 }
16351
16352 inline  Bool GLXQuerySwapGroup(Display *dpy, GLXDrawable drawable,
16353                               GLuint *group, GLuint *barrier)
16354 {
16355   NVSG_GL_STATS_FCT_COUNT();
16356   NVSG_ASSERT( theGLXFunctions::instance()->glXQuerySwapGroupNV );
16357   return theGLXFunctions::instance()->glXQuerySwapGroupNV(dpy,drawable,group,
16358                                                                       barrier);
16359 }
16360
16361 inline  Bool GLXQueryMaxSwapGroups(Display *dpy, int screen,
16362                                   GLuint *maxGroups, GLuint *maxBarriers)
16363 {
16364   NVSG_GL_STATS_FCT_COUNT();
16365   NVSG_ASSERT( theGLXFunctions::instance()->glXQueryMaxSwapGroupsNV );
16366   return theGLXFunctions::instance()->glXQueryMaxSwapGroupsNV(dpy, screen,
16367                                                   maxGroups, maxBarriers );
16368 }
16369
16370 inline  Bool GLXQueryFrameCount(Display *dpy, int screen, GLuint *count)
16371 {
16372   NVSG_GL_STATS_FCT_COUNT();
16373   NVSG_ASSERT( theGLXFunctions::instance()->glXQueryFrameCountNV );
16374   return theGLXFunctions::instance()->glXQueryFrameCountNV(dpy, screen, count );
16375 }
16376
16377 inline  Bool GLXResetFrameCount(Display *dpy, int screen)
16378 {
16379   NVSG_GL_STATS_FCT_COUNT();
16380   NVSG_ASSERT( theGLXFunctions::instance()->glXResetFrameCountNV );
16381   return theGLXFunctions::instance()->glXResetFrameCountNV(dpy, screen );
16382 }
16383
16384
16385 // GLX_NV_video_out
16386 inline  int GLXGetVideoDevice(Display *dpy, int screen,
16387                               int numVideoDevices,
16388                              GLXVideoDeviceNV *pVideoDevice)
16389 {
16390   NVSG_GL_STATS_FCT_COUNT();
16391   NVSG_ASSERT( theGLXFunctions::instance()->glXGetVideoDeviceNV );
16392   return theGLXFunctions::instance()->glXGetVideoDeviceNV( dpy, screen,
16393                                               numVideoDevices, pVideoDevice );
16394 }
16395
16396 inline  int GLXReleaseVideoDevice(Display *dpy, int screen,
16397                                  GLXVideoDeviceNV VideoDevice)
16398 {
16399   NVSG_GL_STATS_FCT_COUNT();
16400   NVSG_ASSERT( theGLXFunctions::instance()->glXReleaseVideoDeviceNV );
16401   return theGLXFunctions::instance()->glXReleaseVideoDeviceNV(dpy,screen,
16402                                                                 VideoDevice);
16403 }
16404
16405 inline  int GLXBindVideoImage(Display *dpy,
16406                              GLXVideoDeviceNV VideoDevice,
16407                              GLXPbuffer pbuf, int iVideoBuffer)
16408 {
16409   NVSG_GL_STATS_FCT_COUNT();
16410   NVSG_ASSERT( theGLXFunctions::instance()->glXBindVideoImageNV );
16411   return theGLXFunctions::instance()->glXBindVideoImageNV(dpy, VideoDevice,pbuf,
16412                                                                 iVideoBuffer);
16413 }
16414
16415 inline  int GLXReleaseVideoImage(Display *dpy, GLXPbuffer pbuf)
16416 {
16417   NVSG_GL_STATS_FCT_COUNT();
16418   NVSG_ASSERT( theGLXFunctions::instance()->glXReleaseVideoImageNV );
16419   return theGLXFunctions::instance()->glXReleaseVideoImageNV(dpy,pbuf);
16420 }
16421
16422 inline  int GLXSendPbufferToVideo(Display *dpy, GLXPbuffer pbuf,
16423                                  int iBufferType,
16424                                  unsigned long *pulCounterPbuffer,
16425                                  GLboolean bBlock)
16426 {
16427   NVSG_GL_STATS_FCT_COUNT();
16428   NVSG_ASSERT( theGLXFunctions::instance()->glXSendPbufferToVideoNV );
16429   return theGLXFunctions::instance()->glXSendPbufferToVideoNV(dpy,pbuf,
16430                                     iBufferType, pulCounterPbuffer, bBlock );
16431 }
16432
16433 inline  int GLXGetVideoInfo(Display *dpy, int screen,
16434                            GLXVideoDeviceNV VideoDevice,
16435                            unsigned long *pulCounterOutputVideo,
16436                            unsigned long *pulCounterOutputPbuffer)
16437 {
16438   NVSG_GL_STATS_FCT_COUNT();
16439   NVSG_ASSERT( theGLXFunctions::instance()->glXGetVideoInfoNV );
16440   return theGLXFunctions::instance()->glXGetVideoInfoNV(dpy,screen,VideoDevice,
16441                               pulCounterOutputVideo, pulCounterOutputPbuffer );
16442 }
16443
16444 // GLX_EXT_texture_from_pixmap
16445 inline  void GLXBindTexImage (Display *dpy, GLXDrawable d, int buffer,
16446                                           const int * attrList)
16447 {
16448   NVSG_GL_STATS_FCT_COUNT();
16449   NVSG_ASSERT( theGLXFunctions::instance()->glXBindTexImageEXT );
16450   return theGLXFunctions::instance()->glXBindTexImageEXT( dpy, d, buffer,
16451                                                                     attrList );
16452 }
16453
16454 inline  void GLXReleaseTexImage (Display *dpy, GLXDrawable d, int buffer)
16455 {
16456   NVSG_GL_STATS_FCT_COUNT();
16457   NVSG_ASSERT( theGLXFunctions::instance()->glXReleaseTexImageEXT );
16458   return theGLXFunctions::instance()->glXReleaseTexImageEXT( dpy, d, buffer );
16459 }
16460
16461 #endif // LINUX
16462
16463 enum
16464 {
16465   GL_INVALID_BUFFER_TARGET = -1
16466   // specialized targets for vertex buffers
16467 , GL_VERTEX_BUFFER_INTERLEAVED_GENERIC = 0
16468 , GL_FEEDBACK_BUFFER_INTERLEAVED_GENERIC = 1
16469 , GL_VERTEX_BUFFER_FIRST = GL_VERTEX_BUFFER_INTERLEAVED_GENERIC
16470 , GL_VERTEX_BUFFER_LAST = GL_FEEDBACK_BUFFER_INTERLEAVED_GENERIC
16471 , GL_INDEX_BUFFER_UNSIGNED_SHORT
16472 , GL_INDEX_BUFFER_FIRST = GL_INDEX_BUFFER_UNSIGNED_SHORT
16473 , GL_INDEX_BUFFER_UNSIGNED_INT
16474 , GL_INDEX_BUFFER_LAST = GL_INDEX_BUFFER_UNSIGNED_INT
16475 , GL_NUM_BUFFER_TARGETS
16476 };
16477
16479
16481 NVSG_API void GLGenVertexBuffer(GLenum target, GLsizeiptr size, GLuint * buffer);
16482
16484
16486 NVSG_API void GLGenIndexBuffer(GLenum target, GLsizeiptr size, GLuint * buffer);
16487
16489
16492 NVSG_API void GLDeleteVertexBuffer(GLuint buffer);
16493
16495
16498 NVSG_API void GLDeleteIndexBuffer(GLuint buffer);
16499
16501
16503 NVSG_API void GLBindVertexBuffer(GLuint buffer);
16504
16506
16509 NVSG_API void GLBindTransformFeedbackBuffer(GLuint index, GLuint buffer, GLuint offset);
16510
16512
16514 NVSG_API void GLBindIndexBuffer(GLuint buffer);
16515
16517
16523 NVSG_API void GLUploadBuffers();
16524
16526
16538 NVSG_API GLvoid * GLMapVertexBuffer(GLuint buffer);
16539
16541
16553 NVSG_API GLvoid * GLMapIndexBuffer(GLuint buffer);
16554
16556
16563 NVSG_API GLboolean GLUnmapVertexBuffer(GLuint buffer);
16564
16566
16573 NVSG_API GLboolean GLUnmapIndexBuffer(GLuint buffer);
16574
16576
16579 NVSG_API GLsizeiptr GLGetVertexBufferOffset(GLuint buffer);
16580
16582
16584 NVSG_API void GLBuildVertexBufferCache( nvgl::GLArrayBufferCache * vi,
16585                                    GLuint whichBuffer,
16586                                    const nvsg::VertexAttributeSet * vas );
16587 NVSG_API void GLFillVertexBufferCache( nvgl::GLArrayBufferCache * vi, GLuint whichBuffer
16588                                       , const nvsg::VertexAttributeSet * vas );
16589
16590 NVSG_API void GLBuildIndexBufferCache( nvgl::GLElementArrayBufferCache* vi,
16591       GLsizeiptr offs, unsigned int numStrips, const nvsg::IndexSet * strips,
16592       bool primitiveRestartSupport );
16593
16594 NVSG_API void GLBuildIndexBufferCache( nvgl::GLElementArrayBufferCache* vi,
16595       GLsizeiptr offs, unsigned int numIndices, const unsigned int * indices );
16596
16597
16599
16602 NVSG_API GLsizeiptr GLGetIndexBufferOffset(GLuint buffer);
16603
16605
16607 NVSG_API GLboolean GLIsVertexBuffer(GLuint buffer);
16608
16610
16612 NVSG_API GLboolean GLIsIndexBuffer(GLuint buffer);
16613
16614 #if !defined(DOXYGEN_IGNORE)
16615 inline void _GLDisable( GLenum cap )
16616 {
16617   NVSG_GL_STATS_STATE( cap, false );
16618   glDisable( cap );
16619   ASSERT_GL_NO_ERROR;
16620 }
16621
16622 inline void _GLDisableClientState( GLenum array )
16623 {
16624   NVSG_GL_STATS_CLIENT_STATE( array, false );
16625   glDisableClientState( array );
16626   ASSERT_GL_NO_ERROR;
16627 }
16628
16629 inline void _GLEnable( GLenum cap )
16630 {
16631   NVSG_GL_STATS_STATE( cap, true );
16632   glEnable( cap );
16633   ASSERT_GL_NO_ERROR;
16634 }
16635
16636 inline void _GLEnableClientState( GLenum array )
16637 {
16638   NVSG_GL_STATS_CLIENT_STATE( array, true );
16639   glEnableClientState( array );
16640   ASSERT_GL_NO_ERROR;
16641 }
16642
16643 inline  void  _GLFogf( GLenum pname, GLfloat param )
16644 {
16645   NVSG_GL_STATS_FCT_COUNT();
16646   glFogf( pname, param );
16647   ASSERT_GL_NO_ERROR;
16648 }
16649
16650 inline  void  _GLFogfv( GLenum pname, const GLfloat * params )
16651 {
16652   NVSG_GL_STATS_FCT_COUNT();
16653   glFogfv( pname, params );
16654   ASSERT_GL_NO_ERROR;
16655 }
16656
16657 inline  void  _GLFogi( GLenum pname, GLint param )
16658 {
16659   NVSG_GL_STATS_FCT_COUNT();
16660   glFogi(pname, param);
16661   ASSERT_GL_NO_ERROR;
16662 }
16663
16664 inline  void  _GLFogiv( GLenum pname, const GLint * params )
16665 {
16666   NVSG_GL_STATS_FCT_COUNT();
16667   glFogiv(pname, params);
16668   ASSERT_GL_NO_ERROR;
16669 }
16670
16671 inline GLboolean _GLIsEnabled( GLenum cap )
16672 {
16673   NVSG_GL_STATS_FCT_COUNT();
16674   GLboolean isEnabled = glIsEnabled( cap );
16675   ASSERT_GL_NO_ERROR;
16676   return( isEnabled );
16677 }
16678
16679 inline  void  _GLLightf( GLenum light, GLenum pname, GLfloat param )
16680 {
16681   NVSG_GL_STATS_LIGHTF( light, pname, param );
16682   glLightf( light, pname, param );
16683   ASSERT_GL_NO_ERROR;
16684 }
16685
16686 inline void _GLLightfv( GLenum light, GLenum pname, const GLfloat *params )
16687 {
16688   NVSG_GL_STATS_LIGHTFV( light, pname, params );
16689   glLightfv( light, pname, params );
16690   ASSERT_GL_NO_ERROR;
16691 }
16692
16693 inline void _GLLighti( GLenum light, GLenum pname, GLint param )
16694 {
16695   NVSG_GL_STATS_LIGHTI( light, pname, param );
16696   glLighti( light, pname, param );
16697   ASSERT_GL_NO_ERROR;
16698 }
16699
16700 inline void _GLLightiv( GLenum light, GLenum pname, GLint *params )
16701 {
16702   NVSG_GL_STATS_LIGHTIV( light, pname, params );
16703   glLightiv( light, pname, params );
16704   ASSERT_GL_NO_ERROR;
16705 }
16706
16707 inline void _GLLightModelf( GLenum pname, GLfloat param )
16708 {
16709   NVSG_GL_STATS_LIGHT_MODELF( pname, param );
16710   glLightModelf( pname, param );
16711   ASSERT_GL_NO_ERROR;
16712 }
16713
16714 inline void _GLLightModelfv( GLenum pname, const GLfloat *params )
16715 {
16716   NVSG_GL_STATS_LIGHT_MODELFV( pname, params );
16717   glLightModelfv( pname, params );
16718   ASSERT_GL_NO_ERROR;
16719 }
16720
16721 inline void _GLLightModeli( GLenum pname, GLint param )
16722 {
16723   NVSG_GL_STATS_LIGHT_MODELI( pname, param );
16724   glLightModeli( pname, param );
16725   ASSERT_GL_NO_ERROR;
16726 }
16727
16728 inline void _GLLightModeliv( GLenum pname, const GLint *params )
16729 {
16730   NVSG_GL_STATS_LIGHT_MODELIV( pname, params );
16731   glLightModeliv( pname, params );
16732   ASSERT_GL_NO_ERROR;
16733 }
16734
16735 inline  void  _GLMaterialf( GLenum face, GLenum pname, GLfloat param )
16736 {
16737   NVSG_GL_STATS_MATERIALF( face, pname, param );
16738   glMaterialf( face, pname, param );
16739   ASSERT_GL_NO_ERROR;
16740 }
16741
16742 inline void _GLMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
16743 {
16744   NVSG_GL_STATS_MATERIALFV( face, pname, params );
16745   glMaterialfv( face, pname, params );
16746   ASSERT_GL_NO_ERROR;
16747 }
16748
16749 inline void _GLMateriali( GLenum face, GLenum pname, GLint param )
16750 {
16751   NVSG_GL_STATS_MATERIALI( face, pname, param );
16752   glMateriali( face, pname, param );
16753   ASSERT_GL_NO_ERROR;
16754 }
16755
16756 inline void _GLMaterialiv( GLenum face, GLenum pname, const GLint *params )
16757 {
16758   NVSG_GL_STATS_MATERIALIV( face, pname, params );
16759   glMaterialiv( face, pname, params );
16760   ASSERT_GL_NO_ERROR;
16761 }
16762
16763 inline void _GLPolygonMode( GLenum face, GLenum mode )
16764 {
16765   NVSG_GL_STATS_POLYGON_MODE( face, mode );
16766   glPolygonMode( face, mode );
16767   ASSERT_GL_NO_ERROR;
16768 }
16769
16770 inline  void  _GLTexEnvf( GLenum target, GLenum pname, GLfloat param )
16771 {
16772   NVSG_GL_STATS_TEX_ENVF( target, pname, param );
16773   glTexEnvf( target, pname, param );
16774   ASSERT_GL_NO_ERROR;
16775 }
16776
16777 inline void _GLTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
16778 {
16779   NVSG_GL_STATS_TEX_ENVFV( target, pname, params );
16780   glTexEnvfv( target, pname, params );
16781   ASSERT_GL_NO_ERROR;
16782 }
16783
16784 inline void _GLTexEnvi( GLenum target, GLenum pname, GLint param )
16785 {
16786   NVSG_GL_STATS_TEX_ENVI( target, pname, param );
16787   glTexEnvi( target, pname, param );
16788   ASSERT_GL_NO_ERROR;
16789 }
16790
16791 inline void _GLTexEnviv( GLenum target, GLenum pname, const GLint *params )
16792 {
16793   NVSG_GL_STATS_TEX_ENVIV( target, pname, params );
16794   glTexEnviv( target, pname, params );
16795   ASSERT_GL_NO_ERROR;
16796 }
16797
16798 inline  void  _GLTexParameterf( GLenum target, GLenum pname, GLfloat param )
16799 {
16800   NVSG_GL_STATS_TEX_PARAMETERF( target, pname, param );
16801   glTexParameterf( target, pname, param );
16802   ASSERT_GL_NO_ERROR;
16803 }
16804
16805 inline void _GLTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
16806 {
16807   NVSG_GL_STATS_TEX_PARAMETERFV( target, pname, params );
16808   glTexParameterfv( target, pname, params );
16809   ASSERT_GL_NO_ERROR;
16810 }
16811
16812 inline void _GLTexParameteri( GLenum target, GLenum pname, GLint param )
16813 {
16814   NVSG_GL_STATS_TEX_PARAMETERI( target, pname, param );
16815   glTexParameteri( target, pname, param );
16816   ASSERT_GL_NO_ERROR;
16817 }
16818
16819 inline void _GLTexParameteriv( GLenum target, GLenum pname, const GLint *params )
16820 {
16821   NVSG_GL_STATS_TEX_PARAMETERIV( target, pname, params );
16822   glTexParameteriv( target, pname, params );
16823   ASSERT_GL_NO_ERROR;
16824 }
16825
16826 #if defined( GL_CACHING )
16827
16828 inline  void  _GLUpdateActiveTexture( void )
16829 {
16830   GLContext * ctx = glContext();
16831   if ( ctx->m_textureAttributes.m_toActivate != ctx->m_textureAttributes.m_active )
16832   {
16833 #if !defined(NDEBUG)
16834     GLint at;
16835     glGetIntegerv( GL_ACTIVE_TEXTURE, &at );
16836     NVSG_ASSERT( at == GL_TEXTURE0 + ctx->m_textureAttributes.m_active );
16837 #endif
16838     ctx->m_textureAttributes.m_active = ctx->m_textureAttributes.m_toActivate;
16839     NVSG_GL_STATS_ACTIVE_TEXTURE( GL_TEXTURE0 + ctx->m_textureAttributes.m_active );
16840     ctx->m_glFunctions->glActiveTexture( GL_TEXTURE0 + ctx->m_textureAttributes.m_active );
16841   }
16842 }
16843
16844 inline  void  _GLUpdateClientActiveTexture( void )
16845 {
16846   GLContext * ctx = glContext();
16847   if ( ctx->m_vertexArrayAttributes.m_clientTextureToActivate != ctx->m_vertexArrayAttributes.m_clientTextureActive )
16848   {
16849 #if !defined(NDEBUG)
16850     GLint cat;
16851     glGetIntegerv( GL_CLIENT_ACTIVE_TEXTURE, &cat );
16852     NVSG_ASSERT( cat == GL_TEXTURE0 + ctx->m_vertexArrayAttributes.m_clientTextureActive );
16853 #endif
16854     ctx->m_vertexArrayAttributes.m_clientTextureActive = ctx->m_vertexArrayAttributes.m_clientTextureToActivate;
16855     NVSG_GL_STATS_CLIENT_ACTIVE_TEXTURE( GL_TEXTURE0 + ctx->m_vertexArrayAttributes.m_clientTextureActive );
16856     ctx->m_glFunctions->glClientActiveTexture( GL_TEXTURE0 + ctx->m_vertexArrayAttributes.m_clientTextureActive );
16857   }
16858 }
16859
16860 #endif
16861
16862 #endif // DOXYGEN_IGNORE
16863
16864 } // namespace nvgl
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLDALData.h File Reference

#include "nvsg/DAL.h"
#include "nvgl/GLContext.h"
#include "nvsg/VertexAttributeSet.h"
#include <vector>
#include <set>

Include dependency graph for GLDALData.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvgl

Detailed Description

Generated on Tue Jan 15 10:27:41 2008 for NVSGSDK by NVIDIA


GLDALData.h Source File

GLDALData.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/DAL.h"
00016 #include "nvgl/GLContext.h"
00017 #include "nvsg/VertexAttributeSet.h"
00018 #include <vector>
00019 #include <set>
00020
00021 namespace nvgl
00022 {
00023   // interface to provide lazy cleanup of dangling GL resources
00024   class GLResourceDeleter
00025   {
00026   public:
00027     GLResourceDeleter(GLsizei n, GLuint * names) : m_names(&names[0], &names[n]) {}
00028     virtual ~GLResourceDeleter() {}
00029     virtual void release() { m_names.clear(); delete this; }
00030   protected:
00031     std::vector<GLuint> m_names;
00032   };
00033
00034   // identifier for device abstraction layer data
00035   enum
00036   {
00037     GL_BUFFER = 0x00000001
00038     , GL_DL  = 0x00000002
00039     , GL_TEX = 0x00000004
00040   };
00041
00042   class GLDALDataCreator : public nvsg::DALDataCreator
00043   {
00044   public:
00045     NVSG_API ~GLDALDataCreator();
00046     NVSG_API void onReleaseDAL(nvsg::HDAL); // overrides DALDataCreator::onReleaseDAL
00047     NVSG_API void exit();  // performs cleanup on exit
00048
00049     // add/release lists
00050     NVSG_API void addDisplayList(nvsg::HDAL);
00051     NVSG_API void releaseDisplayLists();
00052     // add/release buffers
00053     NVSG_API void addBuffer(nvsg::HDAL);
00054     NVSG_API void releaseBuffers();
00055     // add/release textures
00056     NVSG_API void addTexture(nvsg::HDAL);
00057     NVSG_API void releaseTextures();
00058     // add/release dangling resources
00059     NVSG_API void addDanglingResource(GLResourceDeleter*);
00060     NVSG_API void releaseDanglingResources();
00061
00062   private:
00063
00064     // DAL resources
00065     std::set<nvsg::HDAL> m_lists;
00066     std::set<nvsg::HDAL> m_buffers;
00067     std::set<nvsg::HDAL> m_textures;
00068
00069     // dangling resource management
00070     nvutil::SWMRSync m_lock;
00071     void enterCS() { m_lock.lockExclusive(); }
00072     void leaveCS() { m_lock.unlockExclusive(); }
00073     std::vector<GLResourceDeleter*> m_danglingResources;
00074   };
00075
00076   struct GLDALData : public nvsg::DALData
00077   {
00078     NVSG_API GLDALData(GLDALDataCreator * _creator);
00079     NVSG_API virtual ~GLDALData();
00080     GLContext * context;
00081     GLDALDataCreator * creator;
00082   };
00083
00084   // DAL data carrying device dependent texture IDs
00085   struct GLTextureCache : public GLDALData
00086   {
00087     NVSG_API GLTextureCache(GLDALDataCreator * creator);
00088     NVSG_API GLTextureCache(GLDALDataCreator * creator, GLuint tex, GLenum tgt);
00089     NVSG_API ~GLTextureCache();
00090
00091     struct Deleter : public GLResourceDeleter
00092     {
00093       Deleter(GLuint name) : GLResourceDeleter(1, &name) {}
00094       void release();
00095     };
00096
00097     struct GLImageFormat
00098     {
00099       GLImageFormat()
00100         : levels(~0)
00101         , width(0)
00102         , height(0)
00103         , depth(0)
00104         , format(~0)
00105         , type(~0)
00106       {}
00107
00108       GLsizei levels; // # mipmap levels specfied
00109       GLsizei width;  // width of level 0 image in pixels
00110       GLsizei height; // height of level 0 image in pixels
00111       GLsizei depth;  // depth of level 0 image in pixels
00112       GLenum  format; // user format identifier
00113       GLenum  type;   // data type identifier
00114     };
00115
00116     GLuint  texture; // GL name of the texture object
00117     GLenum  target;  // texture target
00118     GLImageFormat imgFmt; // describes the image as specified by GLTexImage.
00119                           // this is going to be evaluated for re-use purposes
00120   };
00121
00122   struct GLDisplayListCache : public GLDALData
00123   {
00124     NVSG_API GLDisplayListCache(GLDALDataCreator * creator);
00125     NVSG_API ~GLDisplayListCache();
00126
00127     struct Deleter : public GLResourceDeleter
00128     {
00129       Deleter(GLuint name) : GLResourceDeleter(1, &name) {}
00130       void release();
00131     };
00132
00133     GLuint listID;
00134   };
00135
00136   struct GLArrayBufferCache : public GLDALData
00137   {
00138     GLArrayBufferCache(GLDALDataCreator * creator);
00139     ~GLArrayBufferCache();
00140
00141     struct Deleter : public GLResourceDeleter
00142     {
00143       // not sure how to fix this for the moment
00144       Deleter(GLuint * names) : GLResourceDeleter(2, names) {}
00145       void release();
00146     };
00147
00148     struct {
00149       GLuint vbo;         // vertex buffer identifier
00150       // how do we delete this?
00151       GLsizei stride;  // byte offset between consecutive vertex attribute data of same type
00152       GLsizei size;    // buffer size
00153       GLsizeiptr attribOffsets[nvsg::VertexAttributeSet::NVSG_VERTEX_ATTRIB_COUNT]; // per vertex attribute offset into vertex buffer
00154       GLenum attribType[nvsg::VertexAttributeSet::NVSG_VERTEX_ATTRIB_COUNT]; // per attribute type
00155     } vbo[2];
00156
00157     GLuint target;
00158   };
00159
00160   struct GLElementArrayBufferCache : public GLDALData
00161   {
00162     GLElementArrayBufferCache(GLDALDataCreator * creator);
00163     ~GLElementArrayBufferCache();
00164
00165     struct Deleter : public GLResourceDeleter
00166     {
00167       Deleter(GLuint name) : GLResourceDeleter(1, &name) {}
00168       void release();
00169     };
00170
00171     GLuint ibo;   // index buffer identifier
00172     GLsizeiptr indexOffset; // offest into index buffer
00173     GLenum indexType;      // type used with indices (either GL_UNSIGNED_INT or GL_UNSIGNED_SHORT)
00174     GLsizei numIndices;     // total number of indices
00175     GLuint  startIndex;   // start - end range for glDrawRangeElements
00176     GLuint  endIndex;     // ...
00177     // multi draw elements related
00178     GLvoid ** primitiveOffsets;    // per primitive offset into index buffer
00179     GLsizei * primitiveIndexCount; // per primitive index count
00180   };
00181
00182   struct GLPixelBufferCache : public GLDALData
00183   {
00184     GLPixelBufferCache(GLDALDataCreator * creator);
00185     ~GLPixelBufferCache();
00186
00187     struct Deleter : public GLResourceDeleter
00188     {
00189       Deleter(GLuint * names) : GLResourceDeleter(2, names) {}
00190       void release();
00191     };
00192
00193     GLuint pbo[2];
00194     GLint  target; // 0 or 1, toggling
00195   };
00196
00197 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLFunctions.h File Reference

#include "nvsgcommon.h"
#include <set>
#include <string>

Include dependency graph for GLFunctions.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvgl

Detailed Description

Generated on Tue Jan 15 10:27:42 2008 for NVSGSDK by NVIDIA


GLFunctions.h Source File

GLFunctions.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include  <set>
00018 #include  <string>
00019
00020 namespace nvgl
00021 {
00022
00024
00029   class GLFunctions
00030   {
00031     public:
00033 #if defined(_WIN32)
00034       GLFunctions( void );
00035 #elif defined(LINUX)
00036       GLFunctions( Display* dpy );
00037 #endif
00038
00040       ~GLFunctions( void );
00041
00043
00047       bool  isAvailable( const std::string& extension
00048                        ) const;
00049
00051
00054       bool  isExported( const std::string& extension
00055                       ) const;
00056
00058
00061       int getVersion() const;
00062
00063     public:
00064 //  Don't need to document all these wrapper functions !!!
00065 #if ! defined( DOXYGEN_IGNORE )
00066       //  version 1.2 functions
00067       PFNGLBLENDCOLORPROC                         glBlendColor;
00068       PFNGLBLENDEQUATIONPROC                      glBlendEquation;
00069       PFNGLCOLORTABLEPROC                         glColorTable;
00070       PFNGLCOLORTABLEPARAMETERFVPROC              glColorTableParameterfv;
00071       PFNGLCOLORTABLEPARAMETERIVPROC              glColorTableParameteriv;
00072       PFNGLCOPYCOLORTABLEPROC                     glCopyColorTable;
00073       PFNGLCOPYTEXSUBIMAGE3DPROC                  glCopyTexSubImage3D;
00074       PFNGLDRAWRANGEELEMENTSPROC                  glDrawRangeElements;
00075       PFNGLGETCOLORTABLEPROC                      glGetColorTable;
00076       PFNGLGETCOLORTABLEPARAMETERFVPROC           glGetColorTableParameterfv;
00077       PFNGLGETCOLORTABLEPARAMETERIVPROC           glGetColorTableParameteriv;
00078       PFNGLTEXIMAGE3DPROC                         glTexImage3D;
00079       PFNGLTEXSUBIMAGE3DPROC                      glTexSubImage3D;
00080
00081       //  version 1.3 functions
00082       PFNGLACTIVETEXTUREPROC                      glActiveTexture;
00083       PFNGLCLIENTACTIVETEXTUREPROC                glClientActiveTexture;
00084       PFNGLCOMPRESSEDTEXIMAGE3DPROC               glCompressedTexImage3D;
00085       PFNGLCOMPRESSEDTEXIMAGE2DPROC               glCompressedTexImage2D;
00086       PFNGLCOMPRESSEDTEXIMAGE1DPROC               glCompressedTexImage1D;
00087       PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC            glCompressedTexSubImage3D;
00088       PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC            glCompressedTexSubImage2D;
00089       PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC            glCompressedTexSubImage1D;
00090       PFNGLGETCOMPRESSEDTEXIMAGEPROC              glGetCompressedTexImage;
00091       PFNGLLOADTRANSPOSEMATRIXFPROC               glLoadTransposeMatrixf;
00092       PFNGLLOADTRANSPOSEMATRIXDPROC               glLoadTransposeMatrixd;
00093       PFNGLMULTITEXCOORD1DPROC                    glMultiTexCoord1d;
00094       PFNGLMULTITEXCOORD1DVPROC                   glMultiTexCoord1dv;
00095       PFNGLMULTITEXCOORD1FPROC                    glMultiTexCoord1f;
00096       PFNGLMULTITEXCOORD1FVPROC                   glMultiTexCoord1fv;
00097       PFNGLMULTITEXCOORD1IPROC                    glMultiTexCoord1i;
00098       PFNGLMULTITEXCOORD1IVPROC                   glMultiTexCoord1iv;
00099       PFNGLMULTITEXCOORD1SPROC                    glMultiTexCoord1s;
00100       PFNGLMULTITEXCOORD1SVPROC                   glMultiTexCoord1sv;
00101       PFNGLMULTITEXCOORD2DPROC                    glMultiTexCoord2d;
00102       PFNGLMULTITEXCOORD2DVPROC                   glMultiTexCoord2dv;
00103       PFNGLMULTITEXCOORD2FPROC                    glMultiTexCoord2f;
00104       PFNGLMULTITEXCOORD2FVPROC                   glMultiTexCoord2fv;
00105       PFNGLMULTITEXCOORD2IPROC                    glMultiTexCoord2i;
00106       PFNGLMULTITEXCOORD2IVPROC                   glMultiTexCoord2iv;
00107       PFNGLMULTITEXCOORD2SPROC                    glMultiTexCoord2s;
00108       PFNGLMULTITEXCOORD2SVPROC                   glMultiTexCoord2sv;
00109       PFNGLMULTITEXCOORD3DPROC                    glMultiTexCoord3d;
00110       PFNGLMULTITEXCOORD3DVPROC                   glMultiTexCoord3dv;
00111       PFNGLMULTITEXCOORD3FPROC                    glMultiTexCoord3f;
00112       PFNGLMULTITEXCOORD3FVPROC                   glMultiTexCoord3fv;
00113       PFNGLMULTITEXCOORD3IPROC                    glMultiTexCoord3i;
00114       PFNGLMULTITEXCOORD3IVPROC                   glMultiTexCoord3iv;
00115       PFNGLMULTITEXCOORD3SPROC                    glMultiTexCoord3s;
00116       PFNGLMULTITEXCOORD3SVPROC                   glMultiTexCoord3sv;
00117       PFNGLMULTITEXCOORD4DPROC                    glMultiTexCoord4d;
00118       PFNGLMULTITEXCOORD4DVPROC                   glMultiTexCoord4dv;
00119       PFNGLMULTITEXCOORD4FPROC                    glMultiTexCoord4f;
00120       PFNGLMULTITEXCOORD4FVPROC                   glMultiTexCoord4fv;
00121       PFNGLMULTITEXCOORD4IPROC                    glMultiTexCoord4i;
00122       PFNGLMULTITEXCOORD4IVPROC                   glMultiTexCoord4iv;
00123       PFNGLMULTITEXCOORD4SPROC                    glMultiTexCoord4s;
00124       PFNGLMULTITEXCOORD4SVPROC                   glMultiTexCoord4sv;
00125       PFNGLMULTTRANSPOSEMATRIXFPROC               glMultTransposeMatrixf;
00126       PFNGLMULTTRANSPOSEMATRIXDPROC               glMultTransposeMatrixd;
00127       PFNGLSAMPLECOVERAGEPROC                     glSampleCoverage;
00128
00129       //  version 1.4 functions
00130       PFNGLBLENDFUNCSEPARATEPROC                  glBlendFuncSeparate;
00131       PFNGLFOGCOORDDPROC                          glFogCoordd;
00132       PFNGLFOGCOORDDVPROC                         glFogCoorddv;
00133       PFNGLFOGCOORDFPROC                          glFogCoordf;
00134       PFNGLFOGCOORDFVPROC                         glFogCoordfv;
00135       PFNGLFOGCOORDPOINTERPROC                    glFogCoordPointer;
00136       PFNGLMULTIDRAWARRAYSPROC                    glMultiDrawArrays;
00137       PFNGLMULTIDRAWELEMENTSPROC                  glMultiDrawElements;
00138       PFNGLPOINTPARAMETERFPROC                    glPointParameterf;
00139       PFNGLPOINTPARAMETERFVPROC                   glPointParameterfv;
00140       PFNGLPOINTPARAMETERIPROC                    glPointParameteri;
00141       PFNGLPOINTPARAMETERIVPROC                   glPointParameteriv;
00142       PFNGLSECONDARYCOLOR3BPROC                   glSecondaryColor3b;
00143       PFNGLSECONDARYCOLOR3BVPROC                  glSecondaryColor3bv;
00144       PFNGLSECONDARYCOLOR3DPROC                   glSecondaryColor3d;
00145       PFNGLSECONDARYCOLOR3DVPROC                  glSecondaryColor3dv;
00146       PFNGLSECONDARYCOLOR3FPROC                   glSecondaryColor3f;
00147       PFNGLSECONDARYCOLOR3FVPROC                  glSecondaryColor3fv;
00148       PFNGLSECONDARYCOLOR3IPROC                   glSecondaryColor3i;
00149       PFNGLSECONDARYCOLOR3IVPROC                  glSecondaryColor3iv;
00150       PFNGLSECONDARYCOLOR3SPROC                   glSecondaryColor3s;
00151       PFNGLSECONDARYCOLOR3SVPROC                  glSecondaryColor3sv;
00152       PFNGLSECONDARYCOLOR3UBPROC                  glSecondaryColor3ub;
00153       PFNGLSECONDARYCOLOR3UBVPROC                 glSecondaryColor3ubv;
00154       PFNGLSECONDARYCOLOR3UIPROC                  glSecondaryColor3ui;
00155       PFNGLSECONDARYCOLOR3UIVPROC                 glSecondaryColor3uiv;
00156       PFNGLSECONDARYCOLOR3USPROC                  glSecondaryColor3us;
00157       PFNGLSECONDARYCOLOR3USVPROC                 glSecondaryColor3usv;
00158       PFNGLSECONDARYCOLORPOINTERPROC              glSecondaryColorPointer;
00159       PFNGLWINDOWPOS2DPROC                        glWindowPos2d;
00160       PFNGLWINDOWPOS2FPROC                        glWindowPos2f;
00161       PFNGLWINDOWPOS2IPROC                        glWindowPos2i;
00162       PFNGLWINDOWPOS2SPROC                        glWindowPos2s;
00163       PFNGLWINDOWPOS2DVPROC                       glWindowPos2dv;
00164       PFNGLWINDOWPOS2FVPROC                       glWindowPos2fv;
00165       PFNGLWINDOWPOS2IVPROC                       glWindowPos2iv;
00166       PFNGLWINDOWPOS2SVPROC                       glWindowPos2sv;
00167       PFNGLWINDOWPOS3DPROC                        glWindowPos3d;
00168       PFNGLWINDOWPOS3FPROC                        glWindowPos3f;
00169       PFNGLWINDOWPOS3IPROC                        glWindowPos3i;
00170       PFNGLWINDOWPOS3SPROC                        glWindowPos3s;
00171       PFNGLWINDOWPOS3DVPROC                       glWindowPos3dv;
00172       PFNGLWINDOWPOS3FVPROC                       glWindowPos3fv;
00173       PFNGLWINDOWPOS3IVPROC                       glWindowPos3iv;
00174       PFNGLWINDOWPOS3SVPROC                       glWindowPos3sv;
00175
00176       //  version 1.5 functions
00177       PFNGLBEGINQUERYPROC                         glBeginQuery;
00178       PFNGLBINDBUFFERPROC                         glBindBuffer;
00179       PFNGLBUFFERDATAPROC                         glBufferData;
00180       PFNGLBUFFERSUBDATAPROC                      glBufferSubData;
00181       PFNGLDELETEBUFFERSPROC                      glDeleteBuffers;
00182       PFNGLDELETEQUERIESPROC                      glDeleteQueries;
00183       PFNGLENDQUERYPROC                           glEndQuery;
00184       PFNGLGENBUFFERSPROC                         glGenBuffers;
00185       PFNGLGENQUERIESPROC                         glGenQueries;
00186       PFNGLGETBUFFERPARAMETERIVPROC               glGetBufferParameteriv;
00187       PFNGLGETBUFFERPOINTERVPROC                  glGetBufferPointerv;
00188       PFNGLGETBUFFERSUBDATAPROC                   glGetBufferSubData;
00189       PFNGLGETQUERYOBJECTIVPROC                   glGetQueryObjectiv;
00190       PFNGLGETQUERYOBJECTUIVPROC                  glGetQueryObjectuiv;
00191       PFNGLGETQUERYIVPROC                         glGetQueryiv;
00192       PFNGLISBUFFERPROC                           glIsBuffer;
00193       PFNGLISQUERYPROC                            glIsQuery;
00194       PFNGLMAPBUFFERPROC                          glMapBuffer;
00195       PFNGLUNMAPBUFFERPROC                        glUnmapBuffer;
00196
00197       //  version 2.0 functions
00198       PFNGLATTACHSHADERPROC                       glAttachShader;
00199       PFNGLBINDATTRIBLOCATIONPROC                 glBindAttribLocation;
00200       PFNGLBLENDEQUATIONSEPARATEPROC              glBlendEquationSeparate;
00201       PFNGLCOMPILESHADERPROC                      glCompileShader;
00202       PFNGLCREATEPROGRAMPROC                      glCreateProgram;
00203       PFNGLCREATESHADERPROC                       glCreateShader;
00204       PFNGLDELETEPROGRAMPROC                      glDeleteProgram;
00205       PFNGLDELETESHADERPROC                       glDeleteShader;
00206       PFNGLDETACHSHADERPROC                       glDetachShader;
00207       PFNGLDISABLEVERTEXATTRIBARRAYPROC           glDisableVertexAttribArray;
00208       PFNGLDRAWBUFFERSARBPROC                     glDrawBuffers;
00209       PFNGLENABLEVERTEXATTRIBARRAYPROC            glEnableVertexAttribArray;
00210       PFNGLLINKPROGRAMPROC                        glLinkProgram;
00211       PFNGLGETACTIVEATTRIBPROC                    glGetActiveAttrib;
00212       PFNGLGETACTIVEUNIFORMPROC                   glGetActiveUniform;
00213       PFNGLGETATTACHEDSHADERSPROC                 glGetAttachedShaders;
00214       PFNGLGETATTRIBLOCATIONPROC                  glGetAttribLocation;
00215       PFNGLGETPROGRAMIVPROC                       glGetProgramiv;
00216       PFNGLGETPROGRAMINFOLOGPROC                  glGetProgramInfoLog;
00217       PFNGLGETSHADERIVPROC                        glGetShaderiv;
00218       PFNGLGETSHADERINFOLOGPROC                   glGetShaderInfoLog;
00219       PFNGLGETSHADERSOURCEPROC                    glGetShaderSource;
00220       PFNGLGETUNIFORMFVPROC                       glGetUniformfv;
00221       PFNGLGETUNIFORMIVPROC                       glGetUniformiv;
00222       PFNGLGETUNIFORMLOCATIONPROC                 glGetUniformLocation;
00223       PFNGLGETVERTEXATTRIBDVPROC                  glGetVertexAttribdv;
00224       PFNGLGETVERTEXATTRIBFVPROC                  glGetVertexAttribfv;
00225       PFNGLGETVERTEXATTRIBIVPROC                  glGetVertexAttribiv;
00226       PFNGLGETVERTEXATTRIBPOINTERVPROC            glGetVertexAttribPointerv;
00227       PFNGLISPROGRAMPROC                          glIsProgram;
00228       PFNGLISSHADERPROC                           glIsShader;
00229       PFNGLSHADERSOURCEPROC                       glShaderSource;
00230       PFNGLSTENCILFUNCSEPARATEPROC                glStencilFuncSeparate;
00231       PFNGLSTENCILOPSEPARATEPROC                  glStencilOpSeparate;
00232       PFNGLSTENCILMASKSEPARATEPROC                glStencilMaskSeparate;
00233       PFNGLUNIFORM1FPROC                          glUniform1f;
00234       PFNGLUNIFORM1FVPROC                         glUniform1fv;
00235       PFNGLUNIFORM1IPROC                          glUniform1i;
00236       PFNGLUNIFORM1IVPROC                         glUniform1iv;
00237       PFNGLUNIFORM2FPROC                          glUniform2f;
00238       PFNGLUNIFORM2FVPROC                         glUniform2fv;
00239       PFNGLUNIFORM2IPROC                          glUniform2i;
00240       PFNGLUNIFORM2IVPROC                         glUniform2iv;
00241       PFNGLUNIFORM3FPROC                          glUniform3f;
00242       PFNGLUNIFORM3FVPROC                         glUniform3fv;
00243       PFNGLUNIFORM3IPROC                          glUniform3i;
00244       PFNGLUNIFORM3IVPROC                         glUniform3iv;
00245       PFNGLUNIFORM4FPROC                          glUniform4f;
00246       PFNGLUNIFORM4FVPROC                         glUniform4fv;
00247       PFNGLUNIFORM4IPROC                          glUniform4i;
00248       PFNGLUNIFORM4IVPROC                         glUniform4iv;
00249       PFNGLUNIFORMMATRIX2FVPROC                   glUniformMatrix2fv;
00250       PFNGLUNIFORMMATRIX3FVPROC                   glUniformMatrix3fv;
00251       PFNGLUNIFORMMATRIX4FVPROC                   glUniformMatrix4fv;
00252       PFNGLUSEPROGRAMPROC                         glUseProgram;
00253       PFNGLVALIDATEPROGRAMPROC                    glValidateProgram;
00254       PFNGLVERTEXATTRIB1DPROC                     glVertexAttrib1d;
00255       PFNGLVERTEXATTRIB1DVPROC                    glVertexAttrib1dv;
00256       PFNGLVERTEXATTRIB1FPROC                     glVertexAttrib1f;
00257       PFNGLVERTEXATTRIB1FVPROC                    glVertexAttrib1fv;
00258       PFNGLVERTEXATTRIB1SPROC                     glVertexAttrib1s;
00259       PFNGLVERTEXATTRIB1SVPROC                    glVertexAttrib1sv;
00260       PFNGLVERTEXATTRIB2DPROC                     glVertexAttrib2d;
00261       PFNGLVERTEXATTRIB2DVPROC                    glVertexAttrib2dv;
00262       PFNGLVERTEXATTRIB2FPROC                     glVertexAttrib2f;
00263       PFNGLVERTEXATTRIB2FVPROC                    glVertexAttrib2fv;
00264       PFNGLVERTEXATTRIB2SPROC                     glVertexAttrib2s;
00265       PFNGLVERTEXATTRIB2SVPROC                    glVertexAttrib2sv;
00266       PFNGLVERTEXATTRIB3DPROC                     glVertexAttrib3d;
00267       PFNGLVERTEXATTRIB3DVPROC                    glVertexAttrib3dv;
00268       PFNGLVERTEXATTRIB3FPROC                     glVertexAttrib3f;
00269       PFNGLVERTEXATTRIB3FVPROC                    glVertexAttrib3fv;
00270       PFNGLVERTEXATTRIB3SPROC                     glVertexAttrib3s;
00271       PFNGLVERTEXATTRIB3SVPROC                    glVertexAttrib3sv;
00272       PFNGLVERTEXATTRIB4NBVPROC                   glVertexAttrib4Nbv;
00273       PFNGLVERTEXATTRIB4NIVPROC                   glVertexAttrib4Niv;
00274       PFNGLVERTEXATTRIB4NSVPROC                   glVertexAttrib4Nsv;
00275       PFNGLVERTEXATTRIB4NUBPROC                   glVertexAttrib4Nub;
00276       PFNGLVERTEXATTRIB4NUBVPROC                  glVertexAttrib4Nubv;
00277       PFNGLVERTEXATTRIB4NUIVPROC                  glVertexAttrib4Nuiv;
00278       PFNGLVERTEXATTRIB4NUSVPROC                  glVertexAttrib4Nusv;
00279       PFNGLVERTEXATTRIB4BVPROC                    glVertexAttrib4bv;
00280       PFNGLVERTEXATTRIB4DPROC                     glVertexAttrib4d;
00281       PFNGLVERTEXATTRIB4DVPROC                    glVertexAttrib4dv;
00282       PFNGLVERTEXATTRIB4FPROC                     glVertexAttrib4f;
00283       PFNGLVERTEXATTRIB4FVPROC                    glVertexAttrib4fv;
00284       PFNGLVERTEXATTRIB4IVPROC                    glVertexAttrib4iv;
00285       PFNGLVERTEXATTRIB4SPROC                     glVertexAttrib4s;
00286       PFNGLVERTEXATTRIB4SVPROC                    glVertexAttrib4sv;
00287       PFNGLVERTEXATTRIB4UBVPROC                   glVertexAttrib4ubv;
00288       PFNGLVERTEXATTRIB4UIVPROC                   glVertexAttrib4uiv;
00289       PFNGLVERTEXATTRIB4USVPROC                   glVertexAttrib4usv;
00290       PFNGLVERTEXATTRIBPOINTERPROC                glVertexAttribPointer;
00291
00292       //  version 2.1 functions
00293       PFNGLUNIFORMMATRIX2X3FVPROC                 glUniformMatrix2x3fv;
00294       PFNGLUNIFORMMATRIX2X4FVPROC                 glUniformMatrix2x4fv;
00295       PFNGLUNIFORMMATRIX3X2FVPROC                 glUniformMatrix3x2fv;
00296       PFNGLUNIFORMMATRIX3X4FVPROC                 glUniformMatrix3x4fv;
00297       PFNGLUNIFORMMATRIX4X2FVPROC                 glUniformMatrix4x2fv;
00298       PFNGLUNIFORMMATRIX4X3FVPROC                 glUniformMatrix4x3fv;
00299
00300       //  GL_ARB_color_buffer_float functions
00301       PFNGLCLAMPCOLORARBPROC                      glClampColor;
00302
00303       //  GL_ARB_fragment_program functions see GL_ARB_vertex_program
00304
00305       //  GL_ARB_imaging functions
00306       PFNGLCOLORSUBTABLEPROC                      glColorSubTable;
00307       PFNGLCOPYCOLORSUBTABLEPROC                  glCopyColorSubTable;
00308       PFNGLCONVOLUTIONFILTER1DPROC                glConvolutionFilter1D;
00309       PFNGLCONVOLUTIONFILTER2DPROC                glConvolutionFilter2D;
00310       PFNGLCONVOLUTIONPARAMETERFPROC              glConvolutionParameterf;
00311       PFNGLCONVOLUTIONPARAMETERFVPROC             glConvolutionParameterfv;
00312       PFNGLCONVOLUTIONPARAMETERIPROC              glConvolutionParameteri;
00313       PFNGLCONVOLUTIONPARAMETERIVPROC             glConvolutionParameteriv;
00314       PFNGLCOPYCONVOLUTIONFILTER1DPROC            glCopyConvolutionFilter1D;
00315       PFNGLCOPYCONVOLUTIONFILTER2DPROC            glCopyConvolutionFilter2D;
00316       PFNGLGETCONVOLUTIONFILTERPROC               glGetConvolutionFilter;
00317       PFNGLGETCONVOLUTIONPARAMETERFVPROC          glGetConvolutionParameterfv;
00318       PFNGLGETCONVOLUTIONPARAMETERIVPROC          glGetConvolutionParameteriv;
00319       PFNGLGETSEPARABLEFILTERPROC                 glGetSeparableFilter;
00320       PFNGLSEPARABLEFILTER2DPROC                  glSeparableFilter2D;
00321       PFNGLGETHISTOGRAMPROC                       glGetHistogram;
00322       PFNGLGETHISTOGRAMPARAMETERFVPROC            glGetHistogramParameterfv;
00323       PFNGLGETHISTOGRAMPARAMETERIVPROC            glGetHistogramParameteriv;
00324       PFNGLGETMINMAXPROC                          glGetMinmax;
00325       PFNGLGETMINMAXPARAMETERFVPROC               glGetMinmaxParameterfv;
00326       PFNGLGETMINMAXPARAMETERIVPROC               glGetMinmaxParameteriv;
00327       PFNGLHISTOGRAMPROC                          glHistogram;
00328       PFNGLMINMAXPROC                             glMinmax;
00329       PFNGLRESETHISTOGRAMPROC                     glResetHistogram;
00330       PFNGLRESETMINMAXPROC                        glResetMinmax;
00331
00332       //  GL_ARB_shader_objects functions
00333       PFNGLATTACHOBJECTARBPROC                    glAttachObjectARB;
00334       PFNGLCREATEPROGRAMOBJECTARBPROC             glCreateProgramObjectARB;
00335       PFNGLCREATESHADEROBJECTARBPROC              glCreateShaderObjectARB;
00336       PFNGLDELETEOBJECTARBPROC                    glDeleteObjectARB;
00337       PFNGLDETACHOBJECTARBPROC                    glDetachObjectARB;
00338       PFNGLGETATTACHEDOBJECTSARBPROC              glGetAttachedObjectsARB;
00339       PFNGLGETHANDLEARBPROC                       glGetHandleARB;
00340       PFNGLGETINFOLOGARBPROC                      glGetInfoLogARB;
00341       PFNGLGETOBJECTPARAMETERFVARBPROC            glGetObjectParameterfvARB;
00342       PFNGLGETOBJECTPARAMETERIVARBPROC            glGetObjectParameterivARB;
00343       PFNGLUSEPROGRAMOBJECTARBPROC                glUseProgramObjectARB;
00344
00345       //  GL_ARB_vertex_array_set_object functions
00346       PFNGLBINDARRAYSETARBPROC                    glBindArraySetARB;
00347       PFNGLDELETEARRAYSETSARBPROC                 glDeleteArraySetsARB;
00348       PFNGLGENARRAYSETSARBPROC                    glGenArraySetsARB;
00349       PFNGLISARRAYSETARBPROC                      glIsArraySetARB;
00350
00351       //  GL_ARB_vertex_program functions
00352       PFNGLBINDPROGRAMARBPROC                     glBindProgramARB;
00353       PFNGLDELETEPROGRAMSARBPROC                  glDeleteProgramsARB;
00354       PFNGLGENPROGRAMSARBPROC                     glGenProgramsARB;
00355       PFNGLGETPROGRAMENVPARAMETERDVARBPROC        glGetProgramEnvParameterdvARB;
00356       PFNGLGETPROGRAMENVPARAMETERFVARBPROC        glGetProgramEnvParameterfvARB;
00357       PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC      glGetProgramLocalParameterdvARB;
00358       PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC      glGetProgramLocalParameterfvARB;
00359       PFNGLGETPROGRAMSTRINGARBPROC                glGetProgramStringARB;
00360       PFNGLPROGRAMENVPARAMETER4DARBPROC           glProgramEnvParameter4dARB;
00361       PFNGLPROGRAMENVPARAMETER4DVARBPROC          glProgramEnvParameter4dvARB;
00362       PFNGLPROGRAMENVPARAMETER4FARBPROC           glProgramEnvParameter4fARB;
00363       PFNGLPROGRAMENVPARAMETER4FVARBPROC          glProgramEnvParameter4fvARB;
00364       PFNGLPROGRAMLOCALPARAMETER4DARBPROC         glProgramLocalParameter4dARB;
00365       PFNGLPROGRAMLOCALPARAMETER4DVARBPROC        glProgramLocalParameter4dvARB;
00366       PFNGLPROGRAMLOCALPARAMETER4FARBPROC         glProgramLocalParameter4fARB;
00367       PFNGLPROGRAMLOCALPARAMETER4FVARBPROC        glProgramLocalParameter4fvARB;
00368       PFNGLPROGRAMSTRINGARBPROC                   glProgramStringARB;
00369
00370       //  GL_Autodesk_valid_back_buffer_hint functions
00371       PFNGLWINDOWBACKBUFFERHINTAUTODESKPROC       glWindowBackBufferHint;
00372       PFNGLVALIDBACKBUFFERHINTAUTODESKPROC        glValidBackBufferHint;
00373
00374       //  GL_EXT_bindable_uniform functions
00375       PFNGLGETUNIFORMBUFFERSIZEEXTPROC            glGetUniformBufferSize;
00376       PFNGLGETUNIFORMOFFSETEXTPROC                glGetUniformOffset;
00377       PFNGLUNIFORMBUFFEREXTPROC                   glUniformBuffer;
00378
00379       //  GL_EXT_compiled_vertex_array functions
00380       PFNGLLOCKARRAYSEXTPROC                      glLockArrays;
00381       PFNGLUNLOCKARRAYSEXTPROC                    glUnlockArrays;
00382
00383       //  GL_EXT_depth_bounds_test functions
00384       PFNGLDEPTHBOUNDSEXTPROC                     glDepthBounds;
00385
00386       //  GL_EXT_draw_buffers2 functions
00387       PFNGLCOLORMASKINDEXEDEXTPROC                glColorMaskIndexed;
00388       PFNGLDISABLEINDEXEDEXTPROC                  glDisableIndexed;
00389       PFNGLENABLEINDEXEDEXTPROC                   glEnableIndexed;
00390       PFNGLGETBOOLEANINDEXEDVEXTPROC              glGetBooleanIndexedv;
00391       PFNGLGETINTEGERINDEXEDVEXTPROC              glGetIntegerIndexedv;
00392       PFNGLISENABLEDINDEXEDEXTPROC                glIsEnabledIndexed;
00393
00394       //  GL_EXT_draw_instanced functions
00395       PFNGLDRAWARRAYSINSTANCEDEXTPROC             glDrawArraysInstanced;
00396       PFNGLDRAWELEMENTSINSTANCEDEXTPROC           glDrawElementsInstanced;
00397
00398       //  GL_EXT_framebuffer_blit functions
00399       PFNGLBLITFRAMEBUFFEREXTPROC                 glBlitFramebuffer;
00400
00401       //  GL_EXT_framebuffer_multisample functions
00402       PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC      glRenderbufferStorageMultisample;
00403
00404       // GL_EXT_framebuffer_object
00405       PFNGLISRENDERBUFFEREXTPROC                      glIsRenderbuffer;
00406       PFNGLBINDRENDERBUFFEREXTPROC                    glBindRenderbuffer;
00407       PFNGLDELETERENDERBUFFERSEXTPROC                 glDeleteRenderbuffers;
00408       PFNGLGENRENDERBUFFERSEXTPROC                    glGenRenderbuffers;
00409       PFNGLRENDERBUFFERSTORAGEEXTPROC                 glRenderbufferStorage;
00410       PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC          glGetRenderbufferParameteriv;
00411       PFNGLISFRAMEBUFFEREXTPROC                       glIsFramebuffer;
00412       PFNGLBINDFRAMEBUFFEREXTPROC                     glBindFramebuffer;
00413       PFNGLDELETEFRAMEBUFFERSEXTPROC                  glDeleteFramebuffers;
00414       PFNGLGENFRAMEBUFFERSEXTPROC                     glGenFramebuffers;
00415       PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC              glCheckFramebufferStatus;
00416       PFNGLFRAMEBUFFERTEXTURE1DEXTPROC                glFramebufferTexture1D;
00417       PFNGLFRAMEBUFFERTEXTURE2DEXTPROC                glFramebufferTexture2D;
00418       PFNGLFRAMEBUFFERTEXTURE3DEXTPROC                glFramebufferTexture3D;
00419       PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC             glFramebufferRenderbuffer;
00420       PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameteriv;
00421       PFNGLGENERATEMIPMAPEXTPROC                      glGenerateMipmap;
00422
00423       //  GL_EXT_geometry_shader4 functions
00424       PFNGLPROGRAMPARAMETERIEXTPROC               glProgramParameteri;
00425
00426       //  GL_EXT_gpu_program_parameters functions
00427       PFNGLPROGRAMENVPARAMETERS4FVEXTPROC         glProgramEnvParameters4fv;
00428       PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC       glProgramLocalParameters4fv;
00429
00430       //  GL_EXT_gpu_shader4 functions
00431       PFNGLBINDFRAGDATALOCATIONEXTPROC            glBindFragDataLocation;
00432       PFNGLGETFRAGDATALOCATIONEXTPROC             glGetFragDataLocation;
00433       PFNGLGETUNIFORMUIVEXTPROC                   glGetUniformuiv;
00434       PFNGLUNIFORM1UIEXTPROC                      glUniform1ui;
00435       PFNGLUNIFORM1UIVEXTPROC                     glUniform1uiv;
00436       PFNGLUNIFORM2UIEXTPROC                      glUniform2ui;
00437       PFNGLUNIFORM2UIVEXTPROC                     glUniform2uiv;
00438       PFNGLUNIFORM3UIEXTPROC                      glUniform3ui;
00439       PFNGLUNIFORM3UIVEXTPROC                     glUniform3uiv;
00440       PFNGLUNIFORM4UIEXTPROC                      glUniform4ui;
00441       PFNGLUNIFORM4UIVEXTPROC                     glUniform4uiv;
00442
00443       //  GL_EXT_point_parameters functions
00444       PFNGLPOINTPARAMETERFEXTPROC                 glPointParameterfEXT;
00445       PFNGLPOINTPARAMETERFVEXTPROC                glPointParameterfvEXT;
00446
00447       //  GL_EXT_stencil_clear_tag functions
00448       PFNGLSTENCILCLEARTAGEXTPROC                 glStencilClearTag;
00449
00450       //  GL_EXT_stencil_two_side functions
00451       PFNGLACTIVESTENCILFACEEXTPROC               glActiveStencilFaceEXT;
00452
00453       // GL_EXT_texture_array
00454       PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC         glFramebufferTextureLayer;
00455
00456       //  GL_EXT_texture_buffer_object functions
00457       PFNGLTEXBUFFEREXTPROC                       glTexBuffer;
00458
00459       //  GL_EXT_texture_integer functions
00460       PFNGLCLEARCOLORIIEXTPROC                    glClearColorIi;
00461       PFNGLCLEARCOLORIUIEXTPROC                   glClearColorIui;
00462       PFNGLGETTEXPARAMETERIIVEXTPROC              glGetTexParameterIiv;
00463       PFNGLGETTEXPARAMETERIUIVEXTPROC             glGetTexParameterIuiv;
00464       PFNGLTEXPARAMETERIIVEXTPROC                 glTexParameterIiv;
00465       PFNGLTEXPARAMETERIUIVEXTPROC                glTexParameterIuiv;
00466
00467       //  GL_EXT_timer_query
00468       PFNGLGETQUERYOBJECTI64VEXTPROC              glGetQueryObjecti64v;
00469       PFNGLGETQUERYOBJECTUI64VEXTPROC             glGetQueryObjectui64v;
00470
00471       //  GL_EXT_vertex_program4 functions
00472       PFNGLGETVERTEXATTRIBIIVEXTPROC              glGetVertexAttribIiv;
00473       PFNGLGETVERTEXATTRIBIUIVEXTPROC             glGetVertexAttribIuiv;
00474       PFNGLVERTEXATTRIBI1IEXTPROC                 glVertexAttribI1i;
00475       PFNGLVERTEXATTRIBI1IVEXTPROC                glVertexAttribI1iv;
00476       PFNGLVERTEXATTRIBI1UIEXTPROC                glVertexAttribI1ui;
00477       PFNGLVERTEXATTRIBI1UIVEXTPROC               glVertexAttribI1uiv;
00478       PFNGLVERTEXATTRIBI2IEXTPROC                 glVertexAttribI2i;
00479       PFNGLVERTEXATTRIBI2IVEXTPROC                glVertexAttribI2iv;
00480       PFNGLVERTEXATTRIBI2UIEXTPROC                glVertexAttribI2ui;
00481       PFNGLVERTEXATTRIBI2UIVEXTPROC               glVertexAttribI2uiv;
00482       PFNGLVERTEXATTRIBI3IEXTPROC                 glVertexAttribI3i;
00483       PFNGLVERTEXATTRIBI3IVEXTPROC                glVertexAttribI3iv;
00484       PFNGLVERTEXATTRIBI3UIEXTPROC                glVertexAttribI3ui;
00485       PFNGLVERTEXATTRIBI3UIVEXTPROC               glVertexAttribI3uiv;
00486       PFNGLVERTEXATTRIBI4BVEXTPROC                glVertexAttribI4bv;
00487       PFNGLVERTEXATTRIBI4IEXTPROC                 glVertexAttribI4i;
00488       PFNGLVERTEXATTRIBI4IVEXTPROC                glVertexAttribI4iv;
00489       PFNGLVERTEXATTRIBI4SVEXTPROC                glVertexAttribI4sv;
00490       PFNGLVERTEXATTRIBI4UBVEXTPROC               glVertexAttribI4ubv;
00491       PFNGLVERTEXATTRIBI4UIEXTPROC                glVertexAttribI4ui;
00492       PFNGLVERTEXATTRIBI4USVEXTPROC               glVertexAttribI4usv;
00493       PFNGLVERTEXATTRIBI4UIVEXTPROC               glVertexAttribI4uiv;
00494       PFNGLVERTEXATTRIBIPOINTEREXTPROC            glVertexAttribIPointer;
00495
00496       // GL_GREMEDY_string_marker
00497       PFNGLSTRINGMARKERGREMEDYPROC                glStringMarker;
00498
00499       // GL_GREMEDY_frame_terminator
00500       PFNGLFRAMETERMINATORGREMEDYPROC             glFrameTerminator;
00501
00502       //  GL_NV_depth_buffer_float
00503       PFNGLDEPTHRANGEDNVPROC                      glDepthRanged;
00504       PFNGLCLEARDEPTHDNVPROC                      glClearDepthd;
00505       PFNGLDEPTHBOUNDSDNVPROC                     glDepthBoundsd;
00506
00507       //  GL_NV_fence functions
00508       PFNGLDELETEFENCESNVPROC                     glDeleteFences;
00509       PFNGLFINISHFENCENVPROC                      glFinishFence;
00510       PFNGLGENFENCESNVPROC                        glGenFences;
00511       PFNGLGETFENCEIVNVPROC                       glGetFenceiv;
00512       PFNGLISFENCENVPROC                          glIsFence;
00513       PFNGLSETFENCENVPROC                         glSetFence;
00514       PFNGLTESTFENCENVPROC                        glTestFence;
00515
00516       //  GL_NV_fragment_program functions
00517       PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC       glGetProgramNamedParameterdv;
00518       PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC       glGetProgramNamedParameterfv;
00519       PFNGLPROGRAMNAMEDPARAMETER4DNVPROC          glProgramNamedParameter4d;
00520       PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC         glProgramNamedParameter4dv;
00521       PFNGLPROGRAMNAMEDPARAMETER4FNVPROC          glProgramNamedParameter4f;
00522       PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC         glProgramNamedParameter4fv;
00523
00524       //  GL_NV_framebuffer_multisample_coverage functions
00525       PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC glRenderbufferStorageMultisampleCoverage;
00526
00527       //  GL_NV_geometry_program4 functions
00528       PFNGLPROGRAMVERTEXLIMITNVPROC               glProgramVertexLimit;
00529       PFNGLFRAMEBUFFERTEXTUREEXTPROC              glFramebufferTexture;
00530       PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC          glFramebufferTextureFace;
00531
00532       //  GL_NV_gpu_program4 functions
00533       PFNGLGETPROGRAMENVPARAMETERIIVNVPROC        glGetProgramEnvParameterIiv;
00534       PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC       glGetProgramEnvParameterIuiv;
00535       PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC      glGetProgramLocalParameterIiv;
00536       PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC     glGetProgramLocalParameterIuiv;
00537       PFNGLPROGRAMENVPARAMETERSI4IVNVPROC         glProgramEnvParametersI4iv;
00538       PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC        glProgramEnvParametersI4uiv;
00539       PFNGLPROGRAMENVPARAMETERI4INVPROC           glProgramEnvParameterI4i;
00540       PFNGLPROGRAMENVPARAMETERI4IVNVPROC          glProgramEnvParameterI4iv;
00541       PFNGLPROGRAMENVPARAMETERI4UINVPROC          glProgramEnvParameterI4ui;
00542       PFNGLPROGRAMENVPARAMETERI4UIVNVPROC         glProgramEnvParameterI4uiv;
00543       PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC       glProgramLocalParametersI4iv;
00544       PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC      glProgramLocalParametersI4uiv;
00545       PFNGLPROGRAMLOCALPARAMETERI4INVPROC         glProgramLocalParameterI4i;
00546       PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC        glProgramLocalParameterI4iv;
00547       PFNGLPROGRAMLOCALPARAMETERI4UINVPROC        glProgramLocalParameterI4ui;
00548       PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC       glProgramLocalParameterI4uiv;
00549
00550       //  GL_NV_half_float functions
00551       PFNGLCOLOR3HNVPROC                          glColor3h;
00552       PFNGLCOLOR3HVNVPROC                         glColor3hv;
00553       PFNGLCOLOR4HNVPROC                          glColor4h;
00554       PFNGLCOLOR4HVNVPROC                         glColor4hv;
00555       PFNGLFOGCOORDHNVPROC                        glFogCoordh;
00556       PFNGLFOGCOORDHVNVPROC                       glFogCoordhv;
00557       PFNGLMULTITEXCOORD1HNVPROC                  glMultiTexCoord1h;
00558       PFNGLMULTITEXCOORD1HVNVPROC                 glMultiTexCoord1hv;
00559       PFNGLMULTITEXCOORD2HNVPROC                  glMultiTexCoord2h;
00560       PFNGLMULTITEXCOORD2HVNVPROC                 glMultiTexCoord2hv;
00561       PFNGLMULTITEXCOORD3HNVPROC                  glMultiTexCoord3h;
00562       PFNGLMULTITEXCOORD3HVNVPROC                 glMultiTexCoord3hv;
00563       PFNGLMULTITEXCOORD4HNVPROC                  glMultiTexCoord4h;
00564       PFNGLMULTITEXCOORD4HVNVPROC                 glMultiTexCoord4hv;
00565       PFNGLNORMAL3HNVPROC                         glNormal3h;
00566       PFNGLNORMAL3HVNVPROC                        glNormal3hv;
00567       PFNGLSECONDARYCOLOR3HNVPROC                 glSecondaryColor3h;
00568       PFNGLSECONDARYCOLOR3HVNVPROC                glSecondaryColor3hv;
00569       PFNGLTEXCOORD1HNVPROC                       glTexCoord1h;
00570       PFNGLTEXCOORD1HVNVPROC                      glTexCoord1hv;
00571       PFNGLTEXCOORD2HNVPROC                       glTexCoord2h;
00572       PFNGLTEXCOORD2HVNVPROC                      glTexCoord2hv;
00573       PFNGLTEXCOORD3HNVPROC                       glTexCoord3h;
00574       PFNGLTEXCOORD3HVNVPROC                      glTexCoord3hv;
00575       PFNGLTEXCOORD4HNVPROC                       glTexCoord4h;
00576       PFNGLTEXCOORD4HVNVPROC                      glTexCoord4hv;
00577       PFNGLVERTEX2HNVPROC                         glVertex2h;
00578       PFNGLVERTEX2HVNVPROC                        glVertex2hv;
00579       PFNGLVERTEX3HNVPROC                         glVertex3h;
00580       PFNGLVERTEX3HVNVPROC                        glVertex3hv;
00581       PFNGLVERTEX4HNVPROC                         glVertex4h;
00582       PFNGLVERTEX4HVNVPROC                        glVertex4hv;
00583       PFNGLVERTEXATTRIB1HNVPROC                   glVertexAttrib1h;
00584       PFNGLVERTEXATTRIB1HVNVPROC                  glVertexAttrib1hv;
00585       PFNGLVERTEXATTRIB2HNVPROC                   glVertexAttrib2h;
00586       PFNGLVERTEXATTRIB2HVNVPROC                  glVertexAttrib2hv;
00587       PFNGLVERTEXATTRIB3HNVPROC                   glVertexAttrib3h;
00588       PFNGLVERTEXATTRIB3HVNVPROC                  glVertexAttrib3hv;
00589       PFNGLVERTEXATTRIB4HNVPROC                   glVertexAttrib4h;
00590       PFNGLVERTEXATTRIB4HVNVPROC                  glVertexAttrib4hv;
00591       PFNGLVERTEXATTRIBS1HVNVPROC                 glVertexAttribs1hv;
00592       PFNGLVERTEXATTRIBS2HVNVPROC                 glVertexAttribs2hv;
00593       PFNGLVERTEXATTRIBS3HVNVPROC                 glVertexAttribs3hv;
00594       PFNGLVERTEXATTRIBS4HVNVPROC                 glVertexAttribs4hv;
00595
00596       //  GL_NV_occlusion_query functions
00597       PFNGLBEGINOCCLUSIONQUERYNVPROC              glBeginOcclusionQueryNV;
00598       PFNGLDELETEOCCLUSIONQUERIESNVPROC           glDeleteOcclusionQueriesNV;
00599       PFNGLENDOCCLUSIONQUERYNVPROC                glEndOcclusionQueryNV;
00600       PFNGLGENOCCLUSIONQUERIESNVPROC              glGenOcclusionQueriesNV;
00601       PFNGLGETOCCLUSIONQUERYIVNVPROC              glGetOcclusionQueryivNV;
00602       PFNGLGETOCCLUSIONQUERYUIVNVPROC             glGetOcclusionQueryuivNV;
00603       PFNGLISOCCLUSIONQUERYNVPROC                 glIsOcclusionQueryNV;
00604
00605       //  GL_NV_parameter_buffer_object functions
00606       PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC        glProgramBufferParametersfv;
00607       PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC       glProgramBufferParametersIiv;
00608       PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC      glProgramBufferParametersIuiv;
00609
00610       //  GL_NV_pixel_data_range functions
00611       PFNGLFLUSHPIXELDATARANGENVPROC              glFlushPixelDataRange;
00612       PFNGLPIXELDATARANGENVPROC                   glPixelDataRange;
00613
00614       //  GL_NV_primitive_restart functions
00615       PFNGLPRIMITIVERESTARTNVPROC                 glPrimitiveRestart;
00616       PFNGLPRIMITIVERESTARTINDEXNVPROC            glPrimitiveRestartIndex;
00617
00618       //  GL_NV_register_combiners functions
00619       PFNGLCOMBINERPARAMETERFVNVPROC              glCombinerParameterfv;
00620       PFNGLCOMBINERPARAMETERFNVPROC               glCombinerParameterf;
00621       PFNGLCOMBINERPARAMETERIVNVPROC              glCombinerParameteriv;
00622       PFNGLCOMBINERPARAMETERINVPROC               glCombinerParameteri;
00623       PFNGLCOMBINERINPUTNVPROC                    glCombinerInput;
00624       PFNGLCOMBINEROUTPUTNVPROC                   glCombinerOutput;
00625       PFNGLFINALCOMBINERINPUTNVPROC               glFinalCombinerInput;
00626       PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC      glGetCombinerInputParameterfv;
00627       PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC      glGetCombinerInputParameteriv;
00628       PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC     glGetCombinerOutputParameterfv;
00629       PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC     glGetCombinerOutputParameteriv;
00630       PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfv;
00631       PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameteriv;
00632
00633       //  GL_NV_register_combiners2 functions
00634       PFNGLCOMBINERSTAGEPARAMETERFVNVPROC         glCombinerStageParameterfv;
00635       PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC      glGetCombinerStageParameterfv;
00636
00637       //  GL_NV_set_window_stereomode functions
00638       PFNGLSETWINDOWSTEREOMODENVPROC              glSetWindowStereoMode;
00639
00640       //  GL_NV_transform_feedback functions
00641       PFNGLACTIVEVARYINGNVPROC                    glActiveVaryingNV;
00642       PFNGLBEGINTRANSFORMFEEDBACKNVPROC           glBeginTransformFeedbackNV;
00643       PFNGLBINDBUFFERBASENVPROC                   glBindBufferBaseNV;
00644       PFNGLBINDBUFFEROFFSETNVPROC                 glBindBufferOffsetNV;
00645       PFNGLBINDBUFFERRANGENVPROC                  glBindBufferRangeNV;
00646       PFNGLENDTRANSFORMFEEDBACKNVPROC             glEndTransformFeedbackNV;
00647       PFNGLGETACTIVEVARYINGNVPROC                 glGetActiveVaryingNV;
00648       PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC      glGetTransformFeedbackVaryingNV;
00649       PFNGLGETVARYINGLOCATIONNVPROC               glGetVaryingLocationNV;
00650       PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC         glTransformFeedbackAttribsNV;
00651       PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC        glTransformFeedbackVaryingsNV;
00652
00653       //  GL_NV_vertex_array_range functions
00654       PFNGLFLUSHVERTEXARRAYRANGENVPROC            glFlushVertexArrayRange;
00655       PFNGLVERTEXARRAYRANGENVPROC                 glVertexArrayRange;
00656
00657       //  GL_NV_vertex_program functions
00658       PFNGLAREPROGRAMSRESIDENTNVPROC              glAreProgramsResidentNV;
00659       PFNGLBINDPROGRAMNVPROC                      glBindProgramNV;
00660       PFNGLDELETEPROGRAMSNVPROC                   glDeleteProgramsNV;
00661       PFNGLEXECUTEPROGRAMNVPROC                   glExecuteProgramNV;
00662       PFNGLGENPROGRAMSNVPROC                      glGenProgramsNV;
00663       PFNGLGETPROGRAMPARAMETERDVNVPROC            glGetProgramParameterdvNV;
00664       PFNGLGETPROGRAMPARAMETERFVNVPROC            glGetProgramParameterfvNV;
00665       PFNGLGETPROGRAMIVNVPROC                     glGetProgramivNV;
00666       PFNGLGETPROGRAMSTRINGNVPROC                 glGetProgramStringNV;
00667       PFNGLGETTRACKMATRIXIVNVPROC                 glGetTrackMatrixivNV;
00668       PFNGLGETVERTEXATTRIBDVNVPROC                glGetVertexAttribdvNV;
00669       PFNGLGETVERTEXATTRIBFVNVPROC                glGetVertexAttribfvNV;
00670       PFNGLGETVERTEXATTRIBIVNVPROC                glGetVertexAttribivNV;
00671       PFNGLGETVERTEXATTRIBPOINTERVNVPROC          glGetVertexAttribPointervNV;
00672       PFNGLISPROGRAMNVPROC                        glIsProgramNV;
00673       PFNGLLOADPROGRAMNVPROC                      glLoadProgramNV;
00674       PFNGLPROGRAMPARAMETER4DNVPROC               glProgramParameter4dNV;
00675       PFNGLPROGRAMPARAMETER4DVNVPROC              glProgramParameter4dvNV;
00676       PFNGLPROGRAMPARAMETER4FNVPROC               glProgramParameter4fNV;
00677       PFNGLPROGRAMPARAMETER4FVNVPROC              glProgramParameter4fvNV;
00678       PFNGLPROGRAMPARAMETERS4DVNVPROC             glProgramParameters4dvNV;
00679       PFNGLPROGRAMPARAMETERS4FVNVPROC             glProgramParameters4fvNV;
00680       PFNGLREQUESTRESIDENTPROGRAMSNVPROC          glRequestResidentProgramsNV;
00681       PFNGLTRACKMATRIXNVPROC                      glTrackMatrixNV;
00682       PFNGLVERTEXATTRIBPOINTERNVPROC              glVertexAttribPointerNV;
00683       PFNGLVERTEXATTRIB1DNVPROC                   glVertexAttrib1dNV;
00684       PFNGLVERTEXATTRIB1DVNVPROC                  glVertexAttrib1dvNV;
00685       PFNGLVERTEXATTRIB1FNVPROC                   glVertexAttrib1fNV;
00686       PFNGLVERTEXATTRIB1FVNVPROC                  glVertexAttrib1fvNV;
00687       PFNGLVERTEXATTRIB1SNVPROC                   glVertexAttrib1sNV;
00688       PFNGLVERTEXATTRIB1SVNVPROC                  glVertexAttrib1svNV;
00689       PFNGLVERTEXATTRIB2DNVPROC                   glVertexAttrib2dNV;
00690       PFNGLVERTEXATTRIB2DVNVPROC                  glVertexAttrib2dvNV;
00691       PFNGLVERTEXATTRIB2FNVPROC                   glVertexAttrib2fNV;
00692       PFNGLVERTEXATTRIB2FVNVPROC                  glVertexAttrib2fvNV;
00693       PFNGLVERTEXATTRIB2SNVPROC                   glVertexAttrib2sNV;
00694       PFNGLVERTEXATTRIB2SVNVPROC                  glVertexAttrib2svNV;
00695       PFNGLVERTEXATTRIB3DNVPROC                   glVertexAttrib3dNV;
00696       PFNGLVERTEXATTRIB3DVNVPROC                  glVertexAttrib3dvNV;
00697       PFNGLVERTEXATTRIB3FNVPROC                   glVertexAttrib3fNV;
00698       PFNGLVERTEXATTRIB3FVNVPROC                  glVertexAttrib3fvNV;
00699       PFNGLVERTEXATTRIB3SNVPROC                   glVertexAttrib3sNV;
00700       PFNGLVERTEXATTRIB3SVNVPROC                  glVertexAttrib3svNV;
00701       PFNGLVERTEXATTRIB4DNVPROC                   glVertexAttrib4dNV;
00702       PFNGLVERTEXATTRIB4DVNVPROC                  glVertexAttrib4dvNV;
00703       PFNGLVERTEXATTRIB4FNVPROC                   glVertexAttrib4fNV;
00704       PFNGLVERTEXATTRIB4FVNVPROC                  glVertexAttrib4fvNV;
00705       PFNGLVERTEXATTRIB4SNVPROC                   glVertexAttrib4sNV;
00706       PFNGLVERTEXATTRIB4SVNVPROC                  glVertexAttrib4svNV;
00707       PFNGLVERTEXATTRIB4UBNVPROC                  glVertexAttrib4ubNV;
00708       PFNGLVERTEXATTRIB4UBVNVPROC                 glVertexAttrib4ubvNV;
00709       PFNGLVERTEXATTRIBS1DVNVPROC                 glVertexAttribs1dvNV;
00710       PFNGLVERTEXATTRIBS1FVNVPROC                 glVertexAttribs1fvNV;
00711       PFNGLVERTEXATTRIBS1SVNVPROC                 glVertexAttribs1svNV;
00712       PFNGLVERTEXATTRIBS2DVNVPROC                 glVertexAttribs2dvNV;
00713       PFNGLVERTEXATTRIBS2FVNVPROC                 glVertexAttribs2fvNV;
00714       PFNGLVERTEXATTRIBS2SVNVPROC                 glVertexAttribs2svNV;
00715       PFNGLVERTEXATTRIBS3DVNVPROC                 glVertexAttribs3dvNV;
00716       PFNGLVERTEXATTRIBS3FVNVPROC                 glVertexAttribs3fvNV;
00717       PFNGLVERTEXATTRIBS3SVNVPROC                 glVertexAttribs3svNV;
00718       PFNGLVERTEXATTRIBS4DVNVPROC                 glVertexAttribs4dvNV;
00719       PFNGLVERTEXATTRIBS4FVNVPROC                 glVertexAttribs4fvNV;
00720       PFNGLVERTEXATTRIBS4SVNVPROC                 glVertexAttribs4svNV;
00721       PFNGLVERTEXATTRIBS4UBVNVPROC                glVertexAttribs4ubvNV;
00722
00723       // GL_SGIS_multitexture
00724       PFNGLMULTITEXCOORDPOINTERSGISPROC           glMultiTexCoordPointer;
00725
00726       //  GL_WIN_swap_hint functions
00727       PFNGLADDSWAPHINTRECTWINPROC                 glAddSwapHintRectWin;
00728
00729 #endif  //  DOXYGEN_IGNORE
00730
00731     private:
00732       int         m_glVersion;
00733       std::set<std::string> m_available;
00734       std::set<std::string> m_exported;
00735   };
00736
00737   inline  bool  GLFunctions::isAvailable( const std::string& extension ) const
00738   {
00739     return( m_available.find( extension ) != m_available.end() );
00740   }
00741
00742   inline  bool   GLFunctions::isExported( const std::string& extension ) const
00743   {
00744     return( m_exported.find( extension ) != m_exported.end() );
00745   }
00746
00747   inline int GLFunctions::getVersion() const
00748   {
00749     return m_glVersion;
00750   }
00751
00752
00753
00754 #if defined(_WIN32)
00755
00756   class WGLFunctions
00757   {
00758     public:
00760       WGLFunctions( void );
00761
00763       ~WGLFunctions( void );
00764
00770       NVSG_API bool Init(void);
00771
00774       NVSG_API void Reset(void);
00775
00777
00781       NVSG_API bool isAvailable( const std::string& extension
00782                                ) const;
00783
00785
00788       NVSG_API bool isExported( const std::string& extension
00789                               ) const;
00790
00791     public:
00792
00793 //  Don't need to document all these wrapper functions !!!
00794 #if ! defined( DOXYGEN_IGNORE )
00795
00796       //  WGL_ARB_buffer_region functions
00797       PFNWGLCREATEBUFFERREGIONARBPROC             wglCreateBufferRegionARB;
00798       PFNWGLDELETEBUFFERREGIONARBPROC             wglDeleteBufferRegionARB;
00799       PFNWGLRESTOREBUFFERREGIONARBPROC            wglRestoreBufferRegionARB;
00800       PFNWGLSAVEBUFFERREGIONARBPROC               wglSaveBufferRegionARB;
00801
00802       //  WGL_ARB_extensions_string functions
00803       PFNWGLGETEXTENSIONSSTRINGARBPROC            wglGetExtensionsStringARB;
00804
00805       //  WGL_ARB_make_current_read functions
00806       PFNWGLMAKECONTEXTCURRENTARBPROC             wglMakeContextCurrentARB;
00807       PFNWGLGETCURRENTREADDCARBPROC               wglGetCurrentReadDCARB;
00808
00809       //  WGL_ARB_pbuffer functions
00810       PFNWGLCREATEPBUFFERARBPROC                  wglCreatePbufferARB;
00811       PFNWGLDESTROYPBUFFERARBPROC                 wglDestroyPbufferARB;
00812       PFNWGLGETPBUFFERDCARBPROC                   wglGetPbufferDCARB;
00813       PFNWGLQUERYPBUFFERARBPROC                   wglQueryPbufferARB;
00814       PFNWGLRELEASEPBUFFERDCARBPROC               wglReleasePbufferDCARB;
00815
00816       //  WGL_ARB_pixel_format functions
00817       PFNWGLCHOOSEPIXELFORMATARBPROC              wglChoosePixelFormatARB;
00818       PFNWGLGETPIXELFORMATATTRIBIVARBPROC         wglGetPixelFormatAttribivARB;
00819       PFNWGLGETPIXELFORMATATTRIBFVARBPROC         wglGetPixelFormatAttribfvARB;
00820
00821       //  WGL_ARB_render_texture functions
00822       PFNWGLBINDTEXIMAGEARBPROC                   wglBindTexImageARB;
00823       PFNWGLRELEASETEXIMAGEARBPROC                wglReleaseTexImageARB;
00824       PFNWGLSETPBUFFERATTRIBARBPROC               wglSetPbufferAttribARB;
00825
00826       //  WGL_EXT_extensions_string functions
00827       PFNWGLGETEXTENSIONSSTRINGEXTPROC            wglGetExtensionsStringEXT;
00828
00829       //  WGL_EXT_genlock functions
00830       PFNWGLENABLEGENLOCKEXTPROC                  wglEnableGenlockEXT;
00831       PFNWGLDISABLEGENLOCKEXTPROC                 wglDisableGenlockEXT;
00832       PFNWGLGENLOCKSOURCEEXTPROC                  wglGenlockSourceEXT;
00833       PFNWGLGENLOCKSAMPLERATEEXTPROC              wglGenlockSampleRateEXT;
00834       PFNWGLGENLOCKSOURCEDELAYEXTPROC             wglGenlockSourceDelayEXT;
00835       PFNWGLGENLOCKSOURCEEDGEEXTPROC              wglGenlockSourceEdgeEXT;
00836       PFNWGLGETGENLOCKSOURCEEXTPROC               wglGetGenlockSourceEXT;
00837       PFNWGLGETGENLOCKSAMPLERATEEXTPROC           wglGetGenlockSampleRateEXT;
00838       PFNWGLGETGENLOCKSOURCEDELAYEXTPROC          wglGetGenlockSourceDelayEXT;
00839       PFNWGLGETGENLOCKSOURCEEDGEEXTPROC           wglGetGenlockSourceEdgeEXT;
00840       PFNWGLISENABLEDGENLOCKEXTPROC               wglIsEnabledGenlockEXT;
00841       PFNWGLQUERYGENLOCKMAXSOURCEDELAYEXTPROC     wglQueryGenlockMaxSourceDelayEXT;
00842
00843       //  WGL_EXT_swap_control functions
00844       PFNWGLSWAPINTERVALEXTPROC                   wglSwapIntervalEXT;
00845       PFNWGLGETSWAPINTERVALEXTPROC                wglGetSwapIntervalEXT;
00846
00847       //  WGL_EXT_swap_frame_lock functions
00848       PFNWGLENABLEFRAMELOCKEXTPROC                wglEnableFrameLockEXT;
00849       PFNWGLDISABLEFRAMELOCKEXTPROC               wglDisableFrameLockEXT;
00850       PFNWGLISENABLEDFRAMELOCKEXTPROC             wglIsEnabledFrameLockEXT;
00851       PFNWGLQUERYFRAMELOCKMASTEREXTPROC           wglQueryFrameLockMasterEXT;
00852
00853       //  WGL_I3D_genlock functions
00854       PFNWGLENABLEGENLOCKI3DPROC                  wglEnableGenlockI3D;
00855       PFNWGLDISABLEGENLOCKI3DPROC                 wglDisableGenlockI3D;
00856       PFNWGLISENABLEDGENLOCKI3DPROC               wglIsEnabledGenlockI3D;
00857       PFNWGLGENLOCKSOURCEI3DPROC                  wglGenlockSourceI3D;
00858       PFNWGLGETGENLOCKSOURCEI3DPROC               wglGetGenlockSourceI3D;
00859       PFNWGLGENLOCKSOURCEEDGEI3DPROC              wglGenlockSourceEdgeI3D;
00860       PFNWGLGETGENLOCKSOURCEEDGEI3DPROC           wglGetGenlockSourceEdgeI3D;
00861       PFNWGLGENLOCKSAMPLERATEI3DPROC              wglGenlockSampleRateI3D;
00862       PFNWGLGETGENLOCKSAMPLERATEI3DPROC           wglGetGenlockSampleRateI3D;
00863       PFNWGLGENLOCKSOURCEDELAYI3DPROC             wglGenlockSourceDelayI3D;
00864       PFNWGLGETGENLOCKSOURCEDELAYI3DPROC          wglGetGenlockSourceDelayI3D;
00865       PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC     wglQueryGenlockMaxSourceDelayI3D;
00866
00867       //  WGL_KTX_buffer_region functions
00868       PFNWGLNEWBUFFERREGIONPROC                   wglNewBufferRegion;
00869       PFNWGLDELETEBUFFERREGIONPROC                wglDeleteBufferRegion;
00870       PFNWGLREADBUFFERREGIONPROC                  wglReadBufferRegion;
00871       PFNWGLDRAWBUFFERREGIONPROC                  wglDrawBufferRegion;
00872       PFNWGLBUFFERREGIONENABLEDPROC               wglBufferRegionEnabled;
00873
00874       //  WGL_NV_allocate_memory functions
00875       PFNWGLALLOCATEMEMORYNVPROC                  wglAllocateMemoryNV;
00876       PFNWGLFREEMEMORYNVPROC                      wglFreeMemoryNV;
00877
00878       //  WGL_NV_swap_group functions
00879       PFNWGLBINDSWAPBARRIERNVPROC                 wglBindSwapBarrierNV;
00880       PFNWGLJOINSWAPGROUPNVPROC                   wglJoinSwapGroupNV;
00881       PFNWGLQUERYSWAPGROUPNVPROC                  wglQuerySwapGroupNV;
00882       PFNWGLQUERYMAXSWAPGROUPSNVPROC              wglQueryMaxSwapGroupsNV;
00883       PFNWGLQUERYFRAMECOUNTNVPROC                 wglQueryFrameCountNV;
00884       PFNWGLRESETFRAMECOUNTNVPROC                 wglResetFrameCountNV;
00885
00886       // WGL_NV_gpu_affinity
00887       PFNWGLENUMGPUSNVPROC                        wglEnumGpusNV;
00888       PFNWGLENUMGPUDEVICESNVPROC                  wglEnumGpuDevicesNV;
00889       PFNWGLCREATEAFFINITYDCNVPROC                wglCreateAffinityDCNV;
00890       PFNWGLENUMGPUSFROMAFFINITYDCNVPROC          wglEnumGpusFromAffinityDCNV;
00891       PFNWGLDELETEDCNVPROC                        wglDeleteDCNV;
00892
00893       // WGL_NV_video_output
00894       PFNWGLGETVIDEODEVICENVPROC                  wglGetVideoDeviceNV;
00895       PFNWGLRELEASEVIDEODEVICENVPROC              wglReleaseVideoDeviceNV;
00896       PFNWGLBINDVIDEOIMAGENVPROC                  wglBindVideoImageNV;
00897       PFNWGLRELEASEVIDEOIMAGENVPROC               wglReleaseVideoImageNV;
00898       PFNWGLSENDPBUFFERTOVIDEONVPROC              wglSendPbufferToVideoNV;
00899       PFNWGLGETVIDEOINFONVPROC                    wglGetVideoInfoNV;
00900
00901 #endif  //  DOXYGEN_IGNORE
00902
00903     private:
00904       std::set<std::string> m_available;
00905       std::set<std::string> m_exported;
00906       bool                  isInitialized;
00907   };
00908
00909   typedef nvutil::Singleton<WGLFunctions> theWGLFunctions;
00910   // Usage WGLFunctions * pfWGL = theWGLFunctions::instance();
00911
00912   inline  bool  WGLFunctions::isAvailable( const std::string& extension ) const
00913   {
00914     return( m_available.find( extension ) != m_available.end() );
00915   }
00916
00917   inline  bool  WGLFunctions::isExported( const std::string& extension ) const
00918   {
00919     return( m_exported.find( extension ) != m_exported.end() );
00920   }
00921
00922 #endif // _WIN32
00923
00924 #if defined(LINUX)
00925
00926   class GLXFunctions
00927   {
00928     public:
00930       GLXFunctions( void );
00931
00933       ~GLXFunctions( void );
00934
00940       NVSG_API bool Init(Display * display);
00941
00944       NVSG_API void Reset(void);
00945
00947
00951       NVSG_API bool isAvailable( const std::string& extension
00952                                ) const;
00953
00955
00958       NVSG_API bool isExported( const std::string& extension
00959                               ) const;
00960
00961     public:
00962
00963 //  Don't need to document all these wrapper functions !!!
00964 #if ! defined( DOXYGEN_IGNORE )
00965
00966   // GLX Version 1.3 - REQUIRED
00967   // GLX_SGI_make_current_read - rolled into 1.3
00968   // GLX_EXT_import_context - rolled into 1.3
00969   // GLX_SGIX_fbconfig - rolled into glx 1.3
00970   // GLX_SGIX_pbuffer - rolled into glx 1.3
00971   // no need to export these extensions
00972
00973   // GLX_ARB_get_proc_address - our code already assumes this is present
00974   // GLX Version 1.4 - added glXGetProcAddress - not exposed here
00975
00976   // GLX_SGI_swap_control
00977   PFNGLXSWAPINTERVALSGIPROC         glXSwapIntervalSGI;
00978
00979   // GLX_SGI_video_sync
00980   PFNGLXGETVIDEOSYNCSGIPROC         glXGetVideoSyncSGI;
00981   PFNGLXWAITVIDEOSYNCSGIPROC        glXWaitVideoSyncSGI;
00982
00983   // GLX_NV_swap_group
00984   PFNGLXJOINSWAPGROUPNVPROC         glXJoinSwapGroupNV;
00985   PFNGLXBINDSWAPBARRIERNVPROC       glXBindSwapBarrierNV;
00986   PFNGLXQUERYSWAPGROUPNVPROC        glXQuerySwapGroupNV;
00987   PFNGLXQUERYMAXSWAPGROUPSNVPROC    glXQueryMaxSwapGroupsNV;
00988   PFNGLXQUERYFRAMECOUNTNVPROC       glXQueryFrameCountNV;
00989   PFNGLXRESETFRAMECOUNTNVPROC       glXResetFrameCountNV;
00990
00991   // GLX_NV_video_out
00992   PFNGLXGETVIDEODEVICENVPROC        glXGetVideoDeviceNV;
00993   PFNGLXRELEASEVIDEODEVICENVPROC    glXReleaseVideoDeviceNV;
00994   PFNGLXBINDVIDEOIMAGENVPROC        glXBindVideoImageNV;
00995   PFNGLXRELEASEVIDEOIMAGENVPROC     glXReleaseVideoImageNV;
00996   PFNGLXSENDPBUFFERTOVIDEONVPROC    glXSendPbufferToVideoNV;
00997   PFNGLXGETVIDEOINFONVPROC          glXGetVideoInfoNV;
00998
00999   //  GLX_EXT_texture_from_pixmap
01000   PFNGLXBINDTEXIMAGEEXTPROC         glXBindTexImageEXT;
01001   PFNGLXRELEASETEXIMAGEEXTPROC      glXReleaseTexImageEXT;
01002
01003 #endif  //  DOXYGEN_IGNORE
01004
01005     private:
01006       std::set<std::string> m_available;
01007       std::set<std::string> m_exported;
01008       bool                  isInitialized;
01009   };
01010
01011   typedef nvutil::Singleton<GLXFunctions> theGLXFunctions;
01012   // Usage GLXFunctions * pfGLX = theGLXFunctions::instance();
01013
01014   inline  bool  GLXFunctions::isAvailable( const std::string& extension ) const
01015   {
01016     return( m_available.find( extension ) != m_available.end() );
01017   }
01018
01019   inline  bool  GLXFunctions::isExported( const std::string& extension ) const
01020   {
01021     return( m_exported.find( extension ) != m_exported.end() );
01022   }
01023
01024 #endif // LINUX
01025
01026
01027 } // namespace nvgl
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLMFCRAWnd.h File Reference

#include "nvui/GLWinRenderArea.h"

Include dependency graph for GLMFCRAWnd.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:27:42 2008 for NVSGSDK by NVIDIA


GLMFCRAWnd.h Source File

GLMFCRAWnd.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013 #ifdef _WIN32
00014 #include "nvui/GLWinRenderArea.h"
00015
00018 //  Don't need to document the API specifier
00019 #if ! defined( DOXYGEN_IGNORE )
00020 #ifdef RAMFC_EXPORTS
00021 # define RAMFC_API __declspec(dllexport)
00022 #else
00023 # define RAMFC_API __declspec(dllimport)
00024 #endif
00025 #endif  //  DOXYGEN_IGNORE
00026
00027
00028 namespace nvui
00029 {
00031
00034   class RAMFC_API GLMFCRAWnd :  public CWnd, public GLWinRenderArea
00035   {
00036     public:
00039       virtual ~GLMFCRAWnd(void);
00040
00048       virtual bool init(RenderArea * shareArea = NULL);
00049
00050       afx_msg BOOL  OnEraseBkgnd( CDC* pDC );
00051       afx_msg void  OnPaint( void );
00052
00058       virtual void setViewportSize(unsigned int x, unsigned int y);
00059
00063       virtual void destroy();
00064
00068       virtual void triggerRedraw();
00069
00070     protected:
00074       virtual BOOL PreCreateWindow( CREATESTRUCT& cs );
00075
00076       DECLARE_MESSAGE_MAP()
00077   };
00078
00079 } //  namespace nvui
00080
00081
00082 #endif //_WIN32
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLObjects.h File Reference

#include "nvsgcommon.h"
#include <set>
#include "nvgl/nvgl.h"
#include "nvutil/RCObject.h"

Include dependency graph for GLObjects.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvgl

Detailed Description

Generated on Tue Jan 15 10:27:43 2008 for NVSGSDK by NVIDIA


GLObjects.h Source File

GLObjects.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include <set>
00018 #include "nvgl/nvgl.h"
00019 #include "nvutil/RCObject.h"
00020
00021
00022 namespace nvgl
00023 {
00024   class GLDALDataCreator;
00025
00027
00030   class GLObjects
00031   {
00032     friend class GLContext;
00033
00034   public:
00036       GLObjects();
00038       ~GLObjects();
00039
00040   private:
00041     // Collection of shareable objects
00042     struct GLShareables : public nvutil::RCObject
00043     {
00044       GLShareables();
00045       ~GLShareables(); // for cleanup purposes
00046       void exit(); // cleanup
00047
00048       NameSet m_buffers;
00049       NameSet m_lists;
00050       NameSet m_programs;
00051       NameSet m_textures;
00052
00053       GLDALDataCreator * m_DALDataCreator;
00054     };
00055
00056     // shareable objects
00057     GLShareables * m_shareables;
00058     // non-shareable objects
00059     NameSet m_occlusionQueries;
00060     NameSet m_queries;
00061   };
00062 } //  namespace nvgl
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLStatistics.h File Reference

#include "nvsgcommon.h"

Include dependency graph for GLStatistics.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Detailed Description

Generated on Tue Jan 15 10:27:43 2008 for NVSGSDK by NVIDIA


GLStatistics.h Source File

GLStatistics.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #if ! defined( DOXYGEN_IGNORE )   // no need to document this
00018 //#if !defined(NDEBUG)
00019 //# define GL_STATISTICS
00020 //#endif
00021
00022 #if defined( GL_STATISTICS )
00023
00024 #include "nvgl/nvgl.h"
00025 #include "nvmath/Mat44f.h"
00026 #include "nvmath/Vecnt.h"
00027 #include <stack>
00028
00029 # define  NVSG_GL_STATS_FCT_COUNT()                                      glContext()->m_glStats->m_fctCount[__FUNCTION__]++
00030 # define  NVSG_GL_STATS_ACTIVE_TEXTURE( texture )                        glContext()->m_glStats->activeTexture( __FUNCTION__, texture )
00031 # define  NVSG_GL_STATS_BIND_BUFFER( target, id )                        glContext()->m_glStats->bindBuffer( __FUNCTION__, target, id )
00032 # define  NVSG_GL_STATS_BIND_TEXTURE( target, texture )                  glContext()->m_glStats->bindTexture( __FUNCTION__, target, texture )
00033 # define  NVSG_GL_STATS_BLEND_FUNC( sfactor, dfactor )                   glContext()->m_glStats->blendFunc( __FUNCTION__, sfactor, dfactor )
00034 # define  NVSG_GL_STATS_BUFFER_DATA( target, size, data, usage )         glContext()->m_glStats->bufferData( __FUNCTION__, target, size, data, usage )
00035 # define  NVSG_GL_STATS_CALL_LIST( list )                                glContext()->m_glStats->callList( __FUNCTION__, list )
00036 # define  NVSG_GL_STATS_CLEAR( mask )                                    glContext()->m_glStats->clear( __FUNCTION__, mask )
00037 # define  NVSG_GL_STATS_CLEAR_COLOR( red, green, blue, alpha )           glContext()->m_glStats->clearColor( __FUNCTION__, red, green, blue, alpha );
00038 # define  NVSG_GL_STATS_CLIENT_ACTIVE_TEXTURE( texture )                 glContext()->m_glStats->clientActiveTexture( __FUNCTION__, texture )
00039 # define  NVSG_GL_STATS_CLIENT_STATE( array, on )                        glContext()->m_glStats->clientState( __FUNCTION__, array, on )
00040 # define  NVSG_GL_STATS_COLOR3B( red, green, blue )                      glContext()->m_glStats->color3b( __FUNCTION__, red, green, blue )
00041 # define  NVSG_GL_STATS_COLOR3BV( v )                                    glContext()->m_glStats->color3bv( __FUNCTION__, v )
00042 # define  NVSG_GL_STATS_COLOR3D( red, green, blue )                      glContext()->m_glStats->color3d( __FUNCTION__, red, green, blue )
00043 # define  NVSG_GL_STATS_COLOR3DV( v )                                    glContext()->m_glStats->color3dv( __FUNCTION__, v )
00044 # define  NVSG_GL_STATS_COLOR3F( red, green, blue )                      glContext()->m_glStats->color3f( __FUNCTION__, red, green, blue )
00045 # define  NVSG_GL_STATS_COLOR3FV( v )                                    glContext()->m_glStats->color3fv( __FUNCTION__, v )
00046 # define  NVSG_GL_STATS_COLOR3I( red, green, blue )                      glContext()->m_glStats->color3i( __FUNCTION__, red, green, blue )
00047 # define  NVSG_GL_STATS_COLOR3IV( v )                                    glContext()->m_glStats->color3iv( __FUNCTION__, v )
00048 # define  NVSG_GL_STATS_COLOR3S( red, green, blue )                      glContext()->m_glStats->color3s( __FUNCTION__, red, green, blue )
00049 # define  NVSG_GL_STATS_COLOR3SV( v )                                    glContext()->m_glStats->color3sv( __FUNCTION__, v )
00050 # define  NVSG_GL_STATS_COLOR3UB( red, green, blue )                     glContext()->m_glStats->color3ub( __FUNCTION__, red, green, blue )
00051 # define  NVSG_GL_STATS_COLOR3UBV( v )                                   glContext()->m_glStats->color3ubv( __FUNCTION__, v )
00052 # define  NVSG_GL_STATS_COLOR3UI( red, green, blue )                     glContext()->m_glStats->color3ui( __FUNCTION__, red, green, blue )
00053 # define  NVSG_GL_STATS_COLOR3UIV( v )                                   glContext()->m_glStats->color3uiv( __FUNCTION__, v )
00054 # define  NVSG_GL_STATS_COLOR3US( red, green, blue )                     glContext()->m_glStats->color3us( __FUNCTION__, red, green, blue )
00055 # define  NVSG_GL_STATS_COLOR3USV( v )                                   glContext()->m_glStats->color3usv( __FUNCTION__, v )
00056 # define  NVSG_GL_STATS_COLOR4B( red, green, blue, alpha )               glContext()->m_glStats->color4b( __FUNCTION__, red, green, blue, alpha )
00057 # define  NVSG_GL_STATS_COLOR4BV( v )                                    glContext()->m_glStats->color4bv( __FUNCTION__, v )
00058 # define  NVSG_GL_STATS_COLOR4D( red, green, blue, alpha )               glContext()->m_glStats->color4d( __FUNCTION__, red, green, blue, alpha )
00059 # define  NVSG_GL_STATS_COLOR4DV( v )                                    glContext()->m_glStats->color4dv( __FUNCTION__, v )
00060 # define  NVSG_GL_STATS_COLOR4F( red, green, blue, alpha )               glContext()->m_glStats->color4f( __FUNCTION__, red, green, blue, alpha )
00061 # define  NVSG_GL_STATS_COLOR4FV( v )                                    glContext()->m_glStats->color4fv( __FUNCTION__, v )
00062 # define  NVSG_GL_STATS_COLOR4I( red, green, blue, alpha )               glContext()->m_glStats->color4i( __FUNCTION__, red, green, blue, alpha )
00063 # define  NVSG_GL_STATS_COLOR4IV( v )                                    glContext()->m_glStats->color4iv( __FUNCTION__, v )
00064 # define  NVSG_GL_STATS_COLOR4S( red, green, blue, alpha )               glContext()->m_glStats->color4s( __FUNCTION__, red, green, blue, alpha )
00065 # define  NVSG_GL_STATS_COLOR4SV( v )                                    glContext()->m_glStats->color4sv( __FUNCTION__, v )
00066 # define  NVSG_GL_STATS_COLOR4UB( red, green, blue, alpha )              glContext()->m_glStats->color4ub( __FUNCTION__, red, green, blue, alpha )
00067 # define  NVSG_GL_STATS_COLOR4UBV( v )                                   glContext()->m_glStats->color4ubv( __FUNCTION__, v )
00068 # define  NVSG_GL_STATS_COLOR4UI( red, green, blue, alpha )              glContext()->m_glStats->color4ui( __FUNCTION__, red, green, blue, alpha )
00069 # define  NVSG_GL_STATS_COLOR4UIV( v )                                   glContext()->m_glStats->color4uiv( __FUNCTION__, v )
00070 # define  NVSG_GL_STATS_COLOR4US( red, green, blue, alpha )              glContext()->m_glStats->color4us( __FUNCTION__, red, green, blue, alpha )
00071 # define  NVSG_GL_STATS_COLOR4USV( v )                                   glContext()->m_glStats->color4usv( __FUNCTION__, v )
00072 # define  NVSG_GL_STATS_DELETE_BUFFERS( n, buffers )                     glContext()->m_glStats->deleteBuffers( __FUNCTION__, n, buffers )
00073 # define  NVSG_GL_STATS_DELETE_LISTS( list, range )                      glContext()->m_glStats->deleteLists( __FUNCTION__, list, range )
00074 # define  NVSG_GL_STATS_DELETE_TEXTURES( n, textures )                   glContext()->m_glStats->deleteTextures( __FUNCTION__, n, textures )
00075 # define  NVSG_GL_STATS_DEPTH_FUNC( func )                               glContext()->m_glStats->depthFunc( __FUNCTION__, func )
00076 # define  NVSG_GL_STATS_DEPTH_MASK( flag )                               glContext()->m_glStats->depthMask( __FUNCTION__, flag )
00077 # define  NVSG_GL_STATS_DRAW_ELEMENTS( mode, count, type, indices )      glContext()->m_glStats->drawElements( __FUNCTION__, mode, count, type, indices )
00078 # define  NVSG_GL_STATS_DRAW_RANGE_ELEMENTS( mode, start, end, count, type, indices )  \
00079                                                                          glContext()->m_glStats->drawRangeElements( __FUNCTION__, mode, start, end, count, type, indices )
00080 # define  NVSG_GL_STATS_END_LIST()                                       glContext()->m_glStats->endList( __FUNCTION__ );
00081 # define  NVSG_GL_STATS_FRUSTUM( left, right, bottom, top, zNear, zFar ) glContext()->m_glStats->frustum( __FUNCTION__, left, right, bottom, top, zNear, zFar )
00082 # define  NVSG_GL_STATS_GEN_BUFFERS( n, buffers )                        glContext()->m_glStats->genBuffers( __FUNCTION__, n, buffers )
00083 # define  NVSG_GL_STATS_GEN_LISTS( range )                               glContext()->m_glStats->genLists( __FUNCTION__, range )
00084 # define  NVSG_GL_STATS_GEN_TEXTURES( n, textures )                      glContext()->m_glStats->genTextures( __FUNCTION__, n, textures )
00085 # define  NVSG_GL_STATS_GET_INTEGERV( pname, params )                    glContext()->m_glStats->getIntegerv( __FUNCTION__, pname, params )
00086 # define  NVSG_GL_STATS_IS_TEXTURE( texture )                            glContext()->m_glStats->isTexture( __FUNCTION__, texture )
00087 # define  NVSG_GL_STATS_LIGHTF( light, pname, param )                    glContext()->m_glStats->lightf( __FUNCTION__, light, pname, param )
00088 # define  NVSG_GL_STATS_LIGHTFV( light, pname, params )                  glContext()->m_glStats->lightfv( __FUNCTION__, light, pname, params )
00089 # define  NVSG_GL_STATS_LIGHTI( light, pname, param )                    glContext()->m_glStats->lighti( __FUNCTION__, light, pname, param )
00090 # define  NVSG_GL_STATS_LIGHTIV( light, pname, params )                  glContext()->m_glStats->lightiv( __FUNCTION__, light, pname, params )
00091 # define  NVSG_GL_STATS_LIGHT_MODELF( pname, param )                     glContext()->m_glStats->lightModelf( __FUNCTION__, pname, param )
00092 # define  NVSG_GL_STATS_LIGHT_MODELFV( pname, params )                   glContext()->m_glStats->lightModelfv( __FUNCTION__, pname, params )
00093 # define  NVSG_GL_STATS_LIGHT_MODELI( pname, param )                     glContext()->m_glStats->lightModeli( __FUNCTION__, pname, param )
00094 # define  NVSG_GL_STATS_LIGHT_MODELIV( pname, params )                   glContext()->m_glStats->lightModeliv( __FUNCTION__, pname, params )
00095 # define  NVSG_GL_STATS_LINE_WIDTH( width )                              glContext()->m_glStats->lineWidth( __FUNCTION__, width )
00096 # define  NVSG_GL_STATS_LOAD_IDENTITY()                                  glContext()->m_glStats->loadIdentity( __FUNCTION__ )
00097 # define  NVSG_GL_STATS_LOAD_MATRIXD( m )                                glContext()->m_glStats->loadMatrixd( __FUNCTION__, m )
00098 # define  NVSG_GL_STATS_LOAD_MATRIXF( m )                                glContext()->m_glStats->loadMatrixf( __FUNCTION__, m )
00099 # define  NVSG_GL_STATS_MATERIALF( face, pname, param )                  glContext()->m_glStats->materialf( __FUNCTION__, face, pname, param )
00100 # define  NVSG_GL_STATS_MATERIALFV( face, pname, params )                glContext()->m_glStats->materialfv( __FUNCTION__, face, pname, params )
00101 # define  NVSG_GL_STATS_MATERIALI( face, pname, param )                  glContext()->m_glStats->materiali( __FUNCTION__, face, pname, param )
00102 # define  NVSG_GL_STATS_MATERIALIV( face, pname, params )                glContext()->m_glStats->materialiv( __FUNCTION__, face, pname, params )
00103 # define  NVSG_GL_STATS_MATRIX_MODE( mode )                              glContext()->m_glStats->matrixMode( __FUNCTION__, mode )
00104 # define  NVSG_GL_STATS_MULT_MATRIXD( m )                                glContext()->m_glStats->multMatrixd( __FUNCTION__, m )
00105 # define  NVSG_GL_STATS_MULT_MATRIXF( m )                                glContext()->m_glStats->multMatrixf( __FUNCTION__, m )
00106 # define  NVSG_GL_STATS_NEW_LIST( list, mode )                           glContext()->m_glStats->newList( __FUNCTION__, list, mode )
00107 # define  NVSG_GL_STATS_NORMAL_POINTER( type, stride, pointer )          glContext()->m_glStats->normalPointer( __FUNCTION__, type, stride, pointer )
00108 # define  NVSG_GL_STATS_ORTHO( left, right, bottom, top, zNear, zFar )   glContext()->m_glStats->ortho( __FUNCTION__, left, right, bottom, top, zNear, zFar )
00109 # define  NVSG_GL_STATS_POINT_SIZE( size )                               glContext()->m_glStats->pointSize( __FUNCTION__, size )
00110 # define  NVSG_GL_STATS_POLYGON_MODE( face, mode )                       glContext()->m_glStats->polygonMode( __FUNCTION__, face, mode )
00111 # define  NVSG_GL_STATS_POLYGON_OFFSET( factor, units )                  glContext()->m_glStats->polygonOffset( __FUNCTION__, factor, units )
00112 # define  NVSG_GL_STATS_POP_ATTRIB()                                     glContext()->m_glStats->popAttrib( __FUNCTION__ )
00113 # define  NVSG_GL_STATS_POP_MATRIX()                                     glContext()->m_glStats->popMatrix( __FUNCTION__ )
00114 # define  NVSG_GL_STATS_PRIMITIVE_RESTART_INDEX( index )                 glContext()->m_glStats->primitiveRestartIndex( __FUNCTION__, index )
00115 # define  NVSG_GL_STATS_PUSH_ATTRIB( mask )                              glContext()->m_glStats->pushAttrib( __FUNCTION__, mask )
00116 # define  NVSG_GL_STATS_PUSH_MATRIX()                                    glContext()->m_glStats->pushMatrix( __FUNCTION__ )
00117 # define  NVSG_GL_STATS_ROTATED( angle, x, y, z )                        glContext()->m_glStats->rotated( __FUNCTION__, angle, x, y, z )
00118 # define  NVSG_GL_STATS_ROTATEF( angle, x, y, z )                        glContext()->m_glStats->rotatef( __FUNCTION__, angle, x, y, z )
00119 # define  NVSG_GL_STATS_SCALED( x, y, z )                                glContext()->m_glStats->scaled( __FUNCTION__, x, y, z )
00120 # define  NVSG_GL_STATS_SCALEF( x, y, z )                                glContext()->m_glStats->scalef( __FUNCTION__, x, y, z )
00121 # define  NVSG_GL_STATS_STATE( cap, on )                                 glContext()->m_glStats->state( __FUNCTION__, cap, on )
00122 # define  NVSG_GL_STATS_TEX_COORD_POINTER( size, type, stride, pointer ) glContext()->m_glStats->texCoordPointer( __FUNCTION__, size, type, stride, pointer )
00123 # define  NVSG_GL_STATS_TEX_ENVF( target, pname, param )                 glContext()->m_glStats->texEnvf( __FUNCTION__, target, pname, param )
00124 # define  NVSG_GL_STATS_TEX_ENVFV( target, pname, params )               glContext()->m_glStats->texEnvfv( __FUNCTION__, target, pname, params )
00125 # define  NVSG_GL_STATS_TEX_ENVI( target, pname, param )                 glContext()->m_glStats->texEnvi( __FUNCTION__, target, pname, param )
00126 # define  NVSG_GL_STATS_TEX_ENVIV( target, pname, params )               glContext()->m_glStats->texEnviv( __FUNCTION__, target, pname, params )
00127 # define  NVSG_GL_STATS_TEX_IMAGE2D( target, level, internalformat, width, height, border, format, type, pixels )  \
00128                                                                          glContext()->m_glStats->texImage2d( __FUNCTION__, target, level, internalformat, width, height, border, format, type, pixel
00129 s )
00130 # define  NVSG_GL_STATS_TEX_PARAMETERF( target, pname, param )           glContext()->m_glStats->texParameterf( __FUNCTION__, target, pname, param )
00131 # define  NVSG_GL_STATS_TEX_PARAMETERFV( target, pname, params )         glContext()->m_glStats->texParameterfv( __FUNCTION__, target, pname, params )
00132 # define  NVSG_GL_STATS_TEX_PARAMETERI( target, pname, param )           glContext()->m_glStats->texParameteri( __FUNCTION__, target, pname, param )
00133 # define  NVSG_GL_STATS_TEX_PARAMETERIV( target, pname, params )         glContext()->m_glStats->texParameteriv( __FUNCTION__, target, pname, params )
00134 # define  NVSG_GL_STATS_TRANSLATED( x, y, z )                            glContext()->m_glStats->translated( __FUNCTION__, x, y, z )
00135 # define  NVSG_GL_STATS_TRANSLATEF( x, y, z )                            glContext()->m_glStats->translatef( __FUNCTION__, x, y, z )
00136 # define  NVSG_GL_STATS_VERTEX_POINTER( size, type, stride, pointer )    glContext()->m_glStats->vertexPointer( __FUNCTION__, size, type, stride, pointer )
00137 # define  NVSG_GL_STATS_VIEWPORT( x, y, width, height )                  glContext()->m_glStats->viewport( __FUNCTION__, x, y, width, height )
00138
00139
00140 class GLStatsEnable
00141 {
00142 public:
00143   GLStatsEnable( void )
00144     : enableState(false)
00145     , enableCalls(0)
00146     , disableCalls(0)
00147     , redundantEnables(0)
00148     , redundantDisables(0)
00149   {
00150   }
00151
00152 public:
00153   bool    enableState;
00154   size_t  enableCalls;
00155   size_t  disableCalls;
00156   size_t  redundantEnables;
00157   size_t  redundantDisables;
00158 };
00159
00160 class GLStatsCount
00161 {
00162 public:
00163   GLStatsCount( void )
00164     : calls(0)
00165     , redundantCalls(0)
00166   {
00167   }
00168
00169 public:
00170   size_t  calls;
00171   size_t  redundantCalls;
00172 };
00173
00174 class GLStatsFloat : public GLStatsCount
00175 {
00176 public:
00177   GLStatsFloat( void )
00178     : value(-1.0f)
00179   {
00180   }
00181
00182 public:
00183   float   value;
00184 };
00185
00186 class GLStatsVec3f : public GLStatsCount
00187 {
00188 public:
00189   GLStatsVec3f( void )
00190     : value( -1.0f, -1.0f, -1.0f )
00191   {
00192   }
00193
00194 public:
00195   nvmath::Vec3f value;
00196 };
00197
00198 class GLStatsVec4f : public GLStatsCount
00199 {
00200 public:
00201   GLStatsVec4f( void )
00202     : value( -1.0f, -1.0f, -1.0f, -1.0f )
00203   {
00204   }
00205
00206 public:
00207   nvmath::Vec4f value;
00208 };
00209
00210 class GLStatistics
00211 {
00212 public:
00213   GLStatistics( void );
00214
00215   void  dump( void );
00216   void  dumpHistogram( FILE *fh, const std::map<size_t,size_t> &hist, char *prefix );
00217   void  activeTexture( const char *fctName, GLenum texture );
00218   void  bindBuffer( const char *fctName, GLenum target, GLuint id );
00219   void  bindTexture( const char *fctName, GLenum target, GLuint texture );
00220   void  blendFunc( const char *fctName, GLenum sfactor, GLenum dfactor );
00221   void  bufferData( const char *fctName, GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage );
00222   void  callList( const char *fctName, GLuint list );
00223   void  clear( const char *fctName, GLbitfield mask );
00224   void  clearColor( const char *fctName, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
00225   void  clientActiveTexture( const char *fctName, GLenum texture );
00226   void  clientState( const char *fctName, GLenum array, bool enable );
00227   void  color3b( const char *fctName, GLbyte red, GLbyte green, GLbyte blue );
00228   void  color3bv( const char *fctName, const GLbyte *v );
00229   void  color3d( const char *fctName, GLdouble red, GLdouble green, GLdouble blue );
00230   void  color3dv( const char *fctName, const GLdouble *v );
00231   void  color3f( const char *fctName, GLfloat red, GLfloat green, GLfloat blue );
00232   void  color3fv( const char *fctName, const GLfloat *v );
00233   void  color3i( const char *fctName, GLint red, GLint green, GLint blue );
00234   void  color3iv( const char *fctName, const GLint *v );
00235   void  color3s( const char *fctName, GLshort red, GLshort green, GLshort blue );
00236   void  color3sv( const char *fctName, const GLshort *v );
00237   void  color3ub( const char *fctName, GLubyte red, GLubyte green, GLubyte blue );
00238   void  color3ubv( const char *fctName, const GLubyte *v );
00239   void  color3ui( const char *fctName, GLuint red, GLuint green, GLuint blue );
00240   void  color3uiv( const char *fctName, const GLuint *v );
00241   void  color3us( const char *fctName, GLushort red, GLushort green, GLushort blue );
00242   void  color3usv( const char *fctName, const GLushort *v );
00243   void  color4b( const char *fctName, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha );
00244   void  color4bv( const char *fctName, const GLbyte *v );
00245   void  color4d( const char *fctName, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha );
00246   void  color4dv( const char *fctName, const GLdouble *v );
00247   void  color4f( const char *fctName, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
00248   void  color4fv( const char *fctName, const GLfloat *v );
00249   void  color4i( const char *fctName, GLint red, GLint green, GLint blue, GLint alpha );
00250   void  color4iv( const char *fctName, const GLint *v );
00251   void  color4s( const char *fctName, GLshort red, GLshort green, GLshort blue, GLshort alpha );
00252   void  color4sv( const char *fctName, const GLshort *v );
00253   void  color4ub( const char *fctName, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
00254   void  color4ubv( const char *fctName, const GLubyte *v );
00255   void  color4ui( const char *fctName, GLuint red, GLuint green, GLuint blue, GLuint alpha );
00256   void  color4uiv( const char *fctName, const GLuint *v );
00257   void  color4us( const char *fctName, GLushort red, GLushort green, GLushort blue, GLushort alpha );
00258   void  color4usv( const char *fctName, const GLushort *v );
00259   void  deleteBuffers( const char *fctName, GLsizei n, const GLuint *buffers );
00260   void  deleteLists( const char *fctName, GLuint list, GLsizei range );
00261   void  deleteTextures( const char *fctName, GLsizei n, const GLuint *textures );
00262   void  depthFunc( const char *fctName, GLenum func );
00263   void  depthMask( const char *fctName, GLboolean flag );
00264   void  drawElements( const char *fctName, GLenum mode, GLsizei count, GLenum type, const GLvoid *indices );
00265   void  drawRangeElements( const char *fctName, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
00266   void  endList( const char *fctName );
00267   void  frustum( const char *fctName, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
00268   void  initLightDefault( GLenum light, GLenum pname );
00269   void  initLightModelDefault( GLenum pname );
00270   void  initMaterialDefault( GLenum face, GLenum pname );
00271   void  initMatrixDefault( void );
00272   void  initPolygonMode( GLenum face );
00273   void  initStateDefault( GLenum cap );
00274   void  initTexEnv( GLenum target, GLenum pname );
00275   void  initTexParameter( GLenum target, GLenum pname );
00276   void  genBuffers( const char *fctName, GLsizei n, GLuint *buffers );
00277   void  genLists( const char *fctName, GLsizei range );
00278   void  genTextures( const char *fctName, GLsizei n, GLuint *textures );
00279   void  getIntegerv( const char *fctName, GLenum pname, GLint *params );
00280   void  isTexture( const char *fctName, GLuint texture );
00281   void  lightf( const char *fctName, GLenum light, GLenum pname, GLfloat param );
00282   void  lightfv( const char *fctName, GLenum light, GLenum pname, const GLfloat *params );
00283   void  lighti( const char *fctName, GLenum light, GLenum pname, GLint param );
00284   void  lightiv( const char *fctName, GLenum light, GLenum pname, const GLint *params );
00285   void  lightModelf( const char *fctName, GLenum pname, GLfloat param );
00286   void  lightModelfv( const char *fctName, GLenum pname, const GLfloat *params );
00287   void  lightModeli( const char *fctName, GLenum pname, GLint param );
00288   void  lightModeliv( const char *fctName, GLenum pname, const GLint *params );
00289   void  lineWidth( const char *fctName, GLfloat width );
00290   void  loadIdentity( const char *fctName );
00291   void  loadMatrixd( const char *fctName, const GLdouble *m );
00292   void  loadMatrixf( const char *fctName, const GLfloat *m );
00293   void  materialf( const char *fctName, GLenum face, GLenum pname, GLfloat param );
00294   void  materialfv( const char *fctName, GLenum face, GLenum pname, const GLfloat *params );
00295   void  materiali( const char *fctName, GLenum face, GLenum pname, GLint param );
00296   void  materialiv( const char *fctName, GLenum face, GLenum pname, const GLint *params );
00297   void  matrixMode( const char *fctName, GLenum mode );
00298   void  multMatrixd( const char *fctName, const GLdouble *m );
00299   void  multMatrixf( const char *fctName, const GLfloat *m );
00300   void  newList( const char *fctName, GLuint list, GLenum mode );
00301   void  normalPointer( const char *fctName, GLenum type, GLsizei stride, const GLvoid *pointer );
00302   void  ortho( const char *fctName, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear
00303              , GLdouble zFar );
00304   void  pointSize( const char *fctName, GLfloat size );
00305   void  polygonMode( const char *fctName, GLenum face, GLenum mode );
00306   void  polygonOffset( const char *fctName, GLfloat factor, GLfloat units );
00307   void  popAttrib( const char *fctName );
00308   void  popMatrix( const char *fctName );
00309   void  primitiveRestartIndex( const char *fctName, GLuint index );
00310   void  pushAttrib( const char *fctName, GLbitfield mask );
00311   void  pushMatrix( const char *fctName );
00312   void  rotated( const char *fctName , GLdouble angle, GLdouble x, GLdouble y, GLdouble z );
00313   void  rotatef( const char *fctName , GLfloat angle, GLfloat x, GLfloat y, GLfloat z );
00314   void  scaled( const char *fctName, GLdouble x, GLdouble y, GLdouble z );
00315   void  scalef( const char *fctName, GLfloat x, GLfloat y, GLfloat z );
00316   void  state( const char *fctName, GLenum cap, bool on );
00317   void  texCoordPointer( const char *fctName, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00318   void  texEnvf( const char *fctName, GLenum target, GLenum pname, GLfloat param );
00319   void  texEnvfv( const char *fctName, GLenum target, GLenum pname, const GLfloat *params );
00320   void  texEnvi( const char *fctName, GLenum target, GLenum pname, GLint param );
00321   void  texEnviv( const char *fctName, GLenum target, GLenum pname, const GLint *params );
00322   void  texImage2d( const char *fctName, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height
00323                   , GLint border, GLenum format, GLenum type, const GLvoid *pixels );
00324   void  texParameterf( const char *fctName, GLenum target, GLenum pname, GLfloat param );
00325   void  texParameterfv( const char *fctName, GLenum target, GLenum pname, const GLfloat *params );
00326   void  texParameteri( const char *fctName, GLenum target, GLenum pname, GLint param );
00327   void  texParameteriv( const char *fctName, GLenum target, GLenum pname, const GLint *params );
00328   void  translated( const char *fctName, GLdouble x, GLdouble y, GLdouble z );
00329   void  translatef( const char *fctName, GLfloat x, GLfloat y, GLfloat z );
00330   void  vertexPointer( const char *fctName, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00331   void  viewport( const char *fctName, GLint x, GLint y, GLsizei width, GLsizei height );
00332
00333 public:
00334   std::map<std::string,size_t>                        m_fctCount;
00335   std::map<std::string,GLStatsCount>                  m_fctStats;
00336   GLenum                                              m_activeTexture;
00337   GLenum                                              m_blendFuncDFactor;
00338   GLenum                                              m_blendFuncSFactor;
00339   std::map<GLenum,GLuint>                             m_boundBuffer;
00340   std::vector<std::map<GLenum,GLuint> >               m_boundTexture;
00341   std::map<GLuint,std::vector<char> >                 m_bufferData;
00342   std::map<GLuint,GLenum>                             m_bufferDataUsage;
00343   nvmath::Vec4f                                       m_clearColor;
00344   GLenum                                              m_clientActiveTexture;
00345   nvmath::Vec4f                                       m_color;
00346   GLenum                                              m_depthFunc;
00347   GLboolean                                           m_depthMask;
00348   std::map<size_t,size_t>                             m_drawElementsHistogram;
00349   std::map<size_t,size_t>                             m_drawElementsIndexDistanceHistogram;
00350   std::map<GLenum,std::map<GLenum,GLfloat> >          m_lightf;
00351   std::map<GLenum,std::map<GLenum,nvmath::Vec3f> >    m_light3f;
00352   std::map<GLenum,std::map<GLenum,nvmath::Vec4f> >    m_light4f;
00353   std::map<GLenum,nvmath::Vec4f>                      m_lightModel4f;
00354   std::map<GLenum,GLint>                              m_lightModeli;
00355   GLfloat                                             m_lineWidth;
00356   std::map<GLenum,std::map<GLenum,GLfloat> >          m_materialf;
00357   std::map<GLenum,std::map<GLenum,nvmath::Vec4f> >    m_material4f;
00358   std::map<GLenum,std::stack<nvmath::Mat44f> >        m_matrixf;
00359   GLenum                                              m_matrixMode;
00360   GLfloat                                             m_pointSize;
00361   std::map<GLenum,GLenum>                             m_polygonMode;
00362   GLfloat                                             m_polygonOffsetFactor;
00363   GLfloat                                             m_polygonOffsetUnits;
00364   GLuint                                              m_primitiveRestartIndex;
00365   std::map<GLenum,bool>                               m_state;
00366   std::map<GLuint,std::map<GLint,GLint> >             m_texImage2dInternalFormat;
00367   std::map<GLuint,std::map<GLenum,GLint> >            m_texParameter;
00368   std::map<GLuint,nvmath::Vec4f>                      m_textureBorderColor;
00369   std::map<GLenum,bool>                               m_textureCoordArrayState;
00370   std::map<GLenum,nvmath::Vec4f>                      m_textureEnvColor;
00371   std::map<GLenum,GLint>                              m_textureEnvMode;
00372   std::map<GLuint,GLfloat>                            m_texturePriority;
00373   GLsizei                                             m_viewportHeight;
00374   GLsizei                                             m_viewportWidth;
00375   GLint                                               m_viewportX;
00376   GLint                                               m_viewportY;
00377 };
00378
00379 #else
00380
00381 # define  NVSG_GL_STATS_FCT_COUNT()
00382 # define  NVSG_GL_STATS_ACTIVE_TEXTURE( texture )
00383 # define  NVSG_GL_STATS_BIND_BUFFER( target, id )
00384 # define  NVSG_GL_STATS_BIND_TEXTURE( target, texture )
00385 # define  NVSG_GL_STATS_BLEND_FUNC( sfactor, dfactor )
00386 # define  NVSG_GL_STATS_BUFFER_DATA( target, size, data, usage )
00387 # define  NVSG_GL_STATS_CALL_LIST( list )
00388 # define  NVSG_GL_STATS_CLEAR( mask )
00389 # define  NVSG_GL_STATS_CLEAR_COLOR( red, green, blue, alpha )
00390 # define  NVSG_GL_STATS_CLIENT_ACTIVE_TEXTURE( texture )
00391 # define  NVSG_GL_STATS_CLIENT_STATE( array, on )
00392 # define  NVSG_GL_STATS_COLOR3B( red, green, blue )
00393 # define  NVSG_GL_STATS_COLOR3BV( v )
00394 # define  NVSG_GL_STATS_COLOR3D( red, green, blue )
00395 # define  NVSG_GL_STATS_COLOR3DV( v )
00396 # define  NVSG_GL_STATS_COLOR3F( red, green, blue )
00397 # define  NVSG_GL_STATS_COLOR3FV( v )
00398 # define  NVSG_GL_STATS_COLOR3I( red, green, blue )
00399 # define  NVSG_GL_STATS_COLOR3IV( v )
00400 # define  NVSG_GL_STATS_COLOR3S( red, green, blue )
00401 # define  NVSG_GL_STATS_COLOR3SV( v )
00402 # define  NVSG_GL_STATS_COLOR3UB( red, green, blue )
00403 # define  NVSG_GL_STATS_COLOR3UBV( v )
00404 # define  NVSG_GL_STATS_COLOR3UI( red, green, blue )
00405 # define  NVSG_GL_STATS_COLOR3UIV( v )
00406 # define  NVSG_GL_STATS_COLOR3US( red, green, blue )
00407 # define  NVSG_GL_STATS_COLOR3USV( v )
00408 # define  NVSG_GL_STATS_COLOR4B( red, green, blue, alpha )
00409 # define  NVSG_GL_STATS_COLOR4BV( v )
00410 # define  NVSG_GL_STATS_COLOR4D( red, green, blue, alpha )
00411 # define  NVSG_GL_STATS_COLOR4DV( v )
00412 # define  NVSG_GL_STATS_COLOR4F( red, green, blue, alpha )
00413 # define  NVSG_GL_STATS_COLOR4FV( v )
00414 # define  NVSG_GL_STATS_COLOR4I( red, green, blue, alpha )
00415 # define  NVSG_GL_STATS_COLOR4IV( v )
00416 # define  NVSG_GL_STATS_COLOR4S( red, green, blue, alpha )
00417 # define  NVSG_GL_STATS_COLOR4SV( v )
00418 # define  NVSG_GL_STATS_COLOR4UB( red, green, blue, alpha )
00419 # define  NVSG_GL_STATS_COLOR4UBV( v )
00420 # define  NVSG_GL_STATS_COLOR4UI( red, green, blue, alpha )
00421 # define  NVSG_GL_STATS_COLOR4UIV( v )
00422 # define  NVSG_GL_STATS_COLOR4US( red, green, blue, alpha )
00423 # define  NVSG_GL_STATS_COLOR4USV( v )
00424 # define  NVSG_GL_STATS_DELETE_BUFFERS( n, buffers )
00425 # define  NVSG_GL_STATS_DELETE_LISTS( list, range )
00426 # define  NVSG_GL_STATS_DELETE_TEXTURES( n, textures )
00427 # define  NVSG_GL_STATS_DEPTH_FUNC( func )
00428 # define  NVSG_GL_STATS_DEPTH_MASK( flag )
00429 # define  NVSG_GL_STATS_DRAW_ELEMENTS( mode, count, type, indices )
00430 # define  NVSG_GL_STATS_DRAW_RANGE_ELEMENTS( mode, start, end, count, type, indices )
00431 # define  NVSG_GL_STATS_END_LIST()
00432 # define  NVSG_GL_STATS_FRUSTUM( left, right, bottom, top, zNear, zFar )
00433 # define  NVSG_GL_STATS_GEN_BUFFERS( n, buffers )
00434 # define  NVSG_GL_STATS_GEN_LISTS( range )
00435 # define  NVSG_GL_STATS_GEN_TEXTURES( n, textures )
00436 # define  NVSG_GL_STATS_GET_INTEGERV( pname, params )
00437 # define  NVSG_GL_STATS_IS_TEXTURE( texture )
00438 # define  NVSG_GL_STATS_LIGHTF( light, pname, param )
00439 # define  NVSG_GL_STATS_LIGHTFV( light, pname, params )
00440 # define  NVSG_GL_STATS_LIGHTI( light, pname, param )
00441 # define  NVSG_GL_STATS_LIGHTIV( light, pname, params )
00442 # define  NVSG_GL_STATS_LIGHT_MODELF( pname, param )
00443 # define  NVSG_GL_STATS_LIGHT_MODELFV( pname, params )
00444 # define  NVSG_GL_STATS_LIGHT_MODELI( pname, param )
00445 # define  NVSG_GL_STATS_LIGHT_MODELIV( pname, params )
00446 # define  NVSG_GL_STATS_LINE_WIDTH( width )
00447 # define  NVSG_GL_STATS_LOAD_IDENTITY()
00448 # define  NVSG_GL_STATS_LOAD_MATRIXD( m )
00449 # define  NVSG_GL_STATS_LOAD_MATRIXF( m )
00450 # define  NVSG_GL_STATS_MATERIALF( face, pname, param )
00451 # define  NVSG_GL_STATS_MATERIALFV( face, pname, params )
00452 # define  NVSG_GL_STATS_MATERIALI( face, pname, param )
00453 # define  NVSG_GL_STATS_MATERIALIV( face, pname, params )
00454 # define  NVSG_GL_STATS_MATRIX_MODE( mode )
00455 # define  NVSG_GL_STATS_MULT_MATRIXD( m )
00456 # define  NVSG_GL_STATS_MULT_MATRIXF( m )
00457 # define  NVSG_GL_STATS_NEW_LIST( list, mode )
00458 # define  NVSG_GL_STATS_NORMAL_POINTER( type, stride, pointer )
00459 # define  NVSG_GL_STATS_ORTHO( left, right, bottom, top, zNear, zFar )
00460 # define  NVSG_GL_STATS_POINT_SIZE( size )
00461 # define  NVSG_GL_STATS_POLYGON_MODE( face, mode )
00462 # define  NVSG_GL_STATS_POLYGON_OFFSET( factor, units )
00463 # define  NVSG_GL_STATS_POP_ATTRIB()
00464 # define  NVSG_GL_STATS_POP_MATRIX()
00465 # define  NVSG_GL_STATS_PRIMITIVE_RESTART_INDEX( index )
00466 # define  NVSG_GL_STATS_PUSH_ATTRIB( mask )
00467 # define  NVSG_GL_STATS_PUSH_MATRIX()
00468 # define  NVSG_GL_STATS_ROTATED( angle, x, y, z )
00469 # define  NVSG_GL_STATS_ROTATEF( angle, x, y, z )
00470 # define  NVSG_GL_STATS_SCALED( x, y, z )
00471 # define  NVSG_GL_STATS_SCALEF( x, y, z )
00472 # define  NVSG_GL_STATS_STATE( cap, on )
00473 # define  NVSG_GL_STATS_TEX_COORD_POINTER( size, type, stride, pointer )
00474 # define  NVSG_GL_STATS_TEX_ENVF( target, pname, param )
00475 # define  NVSG_GL_STATS_TEX_ENVFV( target, pname, params )
00476 # define  NVSG_GL_STATS_TEX_ENVI( target, pname, param )
00477 # define  NVSG_GL_STATS_TEX_ENVIV( target, pname, params )
00478 # define  NVSG_GL_STATS_TEX_IMAGE2D( target, level, internalformat, width, height, border, format, type, pixels )
00479 # define  NVSG_GL_STATS_TEX_PARAMETERF( target, pname, param )
00480 # define  NVSG_GL_STATS_TEX_PARAMETERFV( target, pname, params )
00481 # define  NVSG_GL_STATS_TEX_PARAMETERI( target, pname, param )
00482 # define  NVSG_GL_STATS_TEX_PARAMETERIV( target, pname, params )
00483 # define  NVSG_GL_STATS_TRANSLATED( x, y, z )
00484 # define  NVSG_GL_STATS_TRANSLATEF( x, y, z )
00485 # define  NVSG_GL_STATS_VERTEX_POINTER( size, type, stride, pointer )
00486 # define  NVSG_GL_STATS_VIEWPORT( x, y, width, height )
00487
00488 #endif
00489
00490 #endif  // DOXYGON_IGNORE
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLTraverser.h File Reference

#include <list>
#include "nvsgcommon.h"
#include "nvgl/GLContext.h"
#include "nvgl/GLDALData.h"
#include "nvmath/Matnnt.h"
#include "nvsg/TextureImage.h"
#include "nvtraverser/RenderTraverser.h"

Include dependency graph for GLTraverser.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvgl
namespace | nvtraverser

Defines

#define | NVSG_ASSERT_CONTEXT() assertContext();
Use this to make sure that the right OpenGL context is current.

Detailed Description

Define Documentation

#define NVSG_ASSERT_CONTEXT ( ) assertContext();

Use this to make sure that the right OpenGL context is current.

Generated on Tue Jan 15 10:27:44 2008 for NVSGSDK by NVIDIA


GLTraverser.h Source File

GLTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00016 #include <list>
00017 #include "nvsgcommon.h" // common used stuff
00018 #include "nvgl/GLContext.h"
00019 #include "nvgl/GLDALData.h"
00020 #include "nvmath/Matnnt.h"
00021 #include "nvsg/TextureImage.h"
00022 #include "nvtraverser/RenderTraverser.h" // base class definition
00023
00024 namespace nvgl
00025 {
00026   class FBOFrameBuffer; // internal class, not meant to be publicly used
00027   class PBuffer;        // internal class, not meant to be publicly used
00028 }
00029
00030 namespace nvtraverser
00031 {
00033 #if defined(_WIN32) && !defined(NDEBUG)
00034   #define NVSG_ASSERT_CONTEXT() assertContext();
00035 #else
00036   #define NVSG_ASSERT_CONTEXT()
00037 #endif
00038
00040
00043   class GLTraverser : public RenderTraverser
00044   {
00045     public:
00047       NVSG_API GLTraverser(void);
00048
00050
00054       NVSG_API virtual bool isGeometryCacheTechniqueSupported( GeometryCacheTechnique gct
00055                                                              ) const;
00056
00058       NVSG_API virtual void setGeometryCacheTechnique( GeometryCacheTechnique gct
00059                                                      );
00060
00071       NVSG_API virtual bool isJitterTechniqueSupported( JitterTechnique jt ) const;
00072
00074
00077       NVSG_API virtual bool isRenderTechniqueSupported( RenderTechnique rt
00078                                                       ) const;
00079
00081
00087       NVSG_API virtual bool isShadowTechniqueSupported( ShadowTechnique st
00088                                                       ) const;
00089
00091
00092       NVSG_API virtual void setShadowMapSize( unsigned int size
00093                                             );
00094
00096
00097       NVSG_API virtual void setShadowTechnique( ShadowTechnique st
00098                                               );
00099
00101
00103       NVSG_API virtual void setTextureSizeLimit( unsigned int size );
00104
00106
00113       NVSG_API virtual bool isTransparencyTechniqueSupported( TransparencyTechnique tt
00114                                                             ) const;
00115
00117       NVSG_API virtual void setTransparencyTechnique( TransparencyTechnique tt
00118                                                     );
00119
00121
00124       NVSG_API virtual bool isOITTechniqueSupported( OITTechnique ot
00125                                                    ) const;
00126
00128
00129       NVSG_API virtual void setOITTechnique( OITTechnique ot
00130                                            );
00131
00133       NVSG_API virtual void setOITMaxPasses( unsigned int maxPasses
00134                                            );
00135
00137
00139       NVSG_API void setLocalViewer( bool onOff
00140                                   );
00142
00145       NVSG_API bool isLocalViewerEnabled() const;
00146
00148
00150       NVSG_API void setSeparateSpecularColor( bool onOff
00151                                             );
00152
00154
00157       NVSG_API bool isSeparateSpecularColorEnabled( void ) const;
00158
00160
00175       NVSG_API void setTextureGenericGPUFormat( nvsg::TextureImage::TextureGPUFormat fmt );
00176
00178
00180       NVSG_API nvsg::TextureImage::TextureGPUFormat getTextureGenericGPUFormat( void ) const;
00181
00182       NVSG_API virtual bool isOcclusionCullingSupported( void ) const;
00183       NVSG_API virtual unsigned int createOcclusionCullID( void );
00184       NVSG_API virtual void   destroyOcclusionCullID( unsigned int id );
00185       NVSG_API virtual unsigned int getOcclusionCullResult( unsigned int id );
00186       NVSG_API virtual void   beginOcclusionCullQuery( unsigned int id );
00187       NVSG_API virtual void   endOcclusionCullQuery( unsigned int id );
00188       NVSG_API virtual void   hiddenBegin( void );
00189       NVSG_API virtual void   hiddenEnd( void );
00190
00191     protected:
00193       NVSG_API virtual ~GLTraverser(void);
00194
00196       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00197
00199       NVSG_API virtual void doRender( nvsg::NodeHandle * root );
00200
00202       NVSG_API virtual void handleLines(const nvsg::Lines * p);
00203
00205       NVSG_API virtual void handleLineStrips(const nvsg::LineStrips * p);
00206
00208       NVSG_API virtual void handleMapArray( const nvsg::MapArray * p );
00209
00211       NVSG_API virtual void handleMapElement( const nvsg::MapElement * p );
00212
00214       NVSG_API virtual void handleMapList( const nvsg::MapList * p );
00215
00217       NVSG_API virtual void handleMapMatrix( const nvsg::MapMatrix * p );
00218
00220       NVSG_API virtual void handlePoints(const nvsg::Points * p);
00221
00223       NVSG_API virtual void handleQuadMeshes(const nvsg::QuadMeshes * p);
00224
00226       NVSG_API virtual void handleQuads(const nvsg::Quads * p);
00227
00229       NVSG_API virtual void handleQuadStrips(const nvsg::QuadStrips * p);
00230
00232       NVSG_API virtual void handleTriangles(const nvsg::Triangles * p);
00233
00235       NVSG_API virtual void handleTriFans(const nvsg::TriFans * p);
00236
00238       NVSG_API virtual void handleTriStrips(const nvsg::TriStrips * p);
00239
00241       NVSG_API virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *p );
00242
00244
00245       NVSG_API virtual void renderBegin( void );
00246
00248
00249       NVSG_API virtual void renderEnd( void );
00250
00252
00253       NVSG_API virtual void renderBlendAttribute( const nvsg::BlendAttribute *p
00254                                                 , bool enable
00255                                                 );
00256
00258
00259       NVSG_API virtual void renderAlphaTestAttribute(
00260                const nvsg::AlphaTestAttribute *p
00261                , bool enable
00262                                   //disable (\c false) this AlphaTestAttribute
00263                                                 );
00264
00266
00267       NVSG_API virtual void renderDepthAttribute( const nvsg::DepthAttribute *p
00268                                                 , bool enable
00269                                                 );
00270
00272
00273       NVSG_API virtual void renderDirectedLight( const nvsg::DirectedLight *p
00274                                                , bool enable
00275                                                );
00276
00278
00279       NVSG_API virtual void renderFaceAttribute( const nvsg::FaceAttribute *p
00280                                                , bool enable
00281                                                );
00282
00284
00285       NVSG_API virtual void renderHighlightBox( const nvsg::HighlightBox * p
00286                                               );
00287
00289
00290       NVSG_API virtual void renderHighlightEdges( const nvsg::HighlightEdges * p
00291                                                 );
00292
00294
00295       NVSG_API virtual void renderLineAttribute( const nvsg::LineAttribute *p
00296                                                , bool enable
00297                                                );
00298
00300
00301       NVSG_API virtual void renderLightingAttribute( const nvsg::LightingAttribute *p
00302                                                , bool enable
00303                                                );
00304
00306
00307       NVSG_API virtual void renderLines( const nvsg::Lines *p
00308                                        );
00309
00311
00312       NVSG_API virtual void renderLineStrips( const nvsg::LineStrips *p
00313                                             );
00314
00316
00317       NVSG_API virtual void renderPointAttribute( const nvsg::PointAttribute *p
00318                                                 , bool enable
00319                                                 );
00320
00322
00323       NVSG_API virtual void renderPoints( const nvsg::Points*p
00324                                         );
00325
00327
00328       NVSG_API virtual void renderMaterial( const nvsg::Material *p
00329                                           , bool enable
00330                                           );
00331
00333
00334       NVSG_API virtual void renderParallelCamera( const nvsg::ParallelCamera *p
00335                                                 );
00336
00338
00339       NVSG_API virtual void renderPerspectiveCamera( const nvsg::PerspectiveCamera *p
00340                                                    );
00341
00343
00344       NVSG_API virtual void renderPointLight( const nvsg::PointLight *p
00345                                             , bool enable
00346                                             );
00347
00349
00350       NVSG_API virtual void renderQuadMeshes( const nvsg::QuadMeshes *p
00351         );
00352
00354
00355       NVSG_API virtual void renderQuads( const nvsg::Quads *p
00356                                        );
00357
00359
00360       NVSG_API virtual void renderQuadStrips( const nvsg::QuadStrips *p
00361                                             );
00362
00364
00365       NVSG_API virtual void renderSkinnedTriangles( const nvsg::SkinnedTriangles *p
00366                                                   );
00367
00369
00370       NVSG_API virtual void renderSpotLight( const nvsg::SpotLight *p
00371                                            , bool enable
00372                                            );
00373
00375
00377       NVSG_API virtual void renderStatePass( const nvsg::StatePass *p
00378                                            );
00379
00381
00382       NVSG_API virtual void renderTextureAttribute( const nvsg::TextureAttribute *p
00383                                                   , bool enable
00384                                                   );
00385
00387
00389       NVSG_API virtual void renderTextureAttributeItem( const nvsg::TextureAttributeItem *p
00390                                                       , unsigned int tu
00391                                                       );
00392
00394
00395       NVSG_API virtual void renderTriangles( const nvsg::Triangles *p
00396                                            );
00397
00399
00400       NVSG_API virtual void renderTriFans( const nvsg::TriFans *p
00401                                          );
00402
00404
00405       NVSG_API virtual void renderTriStrips( const nvsg::TriStrips *p
00406                                            );
00407
00409
00410       NVSG_API virtual void renderUnlitColorAttribute( const nvsg::UnlitColorAttribute *p
00411                                                      , bool enable
00412                                                      );
00413
00415
00416       NVSG_API virtual void setClipPlane( unsigned int index
00417                                         , const nvmath::Plane3f & plane
00418                                         , bool enable
00419                                         );
00420
00422
00424       NVSG_API virtual void setTransforms( const nvmath::Mat44f &modelToWorld
00425                                          , const nvmath::Mat44f &worldToModel
00426                                          , bool needsNormalize
00427                                          , bool needsMirror
00428                                          );
00429
00431
00433       NVSG_API virtual void assignDirectedLightToEffectLight( nvsg::CgFxEffect * effect
00434                                                             , nvsg::CgFxParameter lightParam
00435                                                             , const nvsg::DirectedLight * directedLight
00436                                                             , const nvmath::Mat44f& modelToWorld
00437                                                             );
00438
00440
00442       NVSG_API virtual void assignPointLightToEffectLight( nvsg::CgFxEffect * effect
00443                                                          , nvsg::CgFxParameter lightParam
00444                                                          , const nvsg::PointLight * pointLight
00445                                                          , const nvmath::Mat44f& modelToWorld
00446                                                          );
00447
00449
00451       NVSG_API virtual void assignSpotLightToEffectLight( nvsg::CgFxEffect * effect
00452                                                         , nvsg::CgFxParameter lightParam
00453                                                         , const nvsg::SpotLight * spotLight
00454                                                         , const nvmath::Mat44f& modelToWorld
00455                                                         );
00456
00458       NVSG_API virtual void overlayBegin( void );
00459
00461       NVSG_API virtual void overlayEnd( void );
00462
00464       NVSG_API virtual void transparentBegin( void );
00465
00467       NVSG_API virtual void transparentEnd( void );
00468
00470       NVSG_API virtual void highlightBegin( void );
00471
00473       NVSG_API virtual void highlightEnd( void );
00474
00476       NVSG_API virtual void primitiveSetsBegin();
00477
00479
00481       NVSG_API virtual bool primitiveSetsEnd();
00482
00483     private:
00484       // A little helper class for screen door transparency.
00485       class StipplePatterns
00486       {
00487         public:
00488           StipplePatterns();
00489           unsigned char  * getBits(int index);
00490
00491         private:
00492           unsigned char  patBytes[ 64 ][ 8 ];
00493           unsigned long stippleBits[64][32];
00494
00495           StipplePatterns( const StipplePatterns &stipplePatterns );
00496           StipplePatterns& operator=( const StipplePatterns &stipplePatterns );
00497       };
00498
00499
00500     private:
00501
00502       void                  init(); // initializes the renderer, OpenGL states, attribs, ...
00503       void                  exit(); // uninitializes the renderer
00504
00505       void                  reportWarning(const std::string& problem, const std::string& missingFeature);
00506       void                  reportError(const std::string& problem, const std::string& missingFeature);
00507
00508       void                  createJitterFragmentPrograms( void );
00509       void                  doApplyShadowExit( void );
00510       void                  doApplyShadowInit( nvsg::NodeHandle * root );
00511       void                  drawImage( int x, int y, nvsg::TextureImageHandle * tih );
00512       void                  drawMeshedPrimitiveSet( const nvsg::MeshedPrimitiveSet *p, GLenum mode, unsigned int numberOfMeshes, const nvsg::IndexMesh *meshes );
00513       void                  drawMeshedPrimitiveSetDL( const nvsg::MeshedPrimitiveSet *p, GLenum mode, unsigned int numberOfMeshes, const nvsg::IndexMesh *meshes );
00514       void                  drawMeshedPrimitiveSetVBO( const nvsg::MeshedPrimitiveSet *p, GLenum mode, unsigned int numberOfMeshes, const nvsg::IndexMesh *meshes );
00515       void                  drawIndependentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p, GLenum mode, GLsizei count, const GLvoid *indices );
00516       void                  drawIndependentPrimitiveSetDL( const nvsg::IndependentPrimitiveSet *p, GLenum mode, GLsizei count, const GLvoid *indices );
00517       void                  drawIndependentPrimitiveSetVBO( const nvsg::IndependentPrimitiveSet *p, GLenum mode, GLsizei count, const GLvoid *indices );
00518       void                  drawStrippedPrimitiveSet( const nvsg::StrippedPrimitiveSet *p, GLenum mode, unsigned int numberOfStrips, const nvsg::IndexSet *strips );
00519       void                  drawStrippedPrimitiveSetDL( const nvsg::StrippedPrimitiveSet *p, GLenum mode, unsigned int numberOfStrips, const nvsg::IndexSet *strips );
00520       void                  drawStrippedPrimitiveSetVBO( const nvsg::StrippedPrimitiveSet *p, GLenum mode, unsigned int numberOfStrips, const nvsg::IndexSet *strips );
00521       void                  evaluateLightingAndColorMaterial(const nvsg::PrimitiveSet *p);
00522       nvgl::GLDisplayListCache * getDisplayListCache(const nvsg::DALHost *p) const;
00523       nvgl::GLElementArrayBufferCache * getElementArrayBufferCache(const nvsg::DALHost * p) const;
00524       nvgl::GLArrayBufferCache * getArrayBufferCache(const nvsg::DALHost * p) const;
00525       nvgl::GLTextureCache * getTextureCache(const nvsg::DALHost * p) const;
00526       bool                  getVBOCaches( const nvsg::PrimitiveSet * p, nvgl::GLElementArrayBufferCache ** eabc = NULL, nvgl::GLArrayBufferCache ** abc = NULL );
00527       void                  handleIndependentPrimitiveSetVBO( const nvsg::IndependentPrimitiveSet * p );
00528       void                  handleMeshedPrimitiveSetVBO( const nvsg::MeshedPrimitiveSet * p );
00529       void                  handleStrippedPrimitiveSetVBO( const nvsg::StrippedPrimitiveSet * p );
00530       void                  indexMeshesToIndexSets( unsigned int numberOfMeshes, const nvsg::IndexMesh * meshes, std::vector<nvsg::IndexSet> &sets );
00531       void                  jitterClear();
00532       void                  jitterInit( JitterTechnique jt );
00533       void                  prepareEffect( nvsg::CgFxEffect * effect );
00534       void                  processPrimitiveSet( const nvsg::PrimitiveSet *p );
00535       void                  processPrimitiveSetVBO( const nvsg::PrimitiveSet *p, const nvgl::GLElementArrayBufferCache * vboInfoI, const nvgl::GLArrayBufferCache * vboInfoV );
00536       void                  renderCamera( const nvsg::Camera *p );
00537       void                  renderIndependentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p, GLenum mode );
00538       void                  renderMeshedPrimitiveSet( const nvsg::MeshedPrimitiveSet *p, GLenum mode );
00539       void                  renderStrippedPrimitiveSet( const nvsg::StrippedPrimitiveSet *p, GLenum mode );
00540       void                  renderJitteredAccum( const nvsg::ViewState *p );
00541       void                  renderJitteredFBO( const nvsg::ViewState *p );
00542       void                  renderJitteredPBuffer( const nvsg::ViewState *p );
00543       void                  renderJitteredReadPixels( const nvsg::ViewState *p );
00544       bool                  renderLightSource( const nvsg::LightSource *p, bool enable, GLenum &lightId );
00545       void                  renderMono( const nvsg::ViewState *viewState );
00546       void                  renderShadow( const nvsg::Camera *p );
00547       void                  renderStereo( const nvsg::ViewState *viewState );
00548       void                  renderTransparent( const nvsg::Camera *p );
00549       void                  renderTransparentBlended( const nvsg::Camera *p );
00550       void                  renderTransparentOrderIndependent( const nvsg::Camera *p );
00551       void                  setPolygonMode( GLenum face, nvsg::FaceMode mode, const nvsg::FaceAttribute *p = NULL );
00552       void                  shadowClear( void );
00553       void                  setJitteredCamera( nvutil::ReadableObject<nvsg::Camera> & viewCamera
00554                                              , nvsg::CameraHandle * jitteredCamera
00555                                              , const std::pair<nvmath::Vec2f,nvmath::Vec2f> & jitter );
00556       void                  transparencyOITAllocPBuffers( void );
00557       void                  transparencyOITAllocFBOs( void );
00558       void                  transparencyOITAllocTextures( void );
00559       void                  transparencyClear( void );
00560       void                  transparencyInit( void );
00561       void                  transparencyOITFreeFBOBuffers( void );
00562       void                  transparencyOITFreePBuffers( void );
00563       void                  transparencyOITFreeTextures( void );
00564       void                  transparencyOITSetupRendering( void );
00565       bool                  uploadTextureImage( nvsg::TextureTarget target, nvsg::TextureImage * texImg, nvgl::GLTextureCache * cache );
00566
00567 #if 0
00568       void genVBO_VtxBuf(nvgl::GLArrayBufferCache* vi, const nvsg::VertexAttributeSet * p);
00569       void genVBO_IdxBuf(nvgl::GLElementArrayBufferCache* vi, GLsizeiptr offs, unsigned int count, const unsigned int * indices);
00570       void genVBO_IdxBuf(nvgl::GLElementArrayBufferCache* vi, GLsizeiptr offs, unsigned int count, const nvsg::IndexSet * strips);
00571 #endif
00572
00573     private:
00574
00575       bool                                      m_initialized; // indicates whether the renderer is ready to render
00576       nvgl::GLContext                          *m_lastGLContext;
00577
00578 #if !defined(NDEBUG) && defined(_WIN32)
00579       HGLRC                                     m_hglrc;
00580 #endif
00581       bool                                      m_blendAttributeEnabled;
00582       nvmath::Mat44f                            m_clipToView;
00583       JitterTechnique                           m_currentJitterTechnique;
00584       unsigned int                              m_currentTextureCount;
00585       bool                                      m_halfFloatSupport;
00586       bool                                      m_hiddenObject;
00587       bool                                      m_inShadowMapCreation;
00588       bool                                      m_textureArraySupport;
00589       GLuint                                    m_jitterDataSize;                     // for read-pixels-based jittering
00590       GLubyte                                 * m_jitterImageData;
00591       GLushort                                * m_jitterAccumData;
00592       bool                                      m_jitterAccumulationInitialized;      // for pbuffer-based jittering
00593       GLuint                                    m_jitterFPAccumulate;
00594       GLuint                                    m_jitterFPLoad;
00595       GLuint                                    m_jitterFPReturn;
00596       nvgl::PBuffer                           * m_jitterFBuffer[2];
00597       nvgl::PBuffer                           * m_jitterPBuffer;
00598       nvgl::FBOFrameBuffer                    * m_jitterFBODepth;
00599       nvgl::FBOFrameBuffer                    * m_jitterFBOColor[2];
00600       unsigned int                              m_lightCount;
00601       nvsg::LightSourceHandle                 * m_lights[8];
00602       bool                                      m_lightingForcedOff;
00603       GLint                                     m_maxClipPlanes;
00604       GLint                                     m_maxTextureSize;
00605       GLint                                     m_maxTextureUnits;
00606       nvmath::Mat44f                            m_modelToWorld;
00607       bool                                      m_occlusionQuerySupport;
00608       bool                                      m_pboSupport;
00609       bool                                      m_primitiveRestartSupport;
00610       nvmath::Vec3f                             m_shadowBackColor;
00611       std::vector<nvsg::CameraHandle *>         m_shadowLightCameras;
00612       std::vector<nvsg::LightSourceHandle *>    m_shadowLights;
00613       unsigned int                              m_shadowPass;
00614       std::vector<nvgl::PBuffer*>               m_shadowPBuffers;
00615       std::vector<nvsg::LightSourceHandle *>    m_shadowReplacementLights;
00616       StipplePatterns                           m_stipple;  // for screen door transparency
00617       std::vector<nvsg::IndexSet>               m_tempIndexSets;
00618       bool                                      m_textureNonPowerOfTwoSupport;
00619       GLint                                     m_transparencyOITDepthFormat;
00620       GLuint                                    m_transparencyOITDepthTexture;
00621       GLuint                                    m_transparencyOITFragmentProgram[2];
00622       bool                                      m_transparencyOITInitialized;
00623       std::vector<GLuint>                     * m_transparencyOITOcclusionQueries;
00624       std::vector<GLuint>                       m_transparencyOITPBufferQueries;
00625       std::vector<nvgl::PBuffer*>               m_transparencyOITPBuffers;
00626       std::vector<GLuint>                       m_transparencyOITRGBATextureQueries;
00627       std::vector<GLuint>                       m_transparencyOITRGBATextures;
00628       std::vector<GLuint>                       m_transparencyOITFBOQueries;
00629       std::vector<nvgl::FBOFrameBuffer *>       m_transparencyOITFBOs;
00630       bool                                      m_transparencyOITRendering;
00631       bool                                      m_transparencyOITSetupPending;
00632       bool                                      m_transparencyOITTransparentPass;
00633       int                                       m_transparencyOITViewportHeight;
00634       int                                       m_transparencyOITViewportWidth;
00635       int                                       m_viewportWidth;
00636       int                                       m_viewportHeight;
00637       nvmath::Mat44f                            m_worldToModel;
00638       nvmath::Mat44f                            m_worldToView;
00639       nvmath::Mat44f                            m_viewToClip;
00640       nvmath::Mat44f                            m_viewToWorld;
00641       bool                                      m_localViewer;
00642       bool                                      m_separateSpecularColor;
00643       nvsg::TextureImage::TextureGPUFormat      m_textureGenericGPUFmtOverride;
00644       nvsg::MaterialHandle *                    m_currentMaterial;
00645       nvsg::UnlitColorAttributeHandle *         m_currentUnlitColor;
00646       nvsg::MaterialHandle *                    m_defaultMaterial;
00647       nvsg::CgFxEffect *                        m_currentCgFxEffect;
00648       nvsg::CgFxTechnique                       m_currentCgFxTechnique;
00649       unsigned int                              m_currentCgFxNumPasses;
00650       unsigned int                              m_currentCgFxPass;
00651
00652       // incarnation maps
00653       std::map<nvsg::TextureAttributeItemHandle*, nvutil::Incarnation> m_perTexItemIncarnationMap;
00654   };
00655
00656   inline  unsigned char *  GLTraverser::StipplePatterns::getBits( int index )
00657   {
00658     return( (unsigned char *) &stippleBits[ index ][ 0 ] );
00659   }
00660
00661   inline void GLTraverser::setLocalViewer( bool onOff )
00662   {
00663     m_localViewer = onOff;
00664   }
00665
00666   inline bool GLTraverser::isLocalViewerEnabled() const
00667   {
00668     return m_localViewer;
00669   }
00670
00671   inline void GLTraverser::setSeparateSpecularColor( bool onOff )
00672   {
00673     m_separateSpecularColor = onOff;
00674   }
00675
00676   inline bool GLTraverser::isSeparateSpecularColorEnabled( void ) const
00677   {
00678     return m_separateSpecularColor;
00679   }
00680
00681   inline void GLTraverser::setTextureGenericGPUFormat( nvsg::TextureImage::TextureGPUFormat fmt )
00682   {
00683     m_textureGenericGPUFmtOverride = fmt;
00684   }
00685
00686   inline nvsg::TextureImage::TextureGPUFormat GLTraverser::getTextureGenericGPUFormat( void ) const
00687   {
00688     return m_textureGenericGPUFmtOverride;
00689   }
00690 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLUploadTraverser.h File Reference

#include <list>
#include "nvsgcommon.h"
#include "nvtraverser/GLTraverser.h"

Include dependency graph for GLUploadTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:44 2008 for NVSGSDK by NVIDIA


GLUploadTraverser.h Source File

GLUploadTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <list>
00016 #include "nvsgcommon.h" // common used stuff
00017 #include "nvtraverser/GLTraverser.h" // base class definition
00018
00019 namespace nvtraverser
00020 {
00022
00027   class GLUploadTraverser : public GLTraverser
00028   {
00029     public:
00031
00035       NVSG_API GLUploadTraverser( bool display );
00036
00037     protected:
00039       NVSG_API virtual ~GLUploadTraverser(void);
00040
00041       // the four methods we override
00042       NVSG_API virtual void handleLOD( const nvsg::LOD * lod );
00043       NVSG_API virtual void handleSwitch( const nvsg::Switch * swtch );
00044       NVSG_API virtual void lockViewState();
00045
00047       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00048
00050       NVSG_API virtual void doRender( nvsg::NodeHandle * root );
00051
00052     private:
00053
00054       bool  m_display;
00055   };
00056 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLWinRenderArea.h File Reference

#include "nvsgcommon.h"
#include "nvgl/GLContext.h"
#include "nvui/RenderArea.h"

Include dependency graph for GLWinRenderArea.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:27:45 2008 for NVSGSDK by NVIDIA


GLWinRenderArea.h Source File

GLWinRenderArea.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011 #ifdef _WIN32
00012
00013 #pragma once
00014
00016 #include "nvsgcommon.h"
00017
00018 #include "nvgl/GLContext.h"
00019 #include "nvui/RenderArea.h"
00020
00021 namespace nvui
00022 {
00032   class GLWinRenderArea : public RenderArea
00033   {
00034     public:
00037       NVSG_API GLWinRenderArea(void);
00038
00041       NVSG_API virtual ~GLWinRenderArea(void);
00042
00076       NVSG_API virtual bool attachWindow( HWND hWnd );
00077
00093       NVSG_API virtual bool init( RenderArea * shareArea = NULL );
00094
00100       NVSG_API virtual void destroy( void );
00101
00108       NVSG_API void  makeCurrent( void );
00109
00116       NVSG_API virtual void setViewportSize( unsigned int x, unsigned int y );
00117
00124       NVSG_API bool shareLists( GLWinRenderArea* ra );
00125
00134       NVSG_API virtual void renderScene( void );
00135
00141       NVSG_API virtual void triggerRedraw( void );
00142
00151       NVSG_API void enableHWFSAA();
00152
00158       NVSG_API void disableHWFSAA();
00159
00165       NVSG_API bool isHWFSAAEnabled();
00166
00171       NVSG_API void forcePixelFormat( int pf );
00172
00173     protected:
00174       HGLRC     m_hglrc;
00175       HDC       m_hdc;
00176
00183       NVSG_API virtual bool initGL();
00184
00185
00186     private:
00187       GLuint m_backImgTexObj;    // GL texture object related to the back image
00188       nvsg::TextureImageHandle * m_backImg; // for comparison/caching purposes
00189       int   m_pixelFormat;
00190       HWND  m_hWindow;      // Our Window handle
00191 };
00192
00193 }
00194
00195 #endif //_WIN32
00196
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GPUSkinningProcessor.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CoreTypes.h"
#include "nvtraverser/AppTraverser.h"
#include "nvmath/Matnnt.h"
#include <map>
#include <vector>
#include <string>
#include "Cg/cg.h"
#include "Cg/cgGL.h"

Include dependency graph for GPUSkinningProcessor.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvgl
namespace | nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:45 2008 for NVSGSDK by NVIDIA


GPUSkinningProcessor.h Source File

GPUSkinningProcessor.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/CoreTypes.h"
00017 #include "nvtraverser/AppTraverser.h"
00018 #include "nvmath/Matnnt.h"
00019 #include <map>
00020 #include <vector>
00021 #include <string>
00022 #include "Cg/cg.h"
00023 #include "Cg/cgGL.h"
00024
00025 namespace nvsg
00026 {
00027   class SkinnedVertexAttributeSet;
00028   class Group;
00029   class DALHost;
00030 }
00031
00032 namespace nvgl
00033 {
00034   struct GLArrayBufferCache;
00035 }
00036
00037 namespace nvtraverser {
00038
00040
00042 class GPUSkinningProcessor : public AppTraverser::SkinningProcessor
00043 {
00044 public:
00046   NVSG_API GPUSkinningProcessor();
00047
00049   NVSG_API virtual void process( bool process );
00050   NVSG_API virtual AppTraverser::SkinningProcessorType getType();
00051
00053   static NVSG_API bool isSupported( void );
00054
00055 protected:
00057   NVSG_API virtual ~GPUSkinningProcessor();
00058
00059
00060 private:
00061   static void cgErrorCallback( void );
00062
00063   void pushErrorCallback();
00064   void popErrorCallback();
00065   CGerrorCallbackFunc m_oldErrCallback;
00066
00067   struct GPUInfo
00068   {
00069     CGprogram vertexProgram;
00070     CGprogram geometryProgram;
00071
00072     GLuint dataBufferTexture;
00073     GLuint skeletonTexture;
00074
00075     int attribs[ 16 * 3 ];
00076     int numAttribs;
00077   };
00078
00079   void initCg();
00080   void initTransformFeedback();
00081   GLuint createSkeletonTexture( int numMatrices );
00082   unsigned char * getWritableBuffer( size_t size, bool pbo );
00083   void releaseBuffer( bool pbo );
00084   unsigned char * bufferOffset( unsigned char *, bool pbo );
00085   void updateSkinTexture( GLuint texture
00086                         , std::vector<std::pair<nvmath::Mat44f,nvmath::Mat44f> > & jointMatrices );
00087   void processSkins();
00088   GPUInfo * createGPUInfo( nvsg::PrimitiveSetHandle * psh );
00089   void processSkinnedPrimitiveSets();
00090   void processPrimitives( const nvsg::VertexAttributeSet *vas,
00091                           const nvgl::GLArrayBufferCache * vboInfoV );
00092   static bool isArrayBufferCacheValid( const nvgl::GLArrayBufferCache * info );
00093   nvgl::GLArrayBufferCache * getArrayBufferCache( const nvsg::DALHost * host );
00094   void drawVAS( const nvsg::VertexAttributeSet * vas, nvgl::GLArrayBufferCache * vboInfoV );
00095   void beginFrame( int numValues );
00096   void endFrame();
00097   void renderFeedback( const nvsg::VertexAttributeSet * vas, nvgl::GLArrayBufferCache * vboInfoV
00098                      , GPUInfo * gpuInfo );
00099   void processSkinnedPrimitiveSet( nvsg::PrimitiveSetHandle * psh, GPUInfo * info );
00100   GLint createDataBufferTexture( nvsg::SkinHandle * sh, unsigned int & maxCount );
00101   bool buildShaders( const nvsg::PrimitiveSet * ps, GPUInfo * info, unsigned int maxCount );
00102
00103   std::map<nvsg::SkinHandle*,GLuint>            m_skinToTexture;
00104   std::map<nvsg::PrimitiveSetHandle*,GPUInfo*>  m_SPSToInfo;
00105
00106   CGcontext m_cgContext;
00107   static CGcontext s_cgContext;
00108   CGprofile m_cgVprofile, m_cgGprofile, m_cgFprofile;
00109
00110   GLuint        m_writableBuffer[2];
00111   unsigned int  m_writableBufferPBOSize[2];
00112   unsigned int  m_whichPBO;
00113   unsigned char * m_writableBufferB;
00114   unsigned int  m_writableBufferSize;
00115   GLuint        m_maxTextureDimension;
00116   bool          m_initialized;
00117 };
00118
00119 } // namespace nvtraverser
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Group.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Planent.h"
#include "nvsg/Node.h"

Include dependency graph for Group.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:46 2008 for NVSGSDK by NVIDIA


Group.h Source File

Group.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Planent.h"
00017 #include "nvsg/Node.h"
00018
00019 namespace nvsg
00020 {
00027 class Group : public Node
00028 {
00029 public:
00030
00033   NVSG_API Group();
00034
00041   NVSG_API explicit Group( const Node &rhs );
00042
00047   NVSG_API Group( const Group& rhs );
00048
00051   NVSG_API virtual ~Group();
00052
00058   NVSG_API unsigned int getNumberOfChildren() const;
00059
00085   NVSG_API unsigned int addChild(NodeHandle * child, unsigned int position = ~0);
00086
00111   NVSG_API NodeHandle * getChild(unsigned int position) const;
00112
00131   NVSG_API bool removeChild(NodeHandle * child);
00132
00150   NVSG_API void removeChild(unsigned int position);
00151
00168   NVSG_API bool replaceChild(NodeHandle * newChild, NodeHandle * oldChild);
00169
00185   NVSG_API void replaceChild(NodeHandle * newChild, unsigned int position);
00186
00195   NVSG_API bool hasChild(NodeHandle * node) const;
00196
00208   NVSG_API bool getChildPositions(NodeHandle * node, std::vector<unsigned int> & positions) const;
00209
00213   NVSG_API unsigned int getNumberOfClipPlanes() const;
00214
00218   NVSG_API unsigned int getNumberOfActiveClipPlanes() const;
00219
00226   NVSG_API bool isClipPlaneActive( unsigned int index ) const;
00227
00234   NVSG_API const nvmath::Plane3f&  getClipPlane( unsigned int index ) const;
00235
00241   NVSG_API void addClipPlane( const nvmath::Plane3f& plane, bool active = true );
00242
00248   NVSG_API void activateClipPlane( unsigned int index );
00249
00255   NVSG_API void deactivateClipPlane( unsigned int index );
00256
00263   NVSG_API void setClipPlane( unsigned int index, const nvmath::Plane3f& plane );
00264
00270   NVSG_API unsigned int getNumberOfLightSources() const;
00271
00297   NVSG_API LightSourceHandle * getLightSource( unsigned int index ) const;
00298
00307   NVSG_API bool hasLightSource( LightSourceHandle * lsHdl ) const;
00308
00317   NVSG_API void addLightSource( LightSourceHandle * lsHdl );
00318
00334   NVSG_API void replaceLightSource( unsigned int index, LightSourceHandle * lsHdl );
00335
00347   NVSG_API void replaceLightSource( LightSourceHandle * newHdl, LightSourceHandle * oldHdl );
00348
00361   NVSG_API void removeLightSource( unsigned int index );
00362
00379   NVSG_API virtual bool isEquivalent(const Object * p, bool ignoreNames, bool deepCompare) const;
00380
00391   NVSG_API Group & operator=(const Group & rhs);
00392
00399   NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00400
00401 protected:
00402
00415   NVSG_API virtual void preRemoveChild(unsigned int position);
00416
00430   NVSG_API virtual void postRemoveChild(unsigned int position);
00431
00445   NVSG_API virtual void preAddChild(unsigned int position);
00446
00459   NVSG_API virtual void postAddChild(unsigned int position);
00460
00472   NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00473
00486   NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00487
00495   NVSG_API virtual unsigned short determineHintsContainment( unsigned short hints ) const;
00496
00515   NVSG_API virtual bool determineTransparencyContainment() const;
00516
00521   NVSG_API virtual bool determineCgFxContainment() const;
00522
00527   NVSG_API virtual bool determineLightContainment() const;
00528
00533   NVSG_API virtual bool determineLODContainment() const;
00534
00539   NVSG_API virtual bool determineVolumeNodeContainment() const;
00540
00544   NVSG_API virtual bool determineAnimationContainment() const;
00545
00561   NVSG_API void invalidateCaches(NodeHandle *child, bool insert);
00562
00563 private:
00564   void copyChildren(const std::vector<NodeHandle*> & children);
00565   void copyLightSources(const std::vector<LightSourceHandle*> & lightSources);
00566   void addAsParentTo(NodeHandle* child);
00567   void removeAsParentFrom(NodeHandle* child);
00568
00569 private:
00570   std::vector<NodeHandle*>                      m_children;  // the group's child nodes
00571   std::vector<std::pair<bool,nvmath::Plane3f> > m_clipPlanes; // user clip planes
00572   std::vector<LightSourceHandle*>               m_lightSources;
00573 };
00574
00575 inline unsigned int Group::getNumberOfChildren() const
00576 {
00577   NVSG_TRACE();
00578   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00579   NVSG_ASSERT( m_children.size() <= UINT_MAX );
00580   return( static_cast<unsigned int>(m_children.size()) );
00581 }
00582
00583 inline NodeHandle * Group::getChild( unsigned int position ) const
00584 {
00585   NVSG_TRACE();
00586   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00587   NVSG_ASSERT(position<m_children.size()); // undefined behavior for invalid position
00588   return m_children[position];
00589 }
00590
00591 inline bool Group::hasChild( NodeHandle * child ) const
00592 {
00593   NVSG_TRACE();
00594   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00595   return std::find(m_children.begin(), m_children.end(), child) != m_children.end();
00596 }
00597
00598 inline unsigned int Group::getNumberOfClipPlanes() const
00599 {
00600   NVSG_TRACE();
00601   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00602   NVSG_ASSERT( m_clipPlanes.size() <= UINT_MAX );
00603   return( static_cast<unsigned int>(m_clipPlanes.size()) );
00604 }
00605
00606 inline bool Group::isClipPlaneActive( unsigned int index ) const
00607 {
00608   NVSG_TRACE();
00609   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00610   NVSG_ASSERT( index < m_clipPlanes.size() );
00611   return( m_clipPlanes[index].first );
00612 }
00613
00614 inline const nvmath::Plane3f& Group::getClipPlane( unsigned int index ) const
00615 {
00616   NVSG_TRACE();
00617   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00618   NVSG_ASSERT( index < m_clipPlanes.size() );
00619   return( m_clipPlanes[index].second );
00620 }
00621
00622 inline void Group::addClipPlane( const nvmath::Plane3f & plane, bool active )
00623 {
00624   NVSG_TRACE();
00625   NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00626   m_clipPlanes.push_back( std::make_pair( active, plane ) );
00627   invalidateIncarnation();
00628 }
00629
00630 inline void Group::setClipPlane( unsigned int index, const nvmath::Plane3f & plane )
00631 {
00632   NVSG_TRACE();
00633   NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00634   NVSG_ASSERT( index < m_clipPlanes.size() );
00635   if ( m_clipPlanes[index].second != plane )
00636   {
00637     m_clipPlanes[index].second = plane;
00638     invalidateIncarnation();
00639   }
00640 }
00641
00642 inline unsigned int Group::getNumberOfLightSources() const
00643 {
00644   NVSG_TRACE();
00645   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00646   NVSG_ASSERT( m_lightSources.size() <= UINT_MAX );
00647   return( static_cast<unsigned int>(m_lightSources.size()) );
00648 }
00649
00650 inline LightSourceHandle * Group::getLightSource( unsigned int index ) const
00651 {
00652   NVSG_TRACE();
00653   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00654   NVSG_ASSERT( index < m_lightSources.size() );
00655   return( m_lightSources[index] );
00656 }
00657
00658 inline bool Group::hasLightSource( LightSourceHandle * lsHdl ) const
00659 {
00660   NVSG_TRACE();
00661   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00662   return std::find(m_lightSources.begin(), m_lightSources.end(), lsHdl) != m_lightSources.end();
00663 }
00664
00665 inline void Group::addAsParentTo(NodeHandle * child)
00666 {
00667   NVSG_TRACE();
00668   NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00669   NVSG_ASSERT(child); // required valid
00670   nvutil::WritableObject<Node>(child)->addParent(this);
00671 }
00672
00673 inline void Group::removeAsParentFrom(NodeHandle * child)
00674 {
00675   NVSG_TRACE();
00676   NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00677   NVSG_ASSERT(child); // required valid
00678   nvutil::WritableObject<Node>(child)->removeParent(this);
00679 }
00680
00681 } //  namespace nvsg
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Handle.h File Reference

#include <basetsd.h>
#include <stdint.h>
#include "nvutil/Allocator.h"
#include "nvutil/RCObject.h"
#include "nvutil/SWMRSync.h"
#include "nvutil/Assert.h"
#include "nvutil/Conversion.h"

Include dependency graph for Handle.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvutil

Defines

#define | CreateHandle(HandleType) HandleType::create()
Instantiates a Handle of type HandleType.

#define | CreateHandleFromBase(HandleType, BaseHandle) HandleType::createFromBase(BaseHandle)
Instantiates a Handle of type HandleType from the specified BaseHandle.

#define | TEMPLATE template
#define | PROTECTED protected

Typedefs

typedef uintptr_t | UINT_PTR

Detailed Description

Define Documentation

#define CreateHandle ( HandleType ) HandleType::create()

Instantiates a Handle of type HandleType.

Parameters:
HandleType Type of the particular Handle to instantiate.
Returns:
A pointer to the new instantiated Handle.
Use this macro to default-construct a Handle of type HandleType.

#define CreateHandleFromBase | ( | HandleType,
 |  | BaseHandle | ) | HandleType::createFromBase(BaseHandle)

Instantiates a Handle of type HandleType from the specified BaseHandle.

Parameters:
HandleType | Type of the particular Handle to instantiate.
BaseHandle | Pointer to a Handle which type is a base of HandleType.
Returns:
A pointer to the new instantiated Handle.
Use this macro to construct a Handle of type HandleType. The instantiated Handle is a partial copy of the Handle pointed to by BaseHandle.

This macro is useful, for example, if you intend to copy-convert sibling Handle types. That is, let B_Handle and C_Handle both inherit from A_HANDLE, than you can use CreateHandleFromBase to instantiate a C_Handle as a partial copy from a B_Handle.

Generated on Tue Jan 15 10:27:46 2008 for NVSGSDK by NVIDIA


Handle.h Source File

Handle.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00013 #pragma once
00014
00015 #if defined(_WIN32)
00016 # include <basetsd.h>
00017 #endif
00018 #if defined(LINUX)
00019 # include <stdint.h>
00020 typedef uintptr_t UINT_PTR;
00021 #endif
00022
00023 #include "nvutil/Allocator.h"
00024 #include "nvutil/RCObject.h"
00025 #include "nvutil/SWMRSync.h"
00026 #include "nvutil/Assert.h"
00027 #include "nvutil/Conversion.h"
00028
00029 namespace nvutil
00030 {
00031
00052 #if !defined(NDEBUG) && !defined(DOXYGEN_IGNORE)
00053 # define CreateHandle(HandleType) HandleType::create(__FILE__, __LINE__)
00054 # define CreateHandleFromBase(HandleType,BaseHandle) HandleType::createFromBase(__FILE__, __LINE__, BaseHandle)
00055 # define _new_ new(__FILE__, __LINE__)
00056 #else
00057 # define CreateHandle(HandleType) HandleType::create()
00058 # define CreateHandleFromBase(HandleType,BaseHandle) HandleType::createFromBase(BaseHandle)
00059 # if !defined(DOXYGEN_IGNORE)
00060 #  define _new_ new
00061 # endif
00062 #endif
00063
00064 #if defined(_MSC_VER)
00065   // the ms compilers are less compliant to the C++ standard than other compilers
00066 # define TEMPLATE
00067   // the ms compilers do not recognize the Handle hierarchy right!
00068   // both, v1310 and v1400 do not recognize Handle<U,V> as a base class of Handle<T, Handle<U,V> >,
00069   // and hence, do not allow derived classes to access protected members of their base class!
00070 # define PROTECTED public
00071 #else
00072   // C++ standard compliant
00073 # define TEMPLATE  template
00074 # define PROTECTED protected
00075 #endif
00076
00077 // special 'null' type used to build Handle class hierarchy
00078 class NullType;
00079 class EmptyType {};
00080
00081 // serves as base class for 'handled' objects
00082 class HandledObject
00083 {
00084 protected:
00085   HandledObject() {/* do nothing! */}
00086   HandledObject(const HandledObject&) {/* do nothing! */}
00087   virtual ~HandledObject() {
00088 #if !defined(NDEBUG)
00089     m_signature = 0xDEADF00D;
00090     m_handle = 0xDEADF00D;
00091 #endif
00092   }
00093 private:
00094   template <typename T> friend struct Holder;
00095   template <typename T> friend T* getHandle(const HandledObject*);
00096   enum { SIGNATURE=0x4753564e /* "NVSG" */};
00097   int m_signature; // initialized with SIGNATURE if the object is handled
00098   UINT_PTR m_handle; // holds the address of the corresponding handle
00099 };
00100
00101 // enables back-referencing an object to its handle
00102 // and serves locking purposes
00103 template <typename T>
00104 struct Holder : public nvutil::IAllocator
00105 {
00106   // both, the default constructor and the copy constructor use the placement new
00107   // to create an object of type T at &rawmem[0]
00108   Holder(UINT_PTR hdl)
00109   {
00110     // early assign the handle!
00111     // note:
00112     // need to early assign handle and signature here because some object
00113     // constructors require a valid handle available at construction-time
00114     ptr = (T*)&rawmem[0];
00115     ptr->m_signature = HandledObject::SIGNATURE;
00116     ptr->m_handle = hdl;
00117     // construct the object at specified memory
00118     // note:
00119     // the following does not override already assigned handle and signature!
00120     // see HandleObject constructor for more details
00121     ptr = new(&rawmem[0]) T();
00122   }
00123   Holder(const Holder<T>& rhs, UINT_PTR hdl)
00124   {
00125     // early assign the handle!
00126     // note:
00127     // need to early assign handle and signature here because some object
00128     // constructors require a valid handle available at construction-time
00129     ptr = (T*)&rawmem[0];
00130     ptr->m_signature = HandledObject::SIGNATURE;
00131     ptr->m_handle = hdl;
00132     // copy-construct the object at specified memory
00133     // note:
00134     // the following does not override already assigned handle and signature!
00135     // see HandleObject constructor for more details
00136     ptr = new(&rawmem[0]) T(*rhs.ptr);
00137   }
00138   template <typename U>
00139   Holder(const Holder<U>& rhs, UINT_PTR hdl)
00140   {
00141     // early assign the handle!
00142     // note:
00143     // need to early assign handle and signature here because some object
00144     // constructors require a valid handle available at construction-time
00145     ptr = (T*)&rawmem[0];
00146     ptr->m_signature = HandledObject::SIGNATURE;
00147     ptr->m_handle = hdl;
00148     // copy-construct the object at specified memory
00149     // note:
00150     // the following does not override already assigned handle and signature!
00151     // see HandleObject constructor for more details
00152     ptr = new(&rawmem[0]) T(*rhs.ptr);
00153   }
00154   // the destructor explicitely calls T's destructor
00155   ~Holder() { ptr->~T(); }
00156
00157   nvutil::SWMRSync lock; // handles exclusive and shared locking
00158   T * ptr; // points to the object created at &rawmem[sizeof(UINT_PTR)]
00159
00160   // note: this array must reside at the very end of this structure
00161   // as its size varies for different types T and hence would alter
00162   // offsets for subsequent members!
00163   char rawmem[sizeof(T)];
00164 };
00165
00166 // general definition helps to limit certain hierarchies, that is -
00167 // (1) a Handle must either be a stand-alone class (not derived from any other class) or
00168 // (2) must be derived from another Handle class
00169
00213 template <typename T, typename U=NullType>
00214 class Handle;
00215
00223 template <typename T>
00224 class Handle<T, NullType> : public nvutil::RCObject
00225 {
00226 public:
00227   typedef T ObjectType;
00228
00229 public:
00230   // deep copy
00231   // NOTE: For this function to work as expected, it needs to be 'virtual'
00232   // However, declaring it virtual disables lazy instantiation for this function.
00233   // That is - the compiler would fully instantiate the definition and not only
00234   // as much as is really needed. For a generated class hierarchy for which the wrapped
00235   // type is part of a class hierarchy with an abstract base class, for example, this would
00236   // end up in a compiler error, because abstract base classes cannot be instantiated.
00237   // A workaround for this is to implement a pseudo-virtual call mechanism for the clone
00238   // function via a function pointer which will be overridden for each 'real' Handle instance.
00239
00247   Handle * clone() const;
00248
00262   T * beginEdit();
00263
00269   void endEdit();
00270
00284   const T * beginRead();
00285
00295   void endRead();
00296
00297 #if !defined(DOXYGEN_IGNORE)
00298
00299 public:
00300   static Handle * create();
00301 #if !defined(NDEBUG)
00302   // debug create provides leak tracking through CreateHandle macro
00303   static Handle * create(const char* file, unsigned int line);
00304 #endif
00305
00306 #if !defined(NDEBUG)
00307   void assertWriteLocked() const;
00308   void assertReadLocked() const;
00309 #endif
00310
00311 protected:
00312   // default constructor will be invoked from derived class's constructors only
00313   Handle();
00314   virtual ~Handle();
00315
00316 PROTECTED:
00317   // helper to turn the type-less pointed-to holder into an object
00318   // of type Holder<U>
00319
00320   // NOTE: from a derived, that is - dependent Handle, this
00321   // function must be called using the template keyword as follows:
00322   //
00323   // Handle<T, U> h;
00324   // // h.holder<T>(); // this throws a compile error!
00325   // h.TEMPLATE holder<T>(); // correct syntax!
00326   //
00327   // since h is dependent, the compiler is not expecting holder to be
00328   // a template and so parses holder as a non-template if the template
00329   // keyword was not specified as shown above!
00330   template <typename U>
00331   const Holder<U>& holder() const;
00332
00333 protected:
00334   // function pointer through which to call the pseudo-virtual clone function.
00335   Handle * (Handle::*m_pfnVirtualClone)(void) const;
00336
00337   // type-less pointer to a Holder<T>
00338   //
00339   // use a void* here to avoid violation of strict-aliasing rules, where the
00340   // compiler can assume that objects of different types never reside at the
00341   // same memory address.
00342   //
00343   // since the type of the pointed-to object changes per derived Handle, the
00344   // usage of Holder<T>* instead would violate strict-aliasing rules, which
00345   // in turn can result in unexpected runtime behavior!
00346   void * m_holder;
00347
00348 #if !defined(NDEBUG)
00349   SWMRSync m_dbgLock;
00350   int m_dbgWriteCount;
00351   int m_dbgReadCount;
00352   bool m_dbgInsideConstructor;
00353   bool m_dbgInsideDestructor;
00354 #endif
00355
00356 private:
00357   // copy constructor will be invoked by clone
00358   Handle(const Handle& rhs);
00359   // init on default construction; will be invoked by create
00360   void default_init();
00361   // implementation of clone, called through m_pfnVirtualClone
00362   Handle * clone_impl() const;
00363
00364   // not permitted ...
00365   // ... assignment
00366   Handle& operator=(const Handle& rhs);
00367   // ... comparison
00368   bool operator==(const Handle& rhs) const;
00369   bool operator!=(const Handle& rhs) const;
00370
00371 #endif // DOXYGEN_IGNORE
00372 };
00373
00380 template <typename T, typename U, typename V>
00381 class Handle<T, Handle<U,V> > : public Handle<U,V>
00382 {
00383 public:
00384   typedef T ObjectType;
00385
00386 public:
00394   Handle * clone() const; // hides! base class implementation
00395
00396 #if !defined(DOXYGEN_IGNORE)
00397 public:
00398   // instantiation
00399   static Handle * create();
00400   static Handle * createFromBase(const Handle<U,V>& base);
00401 #if !defined(NDEBUG)
00402   static Handle * create(const char * file, unsigned int line);
00403   static Handle * createFromBase(const char * file, unsigned int line, const Handle<U,V>& base);
00404 #endif
00405
00406   // accessors
00407   T * beginEdit();       // hides! base class implementation
00408   const T * beginRead(); // hides! base class implementation
00409   // no need to implement end[Edit/Read] functions
00410
00411 protected:
00412   Handle();
00413   virtual ~Handle();
00414
00415 private:
00416   // private typedef used in private constructors below
00417   typedef Handle* (Handle::*PFNVIRTUALCLONE) (void) const;
00418   // copy constructor, called through clone
00419   Handle(const Handle& rhs);
00420   // construct from a base Handle
00421   explicit Handle(const Handle<U,V>& base);
00422   // init on default construction; will be invoked by create
00423   void default_init();
00424   // implementation of clone, called via m_pfnVirtualClone
00425   Handle * clone_impl() const;
00426
00427   // not permitted ...
00428   // ... assignment
00429   Handle& operator=(const Handle& rhs);
00430   // ... comparison
00431   bool operator==(const Handle& rhs) const;
00432   bool operator!=(const Handle& rhs) const;
00433
00434 #endif // DOXYGEN_IGNORE
00435 };
00436
00437 //
00438 // implementation of member functions
00439 //
00440
00441 template <typename T>
00442 inline Handle<T, NullType> * Handle<T, NullType>::create()
00443 {
00444   Handle<T, NullType> * hdl = new Handle<T, NullType>();
00445   hdl->default_init();
00446   return hdl;
00447 }
00448
00449 #if !defined(NDEBUG)
00450   // debug create provides leak tracking through CreateHandle macro
00451 template <typename T>
00452 inline Handle<T, NullType> * Handle<T, NullType>::create(const char* file, unsigned int line)
00453 {
00454   Handle<T, NullType> * hdl = new(file, line) Handle<T,NullType>();
00455   hdl->default_init();
00456   return hdl;
00457 }
00458 #endif
00459
00460 template <typename T>
00461 inline Handle<T, NullType>::Handle()
00462 #if !defined(NDEBUG)
00463 : m_dbgWriteCount(0)
00464 , m_dbgReadCount(0)
00465 , m_dbgInsideConstructor(true)
00466 , m_dbgInsideDestructor(false)
00467 #endif
00468 {}
00469
00470 template <typename T>
00471 inline Handle<T, NullType>::Handle(const Handle<T,NullType>& rhs)
00472 : m_pfnVirtualClone(&Handle<T, NullType>::clone_impl)
00473 #if !defined(NDEBUG)
00474 , m_dbgWriteCount(0)
00475 , m_dbgReadCount(0)
00476 , m_dbgInsideConstructor(true)
00477 , m_dbgInsideDestructor(false)
00478 #endif
00479 {
00480   // read-lock source while being copied
00481   Handle<T,NullType> * prhs = const_cast<Handle<T,NullType>*>(&rhs);
00482   prhs->beginRead();
00483   m_holder = _new_ Holder<T>(rhs.holder<T>(), (UINT_PTR)this);
00484   prhs->endRead();
00485 #if !defined(NDEBUG)
00486   m_dbgInsideConstructor = false;
00487 #endif
00488 }
00489
00490 template <typename T>
00491 inline Handle<T, NullType>::~Handle()
00492 {
00493 #if !defined(NDEBUG)
00494   NVSG_ASSERT(m_dbgWriteCount==0); // somebody still writing the object ->undefined behavior
00495   NVSG_ASSERT(m_dbgReadCount==0); // somebody still reading the object ->undefined behavior
00496   m_dbgInsideDestructor = true;
00497 #endif
00498   delete (Holder<T>*)m_holder;
00499 }
00500
00501 template <typename T>
00502 inline void Handle<T, NullType>::default_init()
00503 {
00504   NVSG_ASSERT(m_dbgInsideConstructor);
00505   m_pfnVirtualClone = &Handle<T, NullType>::clone_impl;
00506   m_holder = _new_ Holder<T>((UINT_PTR)this);
00507 #if !defined(NDEBUG)
00508   m_dbgInsideConstructor = false;
00509 #endif
00510 }
00511
00512 template <typename T>
00513 inline Handle<T, NullType> * Handle<T, NullType>::clone() const
00514 { // pseudo-virtual call via member function pointer solves problems with
00515   // the compiler's instantiation policy for virtual functions
00516   return (this->*m_pfnVirtualClone)();
00517 }
00518
00519 template <typename T>
00520 inline Handle<T, NullType> * Handle<T, NullType>::clone_impl() const
00521 {
00522   return _new_ Handle<T, NullType>(*this);
00523 }
00524
00525 template <typename T>
00526 inline T * Handle<T, NullType>::beginEdit()
00527 {
00528   // the following waits until exclusive access was given
00529   holder<T>().lock.lockExclusive();
00530 #if !defined(NDEBUG)
00531   m_dbgWriteCount++;
00532 #endif
00533   return holder<T>().ptr;
00534 }
00535
00536 template <typename T>
00537 inline void Handle<T, NullType>::endEdit()
00538 {
00539   // release exclusive access
00540 #if !defined(NDEBUG)
00541   // catch endEdit without prior beginEdit
00542   NVSG_ASSERT(m_dbgWriteCount>0);
00543   m_dbgWriteCount--;
00544 #endif
00545   holder<T>().lock.unlockExclusive();
00546 }
00547
00548 template <typename T>
00549 inline const T * Handle<T, NullType>::beginRead()
00550 {
00551   // the following waits until shared access was given
00552   holder<T>().lock.lockShared();
00553 #if !defined(NDEBUG)
00554   {
00555     // we need exclusive access to increment this debug counter
00556     // note: this is not given by the previous shared lock
00557     AutoLock dbgLock(m_dbgLock);
00558     m_dbgReadCount++;
00559   }
00560 #endif
00561   return holder<T>().ptr;
00562 }
00563
00564 template <typename T>
00565 inline void Handle<T, NullType>::endRead()
00566 {
00567   // release shared access
00568 #if !defined(NDEBUG)
00569   {
00570     AutoLock dbgLock(m_dbgLock);
00571     // catch endRead without prior beginRead
00572     NVSG_ASSERT(m_dbgReadCount>0);
00573     m_dbgReadCount--;
00574   }
00575 #endif
00576   holder<T>().lock.unlockShared();
00577 }
00578
00579 template <typename T>
00580 template <typename U>
00581 inline const Holder<U>& Handle<T, NullType>::holder() const
00582 {
00583   return *((Holder<U>*)m_holder);
00584 }
00585
00586 #if !defined(NDEBUG)
00587 template <typename T>
00588 inline void Handle<T, NullType>::assertWriteLocked() const
00589 {
00590   // NOTE: Actually, this needs additional thread info.
00591   // That is - this is not 100% correct, for example,
00592   // when the object is write-locked from thread A and
00593   // a write access without locking is performed from
00594   // thread B!
00595   NVSG_ASSERT(  m_dbgInsideConstructor
00596              || m_dbgInsideDestructor
00597              || m_dbgWriteCount>0 );
00598 }
00599 template <typename T>
00600 inline void Handle<T, NullType>::assertReadLocked() const
00601 {
00602   // NOTE: Actually, this needs additional thread info!
00603   NVSG_ASSERT(  m_dbgInsideConstructor
00604              || m_dbgInsideDestructor
00605              || m_dbgReadCount>0
00606              || m_dbgWriteCount>0 );
00607 }
00608 #endif
00609
00610 template <typename T, typename U, typename V>
00611 inline Handle<T, Handle<U,V> > * Handle<T, Handle<U,V> >::create()
00612 {
00613   Handle<T,Handle<U,V> > * hdl = new Handle<T,Handle<U,V> >();
00614   hdl->default_init();
00615   return hdl;
00616 }
00617
00618 template <typename T, typename U, typename V>
00619 inline Handle<T, Handle<U,V> > * Handle<T, Handle<U,V> >::createFromBase(const Handle<U,V>& base)
00620 {
00621   return new Handle<T,Handle<U,V> >(base);
00622 }
00623
00624 #if !defined(NDEBUG)
00625 template <typename T, typename U, typename V>
00626 inline Handle<T, Handle<U,V> > * Handle<T, Handle<U,V> >::create(const char* file, unsigned int line)
00627 {
00628   Handle<T,Handle<U,V> > * hdl = new(file, line) Handle<T,Handle<U,V> >();
00629   hdl->default_init();
00630   return hdl;
00631 }
00632
00633 template <typename T, typename U, typename V>
00634 inline Handle<T, Handle<U,V> > * Handle<T, Handle<U,V> >::createFromBase(const char* file, unsigned int line, const Handle<U,V>& base)
00635 {
00636   return new(file, line) Handle<T,Handle<U,V> >(base);
00637 }
00638 #endif
00639
00640 template <typename T, typename U, typename V>
00641 inline Handle<T,Handle<U,V> >::Handle()
00642 {
00643   NVSG_ASSERT((Handle<U,V>::m_dbgInsideConstructor));
00644   /* do nothing ! */
00645 }
00646
00647 template <typename T, typename U, typename V>
00648 inline Handle<T,Handle<U,V> >::Handle(const Handle<T,Handle<U,V> >& rhs)
00649 // note: must not call base classes copy constructor here!!
00650 {
00651   NVSG_ASSERT((Handle<U,V>::m_dbgInsideConstructor));
00652   // override function pointer!
00653   *((PFNVIRTUALCLONE*)&this->m_pfnVirtualClone) = &Handle<T,Handle<U,V> >::clone_impl;
00654   // read-lock source while being copied
00655   Handle<T,Handle<U,V> > * prhs = const_cast<Handle<T,Handle<U,V> >*>(&rhs);
00656   prhs->beginRead();
00657   this->m_holder = _new_ Holder<T>(rhs.TEMPLATE holder<T>(), (UINT_PTR)this);
00658   prhs->endRead();
00659 #if !defined(NDEBUG)
00660   Handle<U,V>::m_dbgInsideConstructor = false;
00661 #endif
00662 }
00663
00664 template <typename T, typename U, typename V>
00665 inline Handle<T,Handle<U,V> >::Handle(const Handle<U,V>& base)
00666 // note: must not call base classes copy constructor here!!
00667 {
00668   NVSG_ASSERT((Handle<U,V>::m_dbgInsideConstructor));
00669   // override function pointer!
00670   *((PFNVIRTUALCLONE*)&this->m_pfnVirtualClone) = &Handle<T,Handle<U,V> >::clone_impl;
00671   this->m_holder = _new_ Holder<T>(base.TEMPLATE holder<U>(), (UINT_PTR)this);
00672 #if !defined(NDEBUG)
00673   Handle<U,V>::m_dbgInsideConstructor = false;
00674 #endif
00675 }
00676
00677 template <typename T, typename U, typename V>
00678 inline Handle<T,Handle<U,V> >::~Handle()
00679 {
00680   // cleanup will be managed by uppermost base class!
00681 }
00682
00683 template <typename T, typename U, typename V>
00684 inline void Handle<T,Handle<U,V> >::default_init()
00685 {
00686   NVSG_ASSERT((Handle<U,V>::m_dbgInsideConstructor));
00687   // override function pointer!
00688   *((PFNVIRTUALCLONE*)&this->m_pfnVirtualClone) = &Handle<T,Handle<U,V> >::clone_impl;
00689   this->m_holder = _new_ Holder<T>((UINT_PTR)this);
00690 #if !defined(NDEBUG)
00691   Handle<U,V>::m_dbgInsideConstructor = false;
00692 #endif
00693 }
00694
00695 template <typename T, typename U, typename V>
00696 inline Handle<T,Handle<U,V> > * Handle<T,Handle<U,V> >::clone() const
00697 { // pseudo-virtual call via member function pointer solves problems with
00698   // the compiler's instantiation policy for virtual functions
00699   return (Handle<T,Handle<U,V> >*)(this->*Handle::m_pfnVirtualClone)();
00700 }
00701
00702 template <typename T, typename U, typename V>
00703 inline Handle<T,Handle<U,V> > * Handle<T,Handle<U,V> >::clone_impl() const
00704 {
00705   return _new_ Handle<T,Handle<U,V> >(*this);
00706 }
00707
00708 template <typename T, typename U, typename V>
00709 inline T * Handle<T,Handle<U,V> >::beginEdit()
00710 {
00711   // the following waits until exclusive access was given
00712   this->TEMPLATE holder<T>().lock.lockExclusive();
00713 #if !defined(NDEBUG)
00714   Handle<U,V>::m_dbgWriteCount++;
00715 #endif
00716   return this->TEMPLATE holder<T>().ptr;
00717 }
00718
00719 template <typename T, typename U, typename V>
00720 inline const T * Handle<T,Handle<U,V> >::beginRead()
00721 {
00722   // the following waits until exclusive access was given
00723   this->TEMPLATE holder<T>().lock.lockShared();
00724 #if !defined(NDEBUG)
00725   Handle<U,V>::m_dbgReadCount++;
00726 #endif
00727   return this->TEMPLATE holder<T>().ptr;
00728 }
00729
00730 //
00731 // implementation of convenient helper functions and structs
00732 //
00733
00734 // returns the object's corresponding handle
00735 template <typename T>
00736 inline T * getHandle(const HandledObject * obj)
00737 {
00738   NVSG_ASSERT(HandledObject::SIGNATURE==obj->m_signature);
00739   return (T*)obj->m_handle;
00740 }
00741
00742 template<typename T>
00743 class WritableObject
00744 {
00745   typedef T* pointer;
00746   typedef T& reference;
00747   typedef Handle<EmptyType, NullType> DummyHandle;
00748 public:
00749   template <typename U>
00750   explicit WritableObject(U * h) {
00751     NVSG_ASSERT(h); obj=h->beginEdit();
00752   }
00753   ~WritableObject() {
00754     DummyHandle * h = getHandle<DummyHandle>(obj);
00755     h->endEdit();
00756   }
00757   // make it behave like a pointer
00758   pointer operator->() const { return obj; }
00759   reference operator*() const { return *obj; }
00760   // implicit conversion to T*
00761   operator pointer() const { return obj; }
00762   // assigning an object of type T
00763   WritableObject& operator=(const T& rhs) { *obj = rhs; return *this; }
00764 private:
00765   WritableObject(const WritableObject&); // copying not permitted!
00766   WritableObject& operator=(const WritableObject&); // assigning a WritableObject not permitted!
00767 private:
00768   pointer obj;
00769 };
00770
00771 template<typename T>
00772 class ReadableObject
00773 {
00774   typedef const T* pointer;
00775   typedef const T& reference;
00776   typedef Handle<EmptyType, NullType> DummyHandle;
00777 public:
00778   template <typename U>
00779   explicit ReadableObject(U * h) {
00780     NVSG_ASSERT(h); obj=h->beginRead();
00781   }
00782   ~ReadableObject() {
00783     DummyHandle * h = getHandle<DummyHandle>(obj);
00784     h->endRead();
00785   }
00786   // make it behave like a pointer
00787   pointer operator->() const { return obj; }
00788   reference operator*() const { return *obj; }
00789   // implicit conversion to const T*
00790   operator pointer() const { return obj; }
00791 private:
00792   ReadableObject(const ReadableObject&); // copying not permitted
00793   ReadableObject& operator=(const ReadableObject&); // assignment not permitted
00794 private:
00795   pointer obj;
00796 };
00797
00798 struct CloneObject
00799 {
00800   template<typename T>
00801   T* operator() (const T* src)
00802   {
00803     T* clone = src->clone();
00804     clone->addRef();
00805     return clone;
00806   }
00807 };
00808
00809 #undef PROTECTED
00810 #undef TEMPLATE
00811 #undef _new_
00812 } // namespace nvutil
00813
00814
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


HighlightBox.h File Reference

#include "nvsgcommon.h"
#include "nvsg/HighlightObject.h"

Include dependency graph for HighlightBox.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:47 2008 for NVSGSDK by NVIDIA


HighlightBox.h Source File

HighlightBox.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/HighlightObject.h" // base class definition
00017
00018 namespace nvsg
00019 {
00024   class HighlightBox : public HighlightObject
00025   {
00026     public:
00031       NVSG_API HighlightBox();
00032
00037       NVSG_API explicit HighlightBox( const HighlightObject &rhs );
00038
00041       NVSG_API HighlightBox( const HighlightBox &rhs );
00042
00046       NVSG_API virtual bool validateIncarnation() const;
00047
00050       NVSG_API const nvmath::Vec3f* getVertices() const;
00051
00055       NVSG_API const nvmath::Vec3f & getColor() const;
00056
00060       NVSG_API void setColor( const nvmath::Vec3f &color );
00061
00065       NVSG_API float getLineWidth() const;
00066
00070       NVSG_API void setLineWidth( float width );
00071
00077       NVSG_API HighlightBox & operator=(const HighlightBox & rhs);
00078
00079     protected:
00080
00083       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00084
00089       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00090
00091     private:
00092       NVSG_API void calculateBox() const;
00093
00094     private:
00095       mutable nvmath::Vec3f m_vertices[8];
00096       float                 m_lineWidth;
00097       nvmath::Vec3f         m_color;
00098   };
00099
00100   inline const nvmath::Vec3f & HighlightBox::getColor() const
00101   {
00102     NVSG_TRACE();
00103     return( m_color );
00104   }
00105
00106   inline float HighlightBox::getLineWidth() const
00107   {
00108     NVSG_TRACE();
00109     return( m_lineWidth );
00110   }
00111
00112   inline const nvmath::Vec3f* HighlightBox::getVertices() const
00113   {
00114     NVSG_TRACE();
00115     return( m_vertices );
00116   }
00117
00118   inline void HighlightBox::setColor( const nvmath::Vec3f &color )
00119   {
00120     NVSG_TRACE();
00121     m_color = color;
00122   }
00123
00124   inline void HighlightBox::setLineWidth( float width )
00125   {
00126     NVSG_TRACE();
00127     m_lineWidth = width;
00128   }
00129
00130 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


HighlightEdges.h File Reference

#include "nvsgcommon.h"
#include "nvsg/HighlightObject.h"
#include "nvsg/PrimitiveSet.h"

Include dependency graph for HighlightEdges.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:47 2008 for NVSGSDK by NVIDIA


HighlightEdges.h Source File

HighlightEdges.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/HighlightObject.h"
00017 #include "nvsg/PrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00025   class HighlightEdges : public HighlightObject
00026   {
00027     public:
00029       NVSG_API HighlightEdges();
00030
00033       NVSG_API HighlightEdges( const HighlightObject &rhs);
00034
00037       NVSG_API HighlightEdges( const HighlightEdges &rhs );
00038
00040       NVSG_API virtual ~HighlightEdges();
00041
00045       NVSG_API const nvmath::Vec3f & getColor() const;
00046
00050       NVSG_API void setColor( const nvmath::Vec3f &color );
00051
00055       NVSG_API float getLineWidth() const;
00056
00060       NVSG_API void setLineWidth( float width );
00061
00067       NVSG_API HighlightEdges & operator=(const HighlightEdges & rhs);
00068
00069     protected:
00070
00073       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00074
00079       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00080
00081     private :
00082       float                 m_lineWidth;
00083       nvmath::Vec3f         m_color;
00084   };
00085
00086   inline const nvmath::Vec3f & HighlightEdges::getColor() const
00087   {
00088     NVSG_TRACE();
00089     return( m_color );
00090   }
00091
00092   inline float HighlightEdges::getLineWidth() const
00093   {
00094     NVSG_TRACE();
00095     return( m_lineWidth );
00096   }
00097
00098   inline void HighlightEdges::setColor( const nvmath::Vec3f &color )
00099   {
00100     NVSG_TRACE();
00101     m_color = color;
00102   }
00103
00104   inline void HighlightEdges::setLineWidth( float width )
00105   {
00106     NVSG_TRACE();
00107     m_lineWidth = width;
00108   }
00109 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


HighlightObject.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Boxnt.h"
#include "nvmath/Spherent.h"
#include "nvsg/Object.h"
#include "nvutil/BitMask.h"

Include dependency graph for HighlightObject.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:47 2008 for NVSGSDK by NVIDIA


HighlightObject.h Source File

HighlightObject.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Boxnt.h"
00017 #include "nvmath/Spherent.h"
00018 #include "nvsg/Object.h"
00019 #include "nvutil/BitMask.h"
00020
00021 namespace nvsg
00022 {
00023   class Drawable;
00024
00029   class HighlightObject : public Object
00030   {
00031     public:
00034       NVSG_API virtual ~HighlightObject();
00035
00036
00039       NVSG_API DrawableHandle * getDrawable() const;
00040
00041       // I would like to give access to the setDrawable API to Drawable only.
00042       // Though, not sure if this really makes sense?!
00043
00047       NVSG_API void setDrawable(DrawableHandle * drawable);
00048
00051       NVSG_API const nvmath::Box3f & getBoundingBox() const;
00052
00058       NVSG_API const nvmath::Sphere3f & getBoundingSphere() const;
00059
00063       NVSG_API void invalidateBoundingVolumes();
00064
00065   protected:
00070       NVSG_API HighlightObject();
00071
00076       NVSG_API HighlightObject( const HighlightObject &rhs );
00077
00081       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const = 0;
00082
00087       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const = 0;
00088
00094       NVSG_API HighlightObject & operator=(const HighlightObject & rhs);
00095
00096     private:
00097       // private status flags controlling invalidation states
00098       enum
00099       {
00100         HF_BOUNDING_BOX_VALID = BIT0,
00101         HF_BOUNDING_SPHERE_VALID = BIT1,
00102         HF_BOUNDING_VOLUMES_VALID = HF_BOUNDING_BOX_VALID | HF_BOUNDING_SPHERE_VALID
00103       };
00104
00105       mutable unsigned int     m_flags;
00106       mutable nvmath::Box3f    m_boundingBox;
00107       mutable nvmath::Sphere3f m_boundingSphere;
00108       DrawableHandle *         m_drawable;
00109   };
00110
00111   inline void HighlightObject::setDrawable( DrawableHandle * drawable )
00112   {
00113     NVSG_TRACE();
00114     // NOTE
00115     // the HighlightObject does not reference the Drawable but the Drawable
00116     // references the HighlightObject. A HighlightObject will be attached to
00117     // a Drawable by means of the Drawable::attachHighlightObject API
00118     m_drawable = drawable;
00119   }
00120
00121   inline DrawableHandle * HighlightObject::getDrawable() const
00122   {
00123     NVSG_TRACE();
00124     return( m_drawable );
00125   }
00126 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


IdentityToGroupTraverser.h File Reference

#include <map>
#include "nvsgcommon.h"
#include "nvtraverser/OptimizeTraverser.h"

Include dependency graph for IdentityToGroupTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:47 2008 for NVSGSDK by NVIDIA


IdentityToGroupTraverser.h Source File

IdentityToGroupTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <map>
00016 #include "nvsgcommon.h"
00017 #include "nvtraverser/OptimizeTraverser.h"
00018
00019 namespace nvtraverser
00020 {
00022   class IdentityToGroupTraverser : public OptimizeTraverser
00023   {
00024     public:
00026       NVSG_API IdentityToGroupTraverser( void );
00027
00028     protected:
00030       NVSG_API virtual ~IdentityToGroupTraverser( void );
00031
00033       NVSG_API virtual void postApply( nvsg::NodeHandle * root );
00034
00036
00037       NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransform * p );
00038
00040       NVSG_API virtual void handleBillboard( nvsg::Billboard *p );
00041
00043       NVSG_API virtual void handleGroup( nvsg::Group *p );
00044
00046       NVSG_API virtual void handleLOD( nvsg::LOD *p );
00047
00049       NVSG_API virtual void handleSwitch( nvsg::Switch *p );
00050
00052       NVSG_API virtual void handleTransform( nvsg::Transform *p );
00053
00054     private:
00055       nvsg::GroupHandle * createGroupFromTransform( nvsg::TransformHandle *th );
00056       void                replaceTransforms( nvsg::Group *p );
00057   };
00058 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


IndependentPrimitiveSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/PrimitiveSet.h"

Include dependency graph for IndependentPrimitiveSet.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:48 2008 for NVSGSDK by NVIDIA


IndependentPrimitiveSet.h Source File

IndependentPrimitiveSet.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/nvsg.h"
00017 #include "nvsg/PrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00028   class IndependentPrimitiveSet : public PrimitiveSet
00029   {
00030     public:
00032       NVSG_API virtual ~IndependentPrimitiveSet();
00033
00037       NVSG_API virtual bool isDataShared() const;
00038
00042       NVSG_API virtual DataID getDataID() const;
00043
00047       NVSG_API bool hasIndices() const;
00048
00052       NVSG_API unsigned int getNumberOfIndices() const;
00053
00057       NVSG_API const unsigned int * getIndices() const;
00058
00066       NVSG_API void setIndices( const unsigned int * indices, unsigned int numIndices );
00067
00084       NVSG_API void setIndices( unsigned int pos, const unsigned int * indices, unsigned int numIndices );
00085
00099       NVSG_API virtual bool isEquivalent( const Object *p
00100                                         , bool ignoreNames
00101                                         , bool deepCompare ) const;
00102
00103     protected:
00108       NVSG_API IndependentPrimitiveSet();
00109
00117       NVSG_API explicit IndependentPrimitiveSet( const PrimitiveSet &rhs );
00118
00124       NVSG_API IndependentPrimitiveSet( const IndependentPrimitiveSet& rhs );
00125
00130       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00131
00136       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00137
00143       NVSG_API IndependentPrimitiveSet & operator=(const IndependentPrimitiveSet & rhs);
00144
00145     private:
00146       nvutil::RCPtr<nvutil::RCVector<unsigned int> > m_indices;
00147   };
00148
00149
00150   // - - - - - - - - - - - - - - - - - - - - - - - - -
00151   // inlines
00152   // - - - - - - - - - - - - - - - - - - - - - - - - -
00153
00154   inline bool IndependentPrimitiveSet::hasIndices()  const
00155   {
00156     return( !m_indices->empty() );
00157   }
00158
00159   inline unsigned int IndependentPrimitiveSet::getNumberOfIndices()  const
00160   {
00161     NVSG_ASSERT( m_indices->size() <= UINT_MAX );
00162     return( static_cast<unsigned int>(m_indices->size()) );
00163   }
00164
00165   inline const unsigned int * IndependentPrimitiveSet::getIndices() const
00166   {
00167     NVSG_TRACE();
00168     return( &(*m_indices)[0] );
00169   }
00170 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


IOLayer.h File Reference

#include <string>
#include "nvsgcommon.h"

Include dependency graph for IOLayer.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvutil
namespace | nvutil::IO

Detailed Description

Generated on Tue Jan 15 10:27:48 2008 for NVSGSDK by NVIDIA


IOLayer.h Source File

IOLayer.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <string>
00016
00017 #include "nvsgcommon.h"
00018
00019 namespace nvutil
00020 {
00022
00025   namespace IO
00026   {
00028
00033     NVSG_API void errorMessage( const std::string& caption
00034                               , const std::string& msg
00035                               , bool resume
00036                               );
00037   }
00038 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


KeyFramedAnimation.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Animation.h"

Include dependency graph for KeyFramedAnimation.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:48 2008 for NVSGSDK by NVIDIA


KeyFramedAnimation.h Source File

KeyFramedAnimation.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Animation.h"
00017
00018 namespace nvsg
00019 {
00028   template<typename T> class KeyFramedAnimation : public Animation<T>
00029   {
00030     public:
00032       virtual ~KeyFramedAnimation( void );
00033
00040       void addKey( unsigned int step, const T & value );
00041
00050       void addKeys( unsigned int numberOfKeys, const unsigned int * steps, const T * values );
00051
00062       void insertKey( unsigned int key, unsigned int step, const T & value );
00063
00070       unsigned int getKeyStep( unsigned int key ) const;
00071
00075       const unsigned int * getKeySteps() const;
00076
00083       const T & getKeyValue( unsigned int key ) const;
00084
00088       const T * getKeyValues() const;
00089
00095       unsigned int getNumberOfKeys( void ) const;
00096
00101       virtual const T & getCurrentValue() const;
00102
00111       virtual T getStepValue( unsigned int step ) const;
00112
00121       void replaceKey( unsigned int key, unsigned int step, const T & value );
00122
00133       void replaceKeys( unsigned int key, unsigned int numberOfKeys, const unsigned int * steps, const T * values );
00134
00140       void removeKey( unsigned int key );
00141
00148       void removeKeys( unsigned int key, unsigned int numberOfKeys );
00149
00153       void reserveKeys( unsigned int numberOfKeys );
00154
00161       virtual void replaceStep( unsigned int step, const T & value );
00162
00170       virtual void removeStep( unsigned int step );
00171
00178       virtual bool isCompatible( const Animation<T> * p ) const;
00179
00193       virtual bool isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const;
00194
00195     protected:
00200       KeyFramedAnimation( void );
00201
00206       KeyFramedAnimation( const KeyFramedAnimation &rhs );
00207
00215       unsigned int getKey( unsigned int frame ) const;
00216
00223       KeyFramedAnimation<T> & operator=(const KeyFramedAnimation<T> & rhs);
00224
00225     private:
00226       std::vector<unsigned int> m_keys;
00227       std::vector<T>            m_values;
00228   };
00229
00230   template<typename T>
00231   inline KeyFramedAnimation<T>::KeyFramedAnimation( void )
00232   : Animation<T>()
00233   {
00234     NVSG_TRACE();
00235   }
00236
00237   template<typename T>
00238   inline KeyFramedAnimation<T>::KeyFramedAnimation( const KeyFramedAnimation &rhs )
00239   : Animation<T>(rhs)
00240   , m_keys( rhs.m_keys )
00241   , m_values( rhs.m_values )
00242   {
00243     NVSG_TRACE();
00244   }
00245
00246   template<typename T>
00247   inline KeyFramedAnimation<T>::~KeyFramedAnimation(void)
00248   {
00249     NVSG_TRACE();
00250   }
00251
00252   template<typename T>
00253   inline void KeyFramedAnimation<T>::addKey( unsigned int step, const T & value )
00254   {
00255     NVSG_TRACE();
00256     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00257     NVSG_ASSERT( m_keys.empty() || ( m_keys.back() < step ) );
00258     m_keys.push_back( step );
00259     m_values.push_back( value );
00260     this->setNumberOfSteps( step + 1 );   // 0...step -> step + 1
00261
00262     // if value of the current step changes here -> recalculate it
00263     unsigned int curStep = this->getCurrentStep();
00264     if (    ( curStep == step )                        // current step is the new key step ?
00265         ||  (   ( 1 < m_keys.size() )                           // current step is in interval preceding the new key step ?
00266             &&  ( m_keys[m_keys.size()-2] < curStep )
00267             &&  ( curStep < step ) ) )
00268     {
00269       this->setCurrentStep( curStep );
00270     }
00271     this->invalidateIncarnation();
00272   }
00273
00274   template<typename T>
00275   inline void KeyFramedAnimation<T>::addKeys( unsigned int numberOfKeys, const unsigned int * steps, const T * values )
00276   {
00277     NVSG_TRACE();
00278     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00279     NVSG_ASSERT( numberOfKeys && steps && values );
00280     NVSG_ASSERT( m_keys.empty() || ( m_keys.back() < steps[0] ) );
00281 #if !defined(NDEBUG)
00282     for ( unsigned int i=1 ; i<numberOfKeys ; i++ )
00283     {
00284       NVSG_ASSERT( steps[i-1] < steps[i] );
00285     }
00286 #endif
00287     m_keys.insert( m_keys.end(), steps, steps + numberOfKeys );
00288     m_values.insert( m_values.end(), values, values + numberOfKeys );
00289     this->setNumberOfSteps( m_keys.back() + 1 );
00290
00291     // if value of the current step changes here -> recalculate it
00292     unsigned int curStep = this->getCurrentStep();
00293     if (    (   ( steps[0] <= curStep )                  // current step is in the new keys steps ?
00294             &&  ( curStep <= steps[numberOfKeys-1] ) )
00295         ||  (   ( numberOfKeys < m_keys.size() )                  // current step is in interval preceding the new keys steps ?
00296             &&  ( m_keys[m_keys.size()-numberOfKeys-1] < curStep )
00297             &&  ( curStep < steps[0] ) ) )
00298     {
00299       this->setCurrentStep( curStep );
00300     }
00301     this->invalidateIncarnation();
00302   }
00303
00304   template<typename T>
00305   inline void KeyFramedAnimation<T>::insertKey( unsigned int key, unsigned int step, const T & value )
00306   {
00307     NVSG_TRACE();
00308     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00309     if ( getKey( step ) == key )
00310     {
00311       replaceKey( key, step, value );
00312     }
00313     else
00314     {
00315       NVSG_ASSERT( ( key == 0 ) || ( m_keys[key-1] < step ) );
00316       NVSG_ASSERT( ( key == m_keys.size() ) || ( step < m_keys[key] ) );
00317       m_keys.insert( m_keys.begin() + key, step );
00318       m_values.insert( m_values.begin() + key, value );
00319
00320       // if value of the current step changes here -> recalculate it
00321       unsigned int curStep = this->getCurrentStep();
00322       if (    ( ( key == 0 ) ? ( step <= curStep ) : ( m_keys[key-1] < curStep ) )
00323           &&  ( ( key == m_keys.size()-1 ) ? ( curStep <= step ) : ( curStep < m_keys[key+1] ) ) )
00324       {
00325         this->setCurrentStep( curStep );
00326       }
00327       this->invalidateIncarnation();
00328     }
00329   }
00330
00331   template<typename T>
00332   inline unsigned int KeyFramedAnimation<T>::getKeyStep( unsigned int key ) const
00333   {
00334     NVSG_TRACE();
00335     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00336     NVSG_ASSERT( key < m_keys.size() );
00337     return( m_keys[key] );
00338   }
00339
00340   template<typename T>
00341   inline const unsigned int * KeyFramedAnimation<T>::getKeySteps() const
00342   {
00343     NVSG_TRACE();
00344     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00345     return( m_keys.empty() ? NULL : &m_keys[0] );
00346   }
00347
00348   template<typename T>
00349   inline const T & KeyFramedAnimation<T>::getKeyValue( unsigned int key ) const
00350   {
00351     NVSG_TRACE();
00352     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00353     NVSG_ASSERT( key < m_values.size() );
00354     return( m_values[key] );
00355   }
00356
00357   template<typename T>
00358   inline const T * KeyFramedAnimation<T>::getKeyValues() const
00359   {
00360     NVSG_TRACE();
00361     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00362     return( m_values.empty() ? NULL : &m_values[0] );
00363   }
00364
00365   template<typename T>
00366   inline unsigned int KeyFramedAnimation<T>::getNumberOfKeys( void ) const
00367   {
00368     NVSG_TRACE();
00369     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00370     NVSG_ASSERT( m_keys.size() <= UINT_MAX );
00371     return( static_cast<unsigned int>(m_keys.size()) );
00372   }
00373
00374   template<typename T>
00375   inline const T & KeyFramedAnimation<T>::getCurrentValue( void ) const
00376   {
00377     NVSG_TRACE();
00378     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00379     return( getKeyValue( getKey( this->getCurrentStep() ) ) );
00380   }
00381
00382   template<typename T>
00383   inline T KeyFramedAnimation<T>::getStepValue( unsigned int step ) const
00384   {
00385     NVSG_TRACE();
00386     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00387     NVSG_ASSERT( step < this->getNumberOfSteps() );
00388     return( getKeyValue( getKey( step ) ) );
00389   }
00390
00391   template<typename T>
00392   inline void KeyFramedAnimation<T>::replaceKey( unsigned int key, unsigned int step, const T & value )
00393   {
00394     NVSG_TRACE();
00395     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00396     NVSG_ASSERT( key < m_keys.size() );
00397     NVSG_ASSERT( ( key == 0 ) || ( m_keys[key-1] < step ) );
00398     NVSG_ASSERT( ( key == m_keys.size()-1 ) || ( step < m_keys[key+1] ) );
00399     m_keys[key] = step;
00400     m_values[key] = value;
00401     this->setNumberOfSteps( m_keys.back() + 1 );
00402
00403     // if value of the current step changes here -> recalculate it
00404     unsigned int curStep = this->getCurrentStep();
00405     if (    ( ( key == 0 ) ? ( step <= curStep ) : ( m_keys[key-1] < curStep ) )
00406         &&  ( ( key == m_keys.size()-1 ) ? ( curStep <= step ) : ( curStep < m_keys[key+1] ) ) )
00407     {
00408       this->setCurrentStep( curStep );
00409     }
00410     this->invalidateIncarnation();
00411   }
00412
00413   template<typename T>
00414   inline void KeyFramedAnimation<T>::replaceKeys( unsigned int key, unsigned int numberOfKeys
00415                                                 , const unsigned int * steps, const T * values )
00416   {
00417     NVSG_TRACE();
00418     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00419     NVSG_ASSERT( numberOfKeys && steps && values );
00420     NVSG_ASSERT( key + numberOfKeys < m_keys.size() );
00421     NVSG_ASSERT( ( key == 0 ) || ( m_keys[key-1] < steps[0] ) );
00422 #if !defined(NDEBUG)
00423     for ( unsigned int i=1 ; i<numberOfKeys ; i++ )
00424     {
00425       NVSG_ASSERT( steps[i-1] < steps[i] );
00426     }
00427 #endif
00428     NVSG_ASSERT(    ( key + numberOfKeys == m_keys.size()-1 )
00429                 ||  ( steps[numberOfKeys-1] < m_keys[key+numberOfKeys+1] ) );
00430     for ( unsigned int i=0, j=key ; i<numberOfKeys ; i++, j++ )
00431     {
00432       m_keys[j] = steps[i];
00433       m_values[j] = values[i];
00434     }
00435     this->setNumberOfSteps( m_keys.empty() ? 0 : m_keys.back() + 1 );
00436
00437    // if value of the current step changes here -> recalculate it
00438     unsigned int curStep = this->getCurrentStep();
00439     if (    ( key == 0 ) ? ( m_keys[0] <= curStep ) : ( m_keys[key-1] < curStep )
00440         &&  ( key + numberOfKeys == m_keys.size()-1 )
00441             ? ( curStep <= m_keys[key+numberOfKeys] )
00442             : ( curStep < m_keys[key+numberOfKeys+1] ) )
00443     {
00444       this->setCurrentStep( curStep );
00445     }
00446     this->invalidateIncarnation();
00447   }
00448
00449   template<typename T>
00450   inline void KeyFramedAnimation<T>::removeKey( unsigned int key )
00451   {
00452     NVSG_TRACE();
00453     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00454     NVSG_ASSERT( key < m_keys.size() );
00455     m_keys.erase( m_keys.begin() + key );
00456     m_values.erase( m_values.begin() + key );
00457     this->setNumberOfSteps( m_keys.empty() ? 0 : m_keys.back() + 1 );
00458
00459     // if value of the current step changes here -> recalculate it
00460     unsigned int curStep = this->getCurrentStep();
00461     if (    ( ( key == 0 ) || ( m_keys[key-1] < curStep ) )
00462         &&  ( ( key == m_keys.size() ) || ( curStep < m_keys[key] ) ) )
00463     {
00464       this->setCurrentStep( curStep );
00465     }
00466     this->invalidateIncarnation();
00467   }
00468
00469   template<typename T>
00470   inline void KeyFramedAnimation<T>::removeKeys( unsigned int key, unsigned int numberOfKeys )
00471   {
00472     NVSG_TRACE();
00473     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00474     NVSG_ASSERT( key + numberOfKeys < m_keys.size() );
00475     m_keys.erase( m_keys.begin() + key, m_keys.begin() + key + numberOfKeys );
00476     m_values.erase( m_values.begin() + key, m_values.begin() + key + numberOfKeys );
00477     this->setNumberOfSteps( m_keys.back() + 1 );
00478
00479     // if value of the current step changes here -> recalculate it
00480     unsigned int curStep = this->getCurrentStep();
00481     if (    ( ( key == 0 ) || ( m_keys[key-1] < curStep ) )
00482         &&  ( ( key == m_keys.size() ) || ( curStep < m_keys[key] ) ) )
00483     {
00484       this->setCurrentStep( curStep );
00485     }
00486     this->invalidateIncarnation();
00487   }
00488
00489   template<typename T>
00490   inline void KeyFramedAnimation<T>::reserveKeys( unsigned int numberOfKeys )
00491   {
00492     NVSG_TRACE();
00493     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00494     m_keys.reserve( numberOfKeys );
00495     m_values.reserve( numberOfKeys );
00496   }
00497
00498   template<typename T>
00499   inline void KeyFramedAnimation<T>::replaceStep( unsigned int step, const T & value )
00500   {
00501     NVSG_TRACE();
00502     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00503     NVSG_ASSERT( step < this->getNumberOfSteps() );
00504     insertKey( getKey( step ), step, value );
00505   }
00506
00507   template<typename T>
00508   inline void KeyFramedAnimation<T>::removeStep( unsigned int step )
00509   {
00510     NVSG_TRACE();
00511     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00512     NVSG_ASSERT( step < this->getNumberOfSteps() );
00513     unsigned int key = getKey(step);
00514
00515     // if the key just before 'step' is more than one step away -> introduce a new key at 'step'-1
00516     if ( key && ( m_keys[key-1] < step-1 ) )
00517     {
00518       NVSG_ASSERT( step );
00519       insertKey( key, step-1, getStepValue(step-1) );
00520       key++;  // now 'key' again is the key index at or to the right of 'step'
00521     }
00522
00523     // if the key just after 'step' is more than one step away -> introduce a new key at 'step'+1
00524     if ( step < this->getNumberOfSteps()-1 )
00525     {
00526       unsigned int nextStepKey = getKey(step+1);
00527       if ( step+1 < m_keys[nextStepKey] )
00528       {
00529         insertKey( nextStepKey, step+1, getStepValue(step+1) );
00530       }
00531     }
00532
00533     // if 'step' is at a key position -> remove it
00534     NVSG_ASSERT( getKey(step) == key );
00535     if ( getKeyStep(key) == step )
00536     {
00537       removeKey( key );
00538     }
00539
00540     // now reduce each key by one step -> 'step' is removed and the animation is one step shorter
00541     for ( unsigned int i=key ; i<m_keys.size() ; i++ )
00542     {
00543       m_keys[i]--;
00544     }
00545   }
00546
00547   template<typename T>
00548   inline unsigned int KeyFramedAnimation<T>::getKey( unsigned int frame ) const
00549   {
00550     NVSG_TRACE();
00551     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00552     NVSG_ASSERT( frame < this->getNumberOfSteps() );
00553     std::vector<unsigned int>::const_iterator it = std::lower_bound( m_keys.begin(), m_keys.end(), frame );
00554     NVSG_ASSERT( it != m_keys.end() );
00555     NVSG_ASSERT( ( it - m_keys.begin() ) <= UINT_MAX );
00556     return( static_cast<unsigned int>(it - m_keys.begin()) );
00557   }
00558
00559   template<typename T>
00560   KeyFramedAnimation<T> & KeyFramedAnimation<T>::operator=(const KeyFramedAnimation<T> & rhs)
00561   {
00562     NVSG_TRACE();
00563     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00564     if (&rhs != this)
00565     {
00566       Animation<T>::operator=(rhs);
00567       m_keys          = rhs.m_keys;
00568       m_values        = rhs.m_values;
00569       this->setCurrentStep( rhs.getCurrentStep() ); // just assume, the current step did change!
00570       this->invalidateIncarnation();
00571     }
00572     return *this;
00573   }
00574
00575   template<typename T>
00576   inline bool KeyFramedAnimation<T>::isCompatible( const Animation<T> * p ) const
00577   {
00578     NVSG_TRACE();
00579     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00580     // two KeyFramedAnimations need to be equivalent as Animations, to be compatible.
00581     bool compatible = Animation<T>::isEquivalent( p, true, true );
00582     if ( compatible )
00583     {
00584       const KeyFramedAnimation<T> * kfa = dynamic_cast<const KeyFramedAnimation<T>*>(p);
00585       NVSG_ASSERT( p );
00586       compatible = ( m_keys == kfa->m_keys );
00587     }
00588     return( compatible );
00589   }
00590
00591   template<typename T>
00592   inline bool KeyFramedAnimation<T>::isEquivalent( const Object * p, bool ignoreNames, bool deepCompare) const
00593   {
00594     NVSG_TRACE();
00595     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00596     bool equi = Animation<T>::isEquivalent( p, ignoreNames, deepCompare );
00597     if ( equi )
00598     {
00599       const KeyFramedAnimation<T> * iat = dynamic_cast<const KeyFramedAnimation<T>*>(p);
00600       equi = ( m_keys == iat->m_keys ) && ( m_values == iat->m_values );
00601     }
00602     return( equi );
00603   }
00604
00605 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


LightingAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/StateAttribute.h"

Include dependency graph for LightingAttribute.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:49 2008 for NVSGSDK by NVIDIA


LightingAttribute.h Source File

LightingAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/StateAttribute.h"
00017
00018
00019 namespace nvsg
00020 {
00031   class LightingAttribute : public StateAttribute
00032   {
00033     public:
00037       NVSG_API LightingAttribute();
00038
00043       NVSG_API explicit LightingAttribute( const StateAttribute &rhs );
00044
00047       NVSG_API LightingAttribute( const LightingAttribute &rhs );
00048
00050       NVSG_API virtual ~LightingAttribute();
00051
00055       NVSG_API void setEnabled( bool state );
00056
00060       NVSG_API bool getEnabled() const;
00061
00068       NVSG_API virtual bool isTransparent() const;
00069
00079       NVSG_API virtual bool isEquivalent( const Object *p
00080                                         , bool ignoreNames
00081                                         , bool deepCompare ) const;
00082
00089       NVSG_API LightingAttribute & operator=(const LightingAttribute & rhs);
00090
00091     private:
00092       bool           m_enabled;
00093   };
00094
00095   inline bool LightingAttribute::getEnabled() const
00096   {
00097     return( m_enabled );
00098   }
00099
00100 } // namespace nvsg
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


LightSource.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Trafo.h"
#include "nvsg/Animation.h"
#include "nvsg/OwnedObject.h"
#include "nvutil/Conversion.h"

Include dependency graph for LightSource.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:49 2008 for NVSGSDK by NVIDIA


LightSource.h Source File

LightSource.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h" // commonly used stuff
00016 #include "nvmath/Trafo.h"
00017 #include "nvsg/Animation.h"
00018 #include "nvsg/OwnedObject.h" // base class definition
00019 #if !defined(NDEBUG)
00020 #include "nvutil/Conversion.h"
00021 #endif
00022
00023 namespace nvsg
00024 {
00034   class LightSource : public OwnedObject<GroupHandle>
00035   {
00036     friend class Group;
00037
00038     public:
00042       NVSG_API virtual ~LightSource();
00043
00050       NVSG_API const nvmath::Vec3f& getAmbientColor() const;
00051
00058       NVSG_API void setAmbientColor( const nvmath::Vec3f &color );
00059
00066       NVSG_API const nvmath::Vec3f& getDiffuseColor() const;
00067
00074       NVSG_API void setDiffuseColor( const nvmath::Vec3f &color );
00075
00082       NVSG_API const nvmath::Vec3f& getSpecularColor() const;
00083
00090       NVSG_API void setSpecularColor( const nvmath::Vec3f &color );
00091
00097       NVSG_API float getIntensity() const;
00098
00104       NVSG_API void setIntensity( float intensity );
00105
00109       NVSG_API bool isEnabled() const;
00110
00116       NVSG_API bool isShadowCasting() const;
00117
00121       NVSG_API void setEnabled( bool enable );
00122
00128       NVSG_API void setShadowCasting( bool cast );
00129
00136       NVSG_API TrafoAnimationHandle * getAnimation() const;
00137
00143       NVSG_API void setAnimation( TrafoAnimationHandle * animation );
00144
00148       NVSG_API nvmath::Mat44f getTransformationMatrix() const;
00149
00154       NVSG_API nvmath::Mat44f getInverse() const;
00155
00169       NVSG_API virtual bool isEquivalent( const Object * p
00170                                         , bool ignoreNames
00171                                         , bool deepCompare ) const;
00172
00179       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00180
00182       NVSG_API void invalidateAnimationContainment();
00183
00184     protected:
00196       NVSG_API LightSource();
00197
00203       NVSG_API LightSource( const LightSource& rhs );
00204
00211       NVSG_API LightSource & operator=(const LightSource & rhs);
00212
00213     protected:
00214       nvmath::Trafo m_trafo;
00215
00216     private:
00217       nvmath::Vec3f               m_ambientColor;
00218       TrafoAnimationHandle      * m_animation; // animation working on a Trafo
00219       nvmath::Vec3f               m_diffuseColor;
00220       float                       m_intensity;
00221       bool                        m_shadowCasting;
00222       bool                        m_enabled;
00223       nvmath::Vec3f               m_specularColor;
00224   };
00225
00226   inline const nvmath::Vec3f& LightSource::getAmbientColor() const
00227   {
00228     NVSG_TRACE();
00229     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00230     return( m_ambientColor );
00231   }
00232
00233   inline TrafoAnimationHandle * LightSource::getAnimation() const
00234   {
00235     NVSG_TRACE();
00236     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00237     return( m_animation );
00238   }
00239
00240   inline const nvmath::Vec3f& LightSource::getDiffuseColor() const
00241   {
00242     NVSG_TRACE();
00243     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00244     return( m_diffuseColor );
00245   }
00246
00247   inline float LightSource::getIntensity() const
00248   {
00249     NVSG_TRACE();
00250     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00251     return( m_intensity );
00252   }
00253
00254   inline nvmath::Mat44f LightSource::getInverse() const
00255   {
00256     NVSG_TRACE();
00257     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00258     return( (m_animation ? nvutil::ReadableObject<Animation<nvmath::Trafo> >(m_animation)->getCurrentValue() : m_trafo).getInverse() );
00259   }
00260
00261   inline const nvmath::Vec3f& LightSource::getSpecularColor() const
00262   {
00263     NVSG_TRACE();
00264     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00265     return( m_specularColor );
00266   }
00267
00268   inline nvmath::Mat44f LightSource::getTransformationMatrix() const
00269   {
00270     NVSG_TRACE();
00271     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00272     return( (m_animation ? nvutil::ReadableObject<Animation<nvmath::Trafo> >(m_animation)->getCurrentValue() : m_trafo).getMatrix() );
00273   }
00274
00275   inline bool LightSource::isEnabled() const
00276   {
00277     NVSG_TRACE();
00278     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00279     return( m_enabled );
00280   }
00281
00282   inline bool LightSource::isShadowCasting() const
00283   {
00284     NVSG_TRACE();
00285     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00286     return( m_shadowCasting );
00287   }
00288
00289   inline void LightSource::setAmbientColor( const nvmath::Vec3f &c )
00290   {
00291     NVSG_TRACE();
00292     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00293     if ( m_ambientColor != c )
00294     {
00295       m_ambientColor = c;
00296       invalidateIncarnation();
00297     }
00298   }
00299
00300   inline void LightSource::setDiffuseColor( const nvmath::Vec3f &c )
00301   {
00302     NVSG_TRACE();
00303     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00304     if ( m_diffuseColor != c )
00305     {
00306       m_diffuseColor = c;
00307       invalidateIncarnation();
00308     }
00309   }
00310
00311   inline void LightSource::setEnabled( bool enable )
00312   {
00313     NVSG_TRACE();
00314     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00315     if ( m_enabled != enable )
00316     {
00317       m_enabled = enable;
00318       invalidateIncarnation();
00319     }
00320   }
00321
00322   inline void LightSource::setIntensity( float i )
00323   {
00324     NVSG_TRACE();
00325     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00326     if ( m_intensity != i )
00327     {
00328       m_intensity = i;
00329       invalidateIncarnation();
00330     }
00331   }
00332
00333   inline void LightSource::setSpecularColor( const nvmath::Vec3f &c )
00334   {
00335     NVSG_TRACE();
00336     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00337     if ( m_specularColor != c )
00338     {
00339       m_specularColor = c;
00340       invalidateIncarnation();
00341     }
00342   }
00343
00344   inline void LightSource::setShadowCasting( bool cast )
00345   {
00346     NVSG_TRACE();
00347     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00348     if ( m_shadowCasting != cast )
00349     {
00350       m_shadowCasting = cast;
00351       invalidateIncarnation();
00352     }
00353   }
00354
00355   template <typename T>
00356   inline T light_cast(const LightSource * light)
00357   {
00358     NVSG_CTASSERT(!!(nvutil::Conversion<T,const LightSource*>::exists));
00359     return dynamic_cast<T>(light);
00360   }
00361
00362   template <typename T>
00363   inline T light_cast(LightSource * light)
00364   {
00365     NVSG_CTASSERT(!!(nvutil::Conversion<T,LightSource*>::exists));
00366     return dynamic_cast<T>(light);
00367   }
00368 } //  namespace nvsg
00369
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


LinearInterpolatedAnimation.h File Reference

#include "nvsgcommon.h"
#include "nvsg/KeyFramedAnimation.h"
#include "nvsg/VertexAttribute.h"

Include dependency graph for LinearInterpolatedAnimation.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:49 2008 for NVSGSDK by NVIDIA


LinearInterpolatedAnimation.h Source File

LinearInterpolatedAnimation.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/KeyFramedAnimation.h"
00017 #include "nvsg/VertexAttribute.h"
00018
00019 namespace nvsg
00020 {
00028   template<typename T>
00029   class LinearInterpolatedAnimation : public KeyFramedAnimation<T>
00030   {
00031     public:
00033       LinearInterpolatedAnimation();
00034
00037       explicit LinearInterpolatedAnimation( const KeyFramedAnimation<T> &rhs );
00038
00041       LinearInterpolatedAnimation( const LinearInterpolatedAnimation &rhs );
00042
00044       virtual ~LinearInterpolatedAnimation();
00045
00050       virtual const T & getCurrentValue() const;
00051
00058       virtual T getStepValue( unsigned int step ) const;
00059
00066       LinearInterpolatedAnimation<T> & operator=(const LinearInterpolatedAnimation<T> & rhs);
00067
00068     protected:
00072       virtual void setCurrentStep( unsigned int step );
00073
00074     private:
00075       T calculateStepValue( unsigned int step ) const;
00076
00077     private:
00078       T m_currentValue;
00079   };
00080
00081   template<typename T>
00082   inline LinearInterpolatedAnimation<T>::LinearInterpolatedAnimation()
00083   {
00084     NVSG_TRACE();
00085     NVSG_ASSERT( false );
00086   }
00087
00088   template<>
00089   inline LinearInterpolatedAnimation<nvmath::Trafo>::LinearInterpolatedAnimation()
00090   { // explicit constructor
00091     NVSG_TRACE();
00092     this->m_objectCode = OC_LINEARINTERPOLATEDTRAFOANIMATION;
00093   }
00094
00095   template<>
00096   inline LinearInterpolatedAnimation<VertexAttribute>::LinearInterpolatedAnimation()
00097   { // explicit constructor
00098     NVSG_TRACE();
00099     this->m_objectCode = OC_LINEARINTERPOLATEDVERTEXATTRIBUTEANIMATION;
00100   }
00101
00102   template<typename T>
00103   inline LinearInterpolatedAnimation<T>::LinearInterpolatedAnimation( const KeyFramedAnimation<T> &rhs )
00104     : KeyFramedAnimation<T>(rhs)
00105   {
00106     NVSG_TRACE();
00107     NVSG_ASSERT( false );
00108   }
00109
00110   template<>
00111   inline LinearInterpolatedAnimation<nvmath::Trafo>::LinearInterpolatedAnimation( const KeyFramedAnimation<nvmath::Trafo> &rhs )
00112     : KeyFramedAnimation<nvmath::Trafo>(rhs)
00113   { // explicit constructor
00114     NVSG_TRACE();
00115     this->m_objectCode = OC_LINEARINTERPOLATEDTRAFOANIMATION;
00116     m_currentValue = calculateStepValue(getCurrentStep());  // initialize with current step
00117   }
00118
00119   template<>
00120   inline LinearInterpolatedAnimation<VertexAttribute>::LinearInterpolatedAnimation( const KeyFramedAnimation<VertexAttribute> &rhs )
00121     : KeyFramedAnimation<VertexAttribute>(rhs)
00122   { // explicit constructor
00123     NVSG_TRACE();
00124     this->m_objectCode = OC_LINEARINTERPOLATEDVERTEXATTRIBUTEANIMATION;
00125     m_currentValue = calculateStepValue(getCurrentStep());  // initialize with current step
00126   }
00127
00128   template<typename T>
00129   inline LinearInterpolatedAnimation<T>::LinearInterpolatedAnimation( const LinearInterpolatedAnimation<T> &rhs )
00130     : KeyFramedAnimation<T>(rhs)
00131   {
00132     NVSG_TRACE();
00133     this->m_objectCode = rhs.m_objectCode;
00134     m_currentValue = calculateStepValue(this->getCurrentStep());  // initialize with current step
00135   }
00136
00137   template<>
00138   inline LinearInterpolatedAnimation<nvmath::Trafo>::LinearInterpolatedAnimation( const LinearInterpolatedAnimation<nvmath::Trafo> &rhs )
00139     : KeyFramedAnimation<nvmath::Trafo>(rhs)
00140   {
00141     NVSG_TRACE();
00142     this->m_objectCode = rhs.m_objectCode;
00143     m_currentValue = calculateStepValue(this->getCurrentStep());  // initialize with current step
00144   }
00145
00146   template<>
00147   inline LinearInterpolatedAnimation<VertexAttribute>::LinearInterpolatedAnimation( const LinearInterpolatedAnimation<VertexAttribute> &rhs )
00148     : KeyFramedAnimation<VertexAttribute>(rhs)
00149   {
00150     NVSG_TRACE();
00151     this->m_objectCode = rhs.m_objectCode;
00152     m_currentValue = calculateStepValue(this->getCurrentStep());  // initialize with current step
00153   }
00154
00155   template<typename T>
00156   inline LinearInterpolatedAnimation<T>::~LinearInterpolatedAnimation()
00157   {
00158     NVSG_TRACE();
00159   }
00160
00161   template<typename T>
00162   inline const T & LinearInterpolatedAnimation<T>::getCurrentValue() const
00163   {
00164     NVSG_TRACE();
00165     return( m_currentValue );
00166   }
00167
00168   template<typename T>
00169   inline T LinearInterpolatedAnimation<T>::calculateStepValue( unsigned int step ) const
00170   {
00171     unsigned int key = this->getKey( step );
00172     if ( this->getKeyStep( key ) == step ) //  step is on a key => use this key step
00173     {
00174       return( this->getKeyValue( key ) );
00175     }
00176     else    //  step is between it-1 and it
00177     {
00178       NVSG_ASSERT( key != 0 );
00179       T stepValue;
00180       nvmath::lerp( (float)( step - this->getKeyStep(key-1) ) / ( this->getKeyStep(key) - this->getKeyStep(key-1) )
00181                   , this->getKeyValue( key-1 ), this->getKeyValue( key ), stepValue );
00182       return( stepValue );
00183     }
00184   }
00185
00186   template<typename T>
00187   inline T LinearInterpolatedAnimation<T>::getStepValue( unsigned int step ) const
00188   {
00189     NVSG_TRACE();
00190
00191     if ( step == this->getCurrentStep() )
00192     {
00193       return( m_currentValue );
00194     }
00195     else
00196     {
00197       return( calculateStepValue( step ) );
00198     }
00199   }
00200
00201   template<typename T>
00202   inline LinearInterpolatedAnimation<T> & LinearInterpolatedAnimation<T>::operator=(const LinearInterpolatedAnimation<T> & rhs)
00203   {
00204     NVSG_TRACE();
00205     return( KeyFramedAnimation<T>::operator=(rhs) );
00206   }
00207
00208   template<typename T>
00209   inline void LinearInterpolatedAnimation<T>::setCurrentStep( unsigned int step )
00210   {
00211     NVSG_TRACE();
00212     m_currentValue = calculateStepValue( step );
00213     KeyFramedAnimation<T>::setCurrentStep( step );
00214   }
00215 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


LineAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/PrimitiveAttribute.h"
#include <float.h>

Include dependency graph for LineAttribute.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:50 2008 for NVSGSDK by NVIDIA


LineAttribute.h Source File

LineAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/PrimitiveAttribute.h"
00017 #include <float.h>
00018
00019 namespace nvsg
00020 {
00026   class LineAttribute : public PrimitiveAttribute
00027   {
00028     public:
00032       NVSG_API LineAttribute();
00033
00038       NVSG_API explicit LineAttribute( const PrimitiveAttribute &rhs );
00039
00041       NVSG_API LineAttribute( const LineAttribute &rhs );
00042
00044       NVSG_API virtual ~LineAttribute();
00045
00054       NVSG_API unsigned short getStipplePattern() const;
00055
00064       NVSG_API void setStipplePattern( unsigned short pattern );
00065
00073       NVSG_API unsigned short getStippleFactor() const;
00074
00082       NVSG_API void setStippleFactor( unsigned short factor );
00083
00089       NVSG_API float getWidth() const;
00090
00096       NVSG_API void setWidth( float width );
00097
00101       NVSG_API bool isAntiAliased() const;
00102
00106       NVSG_API void setAntiAliasing( bool aa );
00107
00116       NVSG_API virtual bool isEquivalent( const Object * p
00117                                         , bool ignoreNames
00118                                         , bool deepCompare ) const;
00119
00126       NVSG_API LineAttribute & operator=(const LineAttribute & rhs);
00127
00128     private:
00129       bool            m_antiAliasing;
00130       unsigned short  m_stippleFactor;
00131       unsigned short  m_stipplePattern;
00132       float           m_width;
00133   };
00134
00135   inline unsigned short LineAttribute::getStippleFactor() const
00136   {
00137     NVSG_TRACE();
00138     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00139     return( m_stippleFactor );
00140   }
00141
00142   inline unsigned short LineAttribute::getStipplePattern() const
00143   {
00144     NVSG_TRACE();
00145     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00146     return( m_stipplePattern );
00147   }
00148
00149   inline float LineAttribute::getWidth() const
00150   {
00151     NVSG_TRACE();
00152     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00153     return( m_width );
00154   }
00155
00156   inline bool LineAttribute::isAntiAliased() const
00157   {
00158     NVSG_TRACE();
00159     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00160     return( m_antiAliasing );
00161   }
00162
00163   inline void LineAttribute::setAntiAliasing( bool aa )
00164   {
00165     NVSG_TRACE();
00166     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00167     if ( m_antiAliasing != aa )
00168     {
00169       m_antiAliasing = aa;
00170       invalidateIncarnation();
00171     }
00172   }
00173
00174   inline void LineAttribute::setStippleFactor( unsigned short factor )
00175   {
00176     NVSG_TRACE();
00177     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00178     NVSG_ASSERT( ( 0 < factor ) && ( factor < 256 ) );
00179     if ( m_stippleFactor != factor )
00180     {
00181       m_stippleFactor = factor;
00182       invalidateIncarnation();
00183     }
00184   }
00185
00186   inline void LineAttribute::setStipplePattern( unsigned short pattern )
00187   {
00188     NVSG_TRACE();
00189     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00190     if ( m_stipplePattern != pattern )
00191     {
00192       m_stipplePattern = pattern;
00193       invalidateIncarnation();
00194     }
00195   }
00196
00197   inline void LineAttribute::setWidth( float width )
00198   {
00199     NVSG_TRACE();
00200     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00201     NVSG_ASSERT( FLT_EPSILON < width );
00202     if ( m_width != width )
00203     {
00204       m_width = width;
00205       invalidateIncarnation();
00206     }
00207   }
00208
00209 } // namespace nvsg
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Lines.h File Reference

#include "nvsgcommon.h"
#include "nvsg/IndependentPrimitiveSet.h"
#include "nvsg/Face.h"

Include dependency graph for Lines.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:50 2008 for NVSGSDK by NVIDIA


Lines.h Source File

Lines.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/IndependentPrimitiveSet.h" // base class definition
00017 #include "nvsg/Face.h" // definition of Segment
00018
00019 namespace nvsg
00020 {
00027   class Lines : public IndependentPrimitiveSet
00028   {
00029     public:
00031       NVSG_API Lines();
00032
00034       NVSG_API explicit Lines( const IndependentPrimitiveSet &rhs );
00035
00037       NVSG_API explicit Lines( const PrimitiveSet &rhs );
00038
00040       NVSG_API Lines( const Lines &rhs );
00041
00043       NVSG_API virtual ~Lines();
00044
00049       NVSG_API bool hasSegments() const;
00050
00055       NVSG_API unsigned int getNumberOfSegments() const;
00056
00061       NVSG_API const Segment * getSegments() const;
00062
00071       NVSG_API void setSegments( const Segment * segments, unsigned int numSegments );
00072
00089       NVSG_API void setSegments( unsigned int pos, const Segment * segments, unsigned int numSegments );
00090
00096       NVSG_API Lines & operator=(const Lines & rhs);
00097   };
00098
00099   // - - - - - - - - - - - - - - - - - - - - - - - - -
00100   // inlines
00101   // - - - - - - - - - - - - - - - - - - - - - - - - -
00102
00103   inline bool Lines::hasSegments()  const
00104   {
00105     NVSG_TRACE();
00106     return( 2 <= getNumberOfIndices() );
00107   }
00108
00109   inline unsigned int Lines::getNumberOfSegments()  const
00110   {
00111     NVSG_TRACE();
00112     NVSG_ASSERT( getNumberOfIndices()/2 <= UINT_MAX );
00113     return( static_cast<unsigned int>(getNumberOfIndices()/2) );
00114   }
00115
00116   inline const Segment * Lines::getSegments() const
00117   {
00118     NVSG_TRACE();
00119     return( (const Segment *) getIndices() );
00120   }
00121
00122   inline void Lines::setSegments( const Segment* pSegments, unsigned int numSegments )
00123   {
00124     NVSG_TRACE();
00125     setIndices( (const unsigned int *) pSegments, 2 * numSegments );
00126   }
00127
00128   inline void Lines::setSegments( unsigned int pos, const Segment* pSegments, unsigned int numSegments )
00129   {
00130     NVSG_TRACE();
00131     if ( pos != ~0 )
00132     {
00133       pos *= 2;
00134     }
00135     setIndices( pos, (const unsigned int *) pSegments, 2 * numSegments );
00136   }
00137
00138   inline Lines & Lines::operator=(const Lines & rhs)
00139   {
00140     NVSG_TRACE();
00141     IndependentPrimitiveSet::operator=(rhs);
00142     return( *this );
00143   }
00144 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


LineStrips.h File Reference

#include "nvsgcommon.h"
#include "nvsg/StrippedPrimitiveSet.h"
#include "nvsg/nvsg.h"

Include dependency graph for LineStrips.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:50 2008 for NVSGSDK by NVIDIA


LineStrips.h Source File

LineStrips.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/StrippedPrimitiveSet.h"
00017 #include "nvsg/nvsg.h"
00018
00019 namespace nvsg
00020 {
00027   class LineStrips : public StrippedPrimitiveSet
00028   {
00029     public:
00031       NVSG_API LineStrips();
00032
00034       NVSG_API explicit LineStrips( const StrippedPrimitiveSet &rhs );
00035
00037       NVSG_API explicit LineStrips( const LineStrips &rhs );
00038
00040       NVSG_API virtual ~LineStrips();
00041
00046       NVSG_API LineStrips & operator=( const LineStrips & rhs );
00047   };
00048 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


LOD.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Matnnt.h"
#include "nvsg/Group.h"

Include dependency graph for LOD.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:51 2008 for NVSGSDK by NVIDIA


LOD.h Source File

LOD.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Matnnt.h"
00017 #include "nvsg/Group.h"
00018
00019 namespace nvsg
00020 {
00049   class LOD : public Group
00050   {
00051     public:
00054       NVSG_API LOD( void );
00055
00063       NVSG_API explicit LOD( const Group &rhs );
00064
00067       NVSG_API LOD( const LOD &rhs );
00068
00071       NVSG_API virtual ~LOD( void );
00072
00090       NVSG_API void setRanges(const float * ranges, unsigned int count);
00091
00099       NVSG_API const float * getRanges() const;
00100
00104       NVSG_API unsigned int getNumberOfRanges() const;
00105
00114       NVSG_API void setCenter(const nvmath::Vec3f & center);
00115
00120       NVSG_API const nvmath::Vec3f & getCenter() const;
00121
00138       NVSG_API virtual unsigned int getLODToUse(const nvmath::Mat44f & modelViewMatrix, float scaleFactor) const;
00139
00177       NVSG_API void setRangeLock(bool on, unsigned int rangeNumber);
00178
00183       NVSG_API unsigned int getRangeLock() const;
00184
00188       NVSG_API bool isRangeLockEnabled() const;
00189
00196       NVSG_API LOD & operator=(const LOD & rhs);
00197
00206       NVSG_API virtual bool isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const;
00207
00208     protected:
00209
00213       NVSG_API virtual bool determineLODContainment() const;
00214
00215     private:
00216       nvmath::Vec3f        m_center;
00217       std::vector<float>   m_ranges;
00218       unsigned int         m_rangeLock;
00219       bool                 m_isRangeLocked;
00220   };
00221 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Log.h File Reference

#include "nvsg/nvsgapi.h"
#include <stdarg.h>
#include <string>
#include "nvutil/Singleton.h"

Include dependency graph for Log.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvutil

Defines

#define | NVSG_LOG_TEST_INIT(TM) nvutil::LogTest::instance()->init(TM!=nvutil::TM_NONE)
Initialize general test logging.

#define | NVSG_LOG_TEST(s) { if ( nvutil::LogTest::instance()->isEnabled() ) { nvutil::LogTest::instance()->format s; } }
Output test relevant format string s if output is enabled.

#define | NVSG_LOG_TEST_ENABLED() nvutil::LogTest::instance()->isEnabled()
Query if any test is enabled.

Variables

NVSG_API std::string | NVSG_LOG_FILE
Global string containing the name of the log file.

Detailed Description

Variable Documentation

NVSG_API std::string NVSG_LOG_FILE

Global string containing the name of the log file.

Generated on Tue Jan 15 10:27:54 2008 for NVSGSDK by NVIDIA


Log.h Source File

Log.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/nvsgapi.h"  // storage-class defines
00016
00017 #include <stdarg.h>
00018 #include <string>
00019
00020 #include "nvutil/Singleton.h"
00021
00023 extern NVSG_API std::string NVSG_LOG_FILE;
00024
00025 namespace nvutil {
00026
00031
00032 typedef enum
00033 {
00034   TM_NONE = 0
00035 , TM_TEST
00036 } TESTMODE;
00037
00039 typedef void LOG_OUTPUT_FUNCTION(const char *);
00040 NVSG_API LOG_OUTPUT_FUNCTION logFileOutput;
00041
00042
00044
00047 template <TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
00048 class Log
00049 {
00050 public:
00051
00053
00056   Log() : m_enabled(false) {}
00058
00060   void init( bool enable
00061            );
00063
00065   void format( const char * fmt
00066              , ...
00067              ) const;
00069
00071   bool isEnabled() const;
00072
00073 private:
00074   bool m_enabled;
00075 };
00076
00077 // inline implementations
00078
00079 template <TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
00080 inline void Log<TestMode, OutputFn>::init(bool enable)
00081 {
00082   m_enabled = enable;
00083 }
00084
00085 template <TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
00086 inline void Log<TestMode, OutputFn>::format(const char * fmt, ...) const
00087 {
00088   if ( !m_enabled )
00089   {
00090     return;
00091   }
00092   // walk the parameter list and perform output
00093   const int bufSize = 1024;
00094   char outBuf[bufSize];
00095
00096   va_list ap;
00097   va_start(ap, fmt);
00098   vsnprintf(outBuf, bufSize-1, fmt, ap);
00099   va_end(ap);
00100
00101   OutputFn(outBuf);
00102 }
00103
00104 template <TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
00105 inline bool Log<TestMode, OutputFn>::isEnabled() const
00106 {
00107   return m_enabled;
00108 }
00109
00110 typedef Singleton< Log<TM_TEST,        logFileOutput> > LogTest;
00111 // ... more similar typedefs for additional tests to log
00112
00113 // NVSG_LOG macro defines
00114
00124
00125
00127 #define NVSG_LOG_TEST_INIT(TM)         nvutil::LogTest::instance()->init(TM!=nvutil::TM_NONE)
00128
00141
00142 #define NVSG_LOG_TEST(s)        { if ( nvutil::LogTest::instance()->isEnabled()       ) { nvutil::LogTest::instance()->format s; }       }
00143
00156
00157 #define NVSG_LOG_TEST_ENABLED()        nvutil::LogTest::instance()->isEnabled()
00158
00161 } // namespace nvutil
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Manipulator.h File Reference

#include "nvsgcommon.h"

Include dependency graph for Manipulator.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:27:54 2008 for NVSGSDK by NVIDIA


Manipulator.h Source File

Manipulator.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 namespace nvui
00018 {
00019   class RenderArea;
00020
00076   class Manipulator
00077   {
00078   public:
00081     NVSG_API Manipulator();
00082
00084     NVSG_API virtual ~Manipulator();
00085
00090     NVSG_API void setRenderArea(nvui::RenderArea * renderArea);
00091
00099     NVSG_API virtual bool updateFrame() = 0;
00100
00106     NVSG_API virtual bool isActive() = 0;
00107
00108   protected:
00109     nvui::RenderArea *  m_renderArea;
00111   };
00112
00113   inline void Manipulator::setRenderArea(nvui::RenderArea * renderArea)
00114   {
00115     NVSG_TRACE();
00116     m_renderArea = renderArea;
00117   }
00118
00119 } // namespace nvui
00120
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Map.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.h"

Include dependency graph for Map.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:54 2008 for NVSGSDK by NVIDIA


Map.h Source File

Map.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Object.h"
00017
00018 namespace nvsg
00019 {
00028   class Map : public Object
00029   {
00030     public:
00032       NVSG_API virtual ~Map();
00033
00037       NVSG_API size_t getWidth() const;
00038
00042       NVSG_API size_t getHeight() const;
00043
00049       NVSG_API const unsigned char * getData() const;
00050
00051     protected:
00053       NVSG_API Map();
00054
00057       NVSG_API Map( const Map &rhs );
00058
00066       NVSG_API void setMapData( size_t width
00067                               , size_t height
00068                               , size_t bitsPerPixel
00069                               , unsigned char * data );
00070
00071     private:
00072       size_t          m_width, m_height;
00073       size_t          m_bpp;  // bits per pixel
00074       unsigned char * m_data;
00075   };
00076
00077   inline size_t Map::getWidth() const
00078   {
00079     NVSG_TRACE();
00080     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00081     return( m_width );
00082   }
00083
00084   inline size_t Map::getHeight() const
00085   {
00086     NVSG_TRACE();
00087     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00088     return( m_height );
00089   }
00090
00091   inline const unsigned char * Map::getData() const
00092   {
00093     NVSG_TRACE();
00094     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00095     return( m_data );
00096   }
00097 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


MapArray.h File Reference

#include "nvsgcommon.h"
#include "nvsg/MapObject.h"
#include "nvsg/TextureImage.h"
#include <vector>

Include dependency graph for MapArray.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:54 2008 for NVSGSDK by NVIDIA


MapArray.h Source File

MapArray.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/MapObject.h"
00017 #include "nvsg/TextureImage.h"
00018 #include <vector>
00019
00020 namespace nvsg
00021 {
00029   class MapArray : public MapObject
00030   {
00031     public:
00036       NVSG_API MapArray();
00037
00039       NVSG_API MapArray( const MapArray &rhs );
00040
00042       NVSG_API virtual ~MapArray();
00043
00057       NVSG_API MapAlignment getAlignment() const;
00058
00072       NVSG_API void setAlignment( MapAlignment alignment );
00073
00080       NVSG_API MapOrientation getOrientation() const;
00081
00088       NVSG_API void setOrientation( MapOrientation orientation );
00089
00095       NVSG_API unsigned int getSpacing() const;
00096
00102       NVSG_API void setSpacing( unsigned int spacing );
00103
00114       NVSG_API MapTraversalDirection getTraversalDirection() const;
00115
00126       NVSG_API void setTraversalDirection( MapTraversalDirection direction );
00127
00131       NVSG_API unsigned int getNumberOfMaps() const;
00132
00139       NVSG_API TextureImageHandle * getMap( unsigned int index ) const;
00140
00146       NVSG_API unsigned int getIndexOfMap( TextureImageHandle * img ) const;
00147
00152       NVSG_API void addMap( TextureImageHandle * img );
00153
00161       NVSG_API void insertMap( unsigned int index, TextureImageHandle * img );
00162
00171       NVSG_API void replaceMap( unsigned int index, TextureImageHandle * img );
00172
00179       NVSG_API void removeMap( unsigned int index );
00180
00185       NVSG_API void clear( void );
00186
00193       NVSG_API void getEntrySize( unsigned int &width
00194                                 , unsigned int &height ) const;
00195
00209       NVSG_API virtual void getSize( unsigned int &width, unsigned int &height ) const;
00210
00223       NVSG_API virtual TextureImageHandle * pickMap( int x, int y ) const;
00224
00225     private:
00226       MapAlignment              m_alignment;
00227       MapTraversalDirection     m_direction;
00228       MapOrientation            m_orientation;
00229       unsigned int              m_spacing;
00230
00231       typedef std::vector<TextureImageHandle *>::const_iterator ConstImageIterator;
00232       typedef std::vector<TextureImageHandle *>::iterator ImageIterator;
00233       std::vector<TextureImageHandle *>  m_maps;
00234   };
00235
00236   inline MapAlignment MapArray::getAlignment() const
00237   {
00238     NVSG_TRACE();
00239     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00240     return( m_alignment );
00241   }
00242
00243   inline void MapArray::setAlignment( MapAlignment alignment )
00244   {
00245     NVSG_TRACE();
00246     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00247     if ( m_alignment != alignment )
00248     {
00249       m_alignment = alignment;
00250       invalidateIncarnation();
00251     }
00252   }
00253
00254   inline MapTraversalDirection MapArray::getTraversalDirection() const
00255   {
00256     NVSG_TRACE();
00257     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00258     return( m_direction );
00259   }
00260
00261   inline void MapArray::setTraversalDirection( MapTraversalDirection direction )
00262   {
00263     NVSG_TRACE();
00264     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00265     if ( m_direction != direction )
00266     {
00267       m_direction = direction;
00268       invalidateIncarnation();
00269     }
00270   }
00271
00272   inline MapOrientation MapArray::getOrientation() const
00273   {
00274     NVSG_TRACE();
00275     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00276     return( m_orientation );
00277   }
00278
00279   inline void MapArray::setOrientation( MapOrientation orientation )
00280   {
00281     NVSG_TRACE();
00282     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00283     if ( m_orientation != orientation )
00284     {
00285       m_orientation = orientation;
00286       invalidateIncarnation();
00287     }
00288   }
00289
00290   inline unsigned int MapArray::getSpacing() const
00291   {
00292     NVSG_TRACE();
00293     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00294     return( m_spacing );
00295   }
00296
00297   inline void MapArray::setSpacing( unsigned int spacing )
00298   {
00299     NVSG_TRACE();
00300     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00301     if ( m_spacing != spacing )
00302     {
00303       m_spacing = spacing;
00304       invalidateIncarnation();
00305     }
00306   }
00307
00308   inline void MapArray::addMap( TextureImageHandle * img )
00309   {
00310     NVSG_TRACE();
00311     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00312     img->addRef();
00313     m_maps.push_back( img );
00314     invalidateIncarnation();
00315   }
00316
00317   inline void MapArray::insertMap( unsigned int index, TextureImageHandle * img )
00318   {
00319     NVSG_TRACE();
00320     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00321     NVSG_ASSERT( img && ( index < m_maps.size() ) );
00322     img->addRef();
00323     m_maps.insert( m_maps.begin() + index, img );
00324     invalidateIncarnation();
00325   }
00326
00327   inline void MapArray::replaceMap( unsigned int index, TextureImageHandle * img )
00328   {
00329     NVSG_TRACE();
00330     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00331     NVSG_ASSERT( img && ( index < m_maps.size() ) );
00332     if ( m_maps[index] != img )
00333     {
00334       img->addRef();
00335       m_maps[index]->removeRef();
00336       m_maps[index] = img;
00337       invalidateIncarnation();
00338     }
00339   }
00340
00341   inline void MapArray::removeMap( unsigned int index )
00342   {
00343     NVSG_TRACE();
00344     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00345     NVSG_ASSERT( index < m_maps.size() );
00346     m_maps[index]->removeRef();
00347     m_maps.erase( m_maps.begin() + index );
00348     invalidateIncarnation();
00349   }
00350
00351   inline unsigned int MapArray::getNumberOfMaps() const
00352   {
00353     NVSG_TRACE();
00354     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00355     NVSG_ASSERT( m_maps.size() <= UINT_MAX );
00356     return( static_cast<unsigned int>(m_maps.size()) );
00357   }
00358
00359   inline TextureImageHandle * MapArray::getMap( unsigned int index ) const
00360   {
00361     NVSG_TRACE();
00362     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00363     NVSG_ASSERT( index < m_maps.size() );
00364     return( m_maps[index] );
00365   }
00366
00367   inline unsigned int MapArray::getIndexOfMap( TextureImageHandle * img ) const
00368   {
00369     NVSG_TRACE();
00370     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00371     ConstImageIterator it = std::find( m_maps.begin(), m_maps.end(), img );
00372     NVSG_ASSERT( ( it==m_maps.end() ) || ( ( it-m_maps.begin() ) < UINT_MAX ) );
00373     return( ( it != m_maps.end() ) ? static_cast<unsigned int>(it - m_maps.begin()) : ~0 );
00374   }
00375 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


MapElement.h File Reference

#include "nvsgcommon.h"
#include "nvsg/MapObject.h"

Include dependency graph for MapElement.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:55 2008 for NVSGSDK by NVIDIA


MapElement.h Source File

MapElement.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/MapObject.h"
00017
00018 namespace nvsg
00019 {
00024   class MapElement : public MapObject
00025   {
00026     public:
00030       NVSG_API MapElement();
00031
00034       NVSG_API MapElement( const MapElement &rhs );
00035
00037       NVSG_API virtual ~MapElement();
00038
00042       NVSG_API TextureImageHandle * getMap() const;
00043
00052       NVSG_API virtual TextureImageHandle * pickMap( int x, int y ) const;
00053
00056       NVSG_API void setMap( TextureImageHandle * img );
00057
00062       NVSG_API virtual void getSize( unsigned int &width, unsigned int &height ) const;
00063
00064     private:
00065       TextureImageHandle  * m_map;
00066   };
00067
00068   inline TextureImageHandle * MapElement::getMap() const
00069   {
00070     NVSG_TRACE();
00071     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00072     return( m_map );
00073   }
00074 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


MapList.h File Reference

#include "nvsgcommon.h"
#include "nvsg/MapObject.h"
#include "nvsg/Object.h"

Include dependency graph for MapList.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:55 2008 for NVSGSDK by NVIDIA


MapList.h Source File

MapList.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/MapObject.h"
00017 #include "nvsg/Object.h"
00018
00019 namespace nvsg
00020 {
00031   class MapList : public Object
00032   {
00033     public:
00035       NVSG_API MapList();
00036
00038       NVSG_API MapList( const MapList &rhs );
00039
00041       NVSG_API virtual ~MapList(void);
00042
00046       NVSG_API unsigned int getNumberOfMapObjects( void ) const;
00047
00054       NVSG_API MapObjectHandle * getMapObject( unsigned int index ) const;
00055
00060       NVSG_API void addMapObject( MapObjectHandle * mo );
00061
00069       NVSG_API void insertMapObject( unsigned int index, MapObjectHandle * mo );
00070
00079       NVSG_API void replaceMapObject( unsigned int index, MapObjectHandle * mo );
00080
00087       NVSG_API void removeMapObject( unsigned int index );
00088
00093       NVSG_API void clear( void );
00094
00107       NVSG_API TextureImageHandle * pickMap( int x, int y, unsigned int * index = NULL ) const;
00108
00114       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00115
00116     private:
00117       typedef std::vector<MapObjectHandle*>::const_iterator ConstMapObjectIterator;
00118       typedef std::vector<MapObjectHandle*>::iterator MapObjectIterator;
00119       std::vector<MapObjectHandle *>  m_list;
00120   };
00121
00122   inline void MapList::addMapObject( MapObjectHandle * mo )
00123   {
00124     NVSG_TRACE();
00125     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00126     NVSG_ASSERT( mo );
00127     mo->addRef();
00128     m_list.push_back( mo );
00129     invalidateIncarnation();
00130   }
00131
00132   inline MapObjectHandle * MapList::getMapObject( unsigned int index ) const
00133   {
00134     NVSG_TRACE();
00135     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00136     NVSG_ASSERT( index < m_list.size() );
00137     return( m_list[index] );
00138   }
00139
00140   inline unsigned int MapList::getNumberOfMapObjects( void ) const
00141   {
00142     NVSG_TRACE();
00143     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00144     NVSG_ASSERT( m_list.size() <= UINT_MAX );
00145     return( static_cast<unsigned int>(m_list.size()) );
00146   }
00147
00148   inline void MapList::insertMapObject( unsigned int index, MapObjectHandle * mo )
00149   {
00150     NVSG_TRACE();
00151     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00152     NVSG_ASSERT( mo && ( index < m_list.size() ) );
00153     mo->addRef();
00154     m_list.insert( m_list.begin() + index, mo );
00155     invalidateIncarnation();
00156   }
00157
00158   inline void MapList::removeMapObject( unsigned int index )
00159   {
00160     NVSG_TRACE();
00161     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00162     NVSG_ASSERT( index < m_list.size() );
00163     m_list[index]->removeRef();
00164     m_list.erase( m_list.begin() + index );
00165     invalidateIncarnation();
00166   }
00167
00168   inline void MapList::replaceMapObject( unsigned int index, MapObjectHandle * mo )
00169   {
00170     NVSG_TRACE();
00171     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00172     NVSG_ASSERT( mo && ( index < m_list.size() ) );
00173     if ( m_list[index] != mo )
00174     {
00175       mo->addRef();
00176       m_list[index]->removeRef();
00177       m_list[index] = mo;
00178       invalidateIncarnation();
00179     }
00180   }
00181 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


MapMatrix.h File Reference

#include "nvsgcommon.h"
#include "nvsg/MapObject.h"
#include <vector>

Include dependency graph for MapMatrix.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:56 2008 for NVSGSDK by NVIDIA


MapMatrix.h Source File

MapMatrix.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/MapObject.h"
00017 #include <vector>
00018
00019 namespace nvsg
00020 {
00031   class MapMatrix : public MapObject
00032   {
00033     public:
00038       NVSG_API MapMatrix( void );
00039
00042       NVSG_API MapMatrix( const MapMatrix &rhs );
00043
00045       NVSG_API virtual ~MapMatrix(void);
00046
00059       NVSG_API MapAlignment getAlignment( MapOrientation orientation ) const;
00060
00074       NVSG_API void setAlignment( MapOrientation orientation
00075                                 , MapAlignment alignment );
00076
00084       NVSG_API unsigned int getSpacing( MapOrientation orientation ) const;
00085
00093       NVSG_API void setSpacing( MapOrientation orientation, unsigned int spacing );
00094
00106       NVSG_API MapTraversalDirection getTraversalDirection( MapOrientation orientation ) const;
00107
00120       NVSG_API void setTraversalDirection( MapOrientation orientation
00121                                          , MapTraversalDirection direction );
00122
00126       NVSG_API unsigned int getNumberOfColumns( void ) const;
00127
00130       NVSG_API void addEmptyColumn( void );
00131
00137       NVSG_API void insertEmptyColumn( unsigned int col );
00138
00144       NVSG_API void removeColumn( unsigned int col );
00145
00150       NVSG_API unsigned int getNumberOfMaps( unsigned int col ) const;
00151
00159       NVSG_API TextureImageHandle * getMap( unsigned int col, unsigned int row ) const;
00160
00167       NVSG_API bool getIndexOfMap( TextureImageHandle * img, unsigned int & col, unsigned int & row ) const;
00168
00176       NVSG_API void addMap( unsigned int col, TextureImageHandle * img );
00177
00186       NVSG_API void insertMap( unsigned int col, unsigned int row, TextureImageHandle * map );
00187
00197       NVSG_API void replaceMap( unsigned int col, unsigned int row, TextureImageHandle * img );
00198
00206       NVSG_API void removeMap( unsigned int col, unsigned int row );
00207
00214       NVSG_API void getEntrySize( unsigned int &width, unsigned int &height ) const;
00215
00225       NVSG_API virtual void getSize( unsigned int &width, unsigned int &height ) const;
00226
00238       NVSG_API virtual TextureImageHandle * pickMap( int x, int y ) const;
00239
00240     private:
00241       typedef std::vector<TextureImageHandle *>::const_iterator ConstImageIterator;
00242       typedef std::vector<TextureImageHandle *>::iterator ImageIterator;
00243       std::vector<std::vector<TextureImageHandle *> > m_maps;
00244       MapAlignment                                    m_alignment[2];
00245       MapTraversalDirection                           m_direction[2];
00246       unsigned int                                    m_spacing[2];
00247   };
00248
00249   inline MapAlignment MapMatrix::getAlignment( MapOrientation orientation ) const
00250   {
00251     NVSG_TRACE();
00252     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00253     return( m_alignment[orientation] );
00254   }
00255
00256   inline void MapMatrix::setAlignment( MapOrientation orientation, MapAlignment alignment )
00257   {
00258     NVSG_TRACE();
00259     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00260     if ( m_alignment[orientation] != alignment )
00261     {
00262       m_alignment[orientation] = alignment;
00263       invalidateIncarnation();
00264     }
00265   }
00266
00267   inline MapTraversalDirection MapMatrix::getTraversalDirection( MapOrientation orientation ) const
00268   {
00269     NVSG_TRACE();
00270     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00271     return( m_direction[orientation] );
00272   }
00273
00274   inline void MapMatrix::setTraversalDirection( MapOrientation orientation, MapTraversalDirection direction )
00275   {
00276     NVSG_TRACE();
00277     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00278     if ( m_direction[orientation] != direction )
00279     {
00280       m_direction[orientation] = direction;
00281       invalidateIncarnation();
00282     }
00283   }
00284
00285   inline unsigned int MapMatrix::getSpacing( MapOrientation orientation ) const
00286   {
00287     NVSG_TRACE();
00288     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00289     return( m_spacing[orientation] );
00290   }
00291
00292   inline void MapMatrix::setSpacing( MapOrientation orientation, unsigned int spacing )
00293   {
00294     NVSG_TRACE();
00295     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00296     if ( m_spacing[orientation] != spacing )
00297     {
00298       m_spacing[orientation] = spacing;
00299       invalidateIncarnation();
00300     }
00301   }
00302
00303   inline void MapMatrix::addEmptyColumn( void )
00304   {
00305     NVSG_TRACE();
00306     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00307     m_maps.resize( m_maps.size() + 1 );
00308     invalidateIncarnation();
00309   }
00310
00311   inline void MapMatrix::insertEmptyColumn( unsigned int col )
00312   {
00313     NVSG_TRACE();
00314     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00315     NVSG_ASSERT( col < m_maps.size() );
00316     m_maps.insert( m_maps.begin() + col, std::vector<TextureImageHandle*>() );
00317     invalidateIncarnation();
00318   }
00319
00320   inline void MapMatrix::addMap( unsigned int col, TextureImageHandle * img )
00321   {
00322     NVSG_TRACE();
00323     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00324     NVSG_ASSERT( img && ( col < m_maps.size() ) );
00325     img->addRef();
00326     m_maps[col].push_back( img );
00327     invalidateIncarnation();
00328   }
00329
00330   inline void MapMatrix::insertMap( unsigned int col, unsigned int row, TextureImageHandle * img )
00331   {
00332     NVSG_TRACE();
00333     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00334     NVSG_ASSERT( img && ( col < m_maps.size() ) && ( row < m_maps[col].size() ) );
00335     img->addRef();
00336     m_maps[col].insert( m_maps[col].begin() + row, img );
00337     invalidateIncarnation();
00338   }
00339
00340   inline void MapMatrix::replaceMap( unsigned int col, unsigned int row, TextureImageHandle * img )
00341   {
00342     NVSG_TRACE();
00343     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00344     NVSG_ASSERT( img && ( col < m_maps.size() ) && ( row < m_maps[col].size() ) );
00345     if ( m_maps[col][row] != img )
00346     {
00347       img->addRef();
00348       m_maps[col][row]->removeRef();
00349       m_maps[col][row] = img;
00350       invalidateIncarnation();
00351     }
00352   }
00353
00354   inline void MapMatrix::removeMap( unsigned int col, unsigned int row )
00355   {
00356     NVSG_TRACE();
00357     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00358     NVSG_ASSERT( ( col < m_maps.size() ) && ( row < m_maps[col].size() ) );
00359     m_maps[col][row]->removeRef();
00360     m_maps[col].erase( m_maps[col].begin() + row );
00361     invalidateIncarnation();
00362   }
00363
00364   inline unsigned int MapMatrix::getNumberOfColumns( void ) const
00365   {
00366     NVSG_TRACE();
00367     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00368     NVSG_ASSERT( m_maps.size() <= UINT_MAX );
00369     return( static_cast<unsigned int>(m_maps.size() ));
00370   }
00371
00372   inline unsigned int MapMatrix::getNumberOfMaps( unsigned int col ) const
00373   {
00374     NVSG_TRACE();
00375     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00376     NVSG_ASSERT( col < m_maps.size() );
00377     NVSG_ASSERT( m_maps[col].size() <= UINT_MAX );
00378     return( static_cast<unsigned int>(m_maps[col].size()) );
00379   }
00380
00381   inline TextureImageHandle * MapMatrix::getMap( unsigned int col, unsigned int row ) const
00382   {
00383     NVSG_TRACE();
00384     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00385     NVSG_ASSERT( ( col < m_maps.size() ) && ( row < m_maps[col].size() ) );
00386     return( m_maps[col][row] );
00387   }
00388 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


MapObject.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.h"

Include dependency graph for MapObject.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:56 2008 for NVSGSDK by NVIDIA


MapObject.h Source File

MapObject.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Object.h"
00017
00018 namespace nvsg
00019 {
00025   typedef enum
00026   {
00027     MA_LOWER,
00028     MA_CENTER,
00029     MA_UPPER
00030   } MapAlignment;
00031
00037   typedef enum
00038   {
00039     MO_HORIZONTAL,
00040     MO_VERTICAL
00041   } MapOrientation;
00042
00048   typedef enum
00049   {
00050     MR_LOWER_LEFT,
00051     MR_LOWER_CENTER,
00052     MR_LOWER_RIGHT,
00053     MR_CENTER_LEFT,
00054     MR_CENTER,
00055     MR_CENTER_RIGHT,
00056     MR_UPPER_LEFT,
00057     MR_UPPER_CENTER,
00058     MR_UPPER_RIGHT
00059   } MapRelation;
00060
00068   typedef enum
00069   {
00070     MTD_LOW_TO_HIGH,
00071     MTD_HIGH_TO_LOW
00072   } MapTraversalDirection;
00073
00081   class MapObject : public Object
00082   {
00083     public:
00085       NVSG_API virtual ~MapObject(void);
00086
00095       NVSG_API void getPosition( int & x
00096                                , int & y ) const;
00097
00106       NVSG_API void setPosition( int x
00107                                , int y );
00108
00120       NVSG_API MapRelation getRelation( void ) const;
00121
00133       NVSG_API void setRelation( MapRelation relation );
00134
00147       NVSG_API void getLowerLeft( int & x
00148                                 , int & y ) const;
00149
00158       NVSG_API virtual void getSize( unsigned int & width
00159                                    , unsigned int & height ) const = 0;
00160
00166       NVSG_API virtual TextureImageHandle * pickMap( int x, int y ) const = 0;
00167
00168     protected:
00173       NVSG_API MapObject(void);
00174
00177       NVSG_API MapObject( const MapObject &rhs );
00178
00179     private:
00180       MapRelation m_relation; // relation of position
00181       int         m_x, m_y;   // raster position
00182   };
00183
00184   inline void MapObject::getPosition( int & x, int & y ) const
00185   {
00186     NVSG_TRACE();
00187     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00188     x = m_x;
00189     y = m_y;
00190   }
00191
00192   inline void MapObject::setPosition( int x, int y )
00193   {
00194     NVSG_TRACE();
00195     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00196     if ( ( m_x != x ) || ( m_y != y ) )
00197     {
00198       m_x = x;
00199       m_y = y;
00200       invalidateIncarnation();
00201     }
00202   }
00203
00204   inline MapRelation MapObject::getRelation( void ) const
00205   {
00206     NVSG_TRACE();
00207     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00208     return( m_relation );
00209   }
00210
00211   inline void MapObject::setRelation( MapRelation relation )
00212   {
00213     NVSG_TRACE();
00214     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00215     if ( m_relation != relation )
00216     {
00217       m_relation = relation;
00218       invalidateIncarnation();
00219     }
00220   }
00221
00222 #if ! defined( DOXYGEN_IGNORE )
00223   //  no need to document these tiny helpers
00224   inline bool pointInRect( int x, int y, int llx, int lly, unsigned int w, unsigned int h )
00225   {
00226     return( ( llx <= x ) && ( lly <= y ) && ( x <= (int)(llx+w) ) && ( y <= (int)(lly+h) ) );
00227   }
00228
00229   inline bool pointInInterval( int x, int l, unsigned int s )
00230   {
00231     return( ( l <= x ) && ( x <= (int)(l+s) ) );
00232   }
00233 #endif
00234
00235 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Material.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vecnt.h"
#include "nvsg/StateAttribute.h"

Include dependency graph for Material.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:56 2008 for NVSGSDK by NVIDIA


Material.h Source File

Material.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Vecnt.h"
00017 #include "nvsg/StateAttribute.h" // base class definition
00018
00019 namespace nvsg
00020 {
00021   class Material;
00022
00028   typedef enum
00029   {
00030     MF_FRONT = 0x01,
00031     MF_BACK  = 0x02,
00032     MF_FRONT_AND_BACK = MF_FRONT | MF_BACK
00033   } MaterialFace;
00034
00035 //  ignore private member class on documentation
00036 # if ! defined( DOXYGEN_IGNORE )
00037   class MaterialData : public nvutil::RCObject
00038   {
00039     friend class Material;
00040
00041     public:
00043
00045       NVSG_API MaterialData(const MaterialData& rhs);
00046
00047     private:
00048       // instantiation on stack is not permitted
00049       MaterialData();
00050       ~MaterialData();
00051       // assignment also not permitted
00052       MaterialData& operator=(const MaterialData& rhs) {}
00053
00054       nvmath::Vec3f m_backAmbientColor;
00055       nvmath::Vec3f m_backDiffuseColor;
00056       nvmath::Vec3f m_backEmissiveColor;
00057       float         m_backOpacity;
00058       nvmath::Vec3f m_backSpecularColor;
00059       float         m_backSpecularExponent;
00060
00061       nvmath::Vec3f m_frontAmbientColor;
00062       nvmath::Vec3f m_frontDiffuseColor;
00063       nvmath::Vec3f m_frontEmissiveColor;
00064       float         m_frontOpacity;
00065       nvmath::Vec3f m_frontSpecularColor;
00066       float         m_frontSpecularExponent;
00067   };
00068 #endif    //  DOXYGEN_IGNORE
00069
00082   class Material : public StateAttribute
00083   {
00084     public:
00086       NVSG_API Material();
00087
00089       NVSG_API explicit Material( const StateAttribute &rhs );
00090
00092       NVSG_API Material( const Material &rhs );
00093
00095       NVSG_API virtual ~Material();
00096
00105       NVSG_API virtual bool isDataShared() const;
00106
00114       NVSG_API virtual DataID getDataID() const;
00115
00127       NVSG_API const nvmath::Vec3f& getAmbientColor( MaterialFace mf = MF_FRONT ) const;
00128
00139       NVSG_API void setAmbientColor( const nvmath::Vec3f &ac
00140                                    , MaterialFace mf = MF_FRONT_AND_BACK );
00141
00157       NVSG_API const nvmath::Vec3f& getDiffuseColor( MaterialFace mf = MF_FRONT ) const;
00158
00173       NVSG_API void setDiffuseColor( const nvmath::Vec3f &dc
00174                                    , MaterialFace mf = MF_FRONT_AND_BACK );
00175
00191       NVSG_API const nvmath::Vec3f& getEmissiveColor( MaterialFace mf = MF_FRONT ) const;
00192
00207       NVSG_API void setEmissiveColor( const nvmath::Vec3f &ec
00208                                     , MaterialFace mf = MF_FRONT_AND_BACK );
00209
00221       NVSG_API float getOpacity( MaterialFace mf = MF_FRONT ) const;
00222
00233       NVSG_API void setOpacity( float o
00234                               , MaterialFace mf = MF_FRONT_AND_BACK );
00235
00248       NVSG_API const nvmath::Vec3f& getSpecularColor( MaterialFace mf = MF_FRONT ) const;
00249
00261       NVSG_API void setSpecularColor( const nvmath::Vec3f &sc
00262                                     , MaterialFace mf = MF_FRONT_AND_BACK );
00263
00276       NVSG_API float getSpecularExponent( MaterialFace mf = MF_FRONT ) const;
00277
00289       NVSG_API void setSpecularExponent( float se
00290                                        , MaterialFace mf = MF_FRONT_AND_BACK );
00291
00297       NVSG_API Material & operator=( const Material & rhs );
00298
00307       NVSG_API virtual bool isEquivalent( const Object * p
00308                                         , bool ignoreNames
00309                                         , bool deepCompare ) const;
00310
00311
00312   private:
00313       // helper performing the actual assignment
00314       // called inside setOpacity for different faces
00315       void assignOpacity(float& lhs, float rhs);
00316
00317   private:
00318       nvutil::RCPtr<MaterialData> m_material; // shareable material data
00319   };
00320
00321   inline const nvmath::Vec3f& Material::getAmbientColor( MaterialFace mf ) const
00322   {
00323     NVSG_TRACE();
00324     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00325     return( ( mf & MF_FRONT ) ? m_material->m_frontAmbientColor : m_material->m_backAmbientColor );
00326   }
00327
00328   inline const nvmath::Vec3f& Material::getDiffuseColor( MaterialFace mf ) const
00329   {
00330     NVSG_TRACE();
00331     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00332     return( ( mf & MF_FRONT ) ? m_material->m_frontDiffuseColor : m_material->m_backDiffuseColor );
00333   }
00334
00335   inline const nvmath::Vec3f& Material::getEmissiveColor( MaterialFace mf ) const
00336   {
00337     NVSG_TRACE();
00338     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00339     return( ( mf & MF_FRONT ) ? m_material->m_frontEmissiveColor : m_material->m_backEmissiveColor );
00340   }
00341
00342   inline float Material::getOpacity( MaterialFace mf ) const
00343   {
00344     NVSG_TRACE();
00345     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00346     return( ( mf & MF_FRONT ) ? m_material->m_frontOpacity : m_material->m_backOpacity );
00347   }
00348
00349   inline const nvmath::Vec3f& Material::getSpecularColor( MaterialFace mf ) const
00350   {
00351     NVSG_TRACE();
00352     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00353     return( ( mf & MF_FRONT ) ? m_material->m_frontSpecularColor : m_material->m_backSpecularColor );
00354   }
00355
00356   inline float Material::getSpecularExponent( MaterialFace mf ) const
00357   {
00358     NVSG_TRACE();
00359     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00360     return( ( mf & MF_FRONT ) ? m_material->m_frontSpecularExponent : m_material->m_backSpecularExponent );
00361   }
00362
00363 } //  namespace nvsg
00364
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Matnnt.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Quatt.h"
#include "nvmath/Vecnt.h"

Include dependency graph for Matnnt.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvmath

Detailed Description

Generated on Tue Jan 15 10:27:57 2008 for NVSGSDK by NVIDIA


Matnnt.h Source File

Matnnt.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Quatt.h"
00017 #include "nvmath/Vecnt.h"
00018
00019 namespace nvmath
00020 {
00021   template<typename T> class Quatt;
00022
00027   template<unsigned int n, typename T> class Matnnt
00028   {
00029     public:
00032       Matnnt();
00033
00040       template<unsigned int m, typename S>
00041         explicit Matnnt( const Matnnt<m,S> & rhs );
00042
00058       Matnnt( T m00, T m01, T m02
00059             , T m10, T m11, T m12
00060             , T m20, T m21, T m22 );
00061
00071       Matnnt( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1, const Vecnt<n,T> & v2 );
00072
00098       Matnnt( T m00, T m01, T m02, T m03
00099             , T m10, T m11, T m12, T m13
00100             , T m20, T m21, T m22, T m23
00101             , T m30, T m31, T m32, T m33 );
00102
00116       Matnnt( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1, const Vecnt<n,T> & v2, const Vecnt<n,T> & v3 );
00117
00127       Matnnt( const Vecnt<n,T> & axis, T angle );
00128
00133       explicit Matnnt( const Quatt<T> & ori );
00134
00139       Matnnt( const Quatt<T> & ori, const Vecnt<n-1,T> & trans );
00140
00147       Matnnt( const Quatt<T> & ori, const Vecnt<n-1,T> & trans, const Vecnt<n-1,T> & scale );
00148
00149     public:
00158       const T * getPtr() const;
00159
00163       bool invert();
00164
00168       template<typename S>
00169         Vecnt<n,T> & operator[]( S i );
00170
00174       template<typename S>
00175         const Vecnt<n,T> & operator[]( S i ) const;
00176
00183       template<typename S>
00184         Matnnt<n,T> & operator+=( const Matnnt<n,S> & m );
00185
00192       template<typename S>
00193         Matnnt<n,T> & operator-=( const Matnnt<n,S> & m );
00194
00200       template<typename S>
00201         Matnnt<n,T> & operator*=( S s );
00202
00208       Matnnt<n,T> & operator*=( const Matnnt<n,T> & m );
00209
00216       template<typename S>
00217         Matnnt<n,T> & operator/=( S s );
00218
00219     private:
00220       Vecnt<n,T>  m_mat[n];
00221   };
00222
00223
00224   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00225   // non-member functions
00226   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00227
00236   template<unsigned int n, typename T>
00237     bool isIdentity( const Matnnt<n,T> & m, T eps = std::numeric_limits<T>::epsilon() )
00238   {
00239     bool identity = true;
00240     for ( unsigned int i=0 ; identity && i<n ; ++i )
00241     {
00242       for ( unsigned int j=0 ; identity && j<i ; ++j )
00243       {
00244         identity = ( abs( m[i][j] ) <= eps );
00245       }
00246       if ( identity )
00247       {
00248         identity = ( abs( m[i][i] - 1 ) <= eps );
00249       }
00250       for ( unsigned int j=i+1 ; identity && j<n ; ++j )
00251       {
00252         identity = ( abs( m[i][j] ) <= eps );
00253       }
00254     }
00255     return( identity );
00256   }
00257
00264   template<unsigned int n, typename T>
00265     bool isNormalized( const Matnnt<n,T> & m, T eps = std::numeric_limits<T>::epsilon() )
00266   {
00267     bool normalized = true;
00268     for ( unsigned int i=0 ; normalized && i<n ; ++i )
00269     {
00270       normalized = isNormalized( m[i], eps );
00271     }
00272     for ( unsigned int i=0 ; normalized && i<n ; ++i )
00273     {
00274       Vecnt<n,T> v;
00275       for ( unsigned int j=0 ; j<n ; j++ )
00276       {
00277         v[j] = m[j][i];
00278       }
00279       normalized = isNormalized( v, eps );
00280     }
00281     return( normalized );
00282   }
00283
00290   template<unsigned int n, typename T>
00291     bool isNull( const Matnnt<n,T> & m, T eps = std::numeric_limits<T>::epsilon() )
00292   {
00293     bool null = true;
00294     for ( unsigned int i=0 ; null && i<n ; ++i )
00295     {
00296       null = isNull( m[i], eps );
00297     }
00298     return( null );
00299   }
00300
00308   template<unsigned int n, typename T>
00309     bool isOrthogonal( const Matnnt<n,T> & m, T eps = std::numeric_limits<T>::epsilon() )
00310   {
00311     bool orthogonal = true;
00312     for ( unsigned int i=0 ; orthogonal && i+1<n ; ++i )
00313     {
00314       for ( unsigned int j=i+1 ; orthogonal && j<n ; ++j )
00315       {
00316         orthogonal = areOrthogonal( m[i], m[j], eps );
00317       }
00318     }
00319     if ( orthogonal )
00320     {
00321       Matnnt<n,T> tm = ~m;
00322       for ( unsigned int i=0 ; orthogonal && i+1<n ; ++i )
00323       {
00324         for ( unsigned int j=i+1 ; orthogonal && j<n ; ++j )
00325         {
00326           orthogonal = areOrthogonal( tm[i], tm[j], eps );
00327         }
00328       }
00329     }
00330     return( orthogonal );
00331   }
00332
00337   template<unsigned int n, typename T>
00338     T maxElement( const Matnnt<n,T> & m );
00339
00344   template<unsigned int n, typename T>
00345     T minElement( const Matnnt<n,T> & m );
00346
00353   template<unsigned int n, typename T>
00354     bool operator==( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 );
00355
00362   template<unsigned int n, typename T>
00363     bool operator!=( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 );
00364
00368   template<unsigned int n, typename T>
00369     Matnnt<n,T> operator~( const Matnnt<n,T> & m );
00370
00375   template<unsigned int n, typename T>
00376     Matnnt<n,T> operator+( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 );
00377
00381   template<unsigned int n, typename T>
00382     Matnnt<n,T> operator-( const Matnnt<n,T> & m );
00383
00388   template<unsigned int n, typename T>
00389     Matnnt<n,T> operator-( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 );
00390
00395   template<unsigned int n, typename T>
00396     Matnnt<n,T> operator*( const Matnnt<n,T> & m, T s );
00397
00402   template<unsigned int n, typename T>
00403     Matnnt<n,T> operator*( T s, const Matnnt<n,T> & m );
00404
00409   template<unsigned int n, typename T>
00410     Vecnt<n,T> operator*( const Matnnt<n,T> & m, const Vecnt<n,T> & v );
00411
00416   template<unsigned int n, typename T>
00417     Vecnt<n,T> operator*( const Vecnt<n,T> & v, const Matnnt<n,T> & m );
00418
00423   template<unsigned int n, typename T>
00424     Matnnt<n,T> operator*( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 );
00425
00430   template<unsigned int n, typename T>
00431     Matnnt<n,T> operator/( const Matnnt<n,T> & m, T s );
00432
00436   template<unsigned int n, typename T>
00437     void setIdentity( Matnnt<n,T> & m );
00438
00439
00440   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00441   // non-member functions, specialized for n == 3
00442   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00443
00447   template<typename T>
00448     T determinant( const Matnnt<3,T> & m );
00449
00457   template<typename T>
00458     bool isRotation( const Matnnt<3,T> & m, T eps = 9 * std::numeric_limits<T>::epsilon() )
00459   {
00460     return(   isNormalized( m, eps )
00461           &&  isOrthogonal( m, eps )
00462           && ( abs( determinant( m ) - 1 ) <= eps ) );
00463   }
00464
00477   template<typename T>
00478     Matnnt<3,T> & setMat( Matnnt<3,T> & m, T m00, T m01, T m02
00479                                          , T m10, T m11, T m12
00480                                          , T m20, T m21, T m22 );
00481
00488   template<typename T>
00489     Matnnt<3,T> & setMat( Matnnt<3,T> & m, const Vecnt<3,T> & v0
00490                                          , const Vecnt<3,T> & v1
00491                                          , const Vecnt<3,T> & v2 );
00492
00499   template<typename T>
00500     Matnnt<3,T> & setMat( Matnnt<3,T> & m, const Quatt<T> & q );
00501
00509   template<typename T>
00510     Matnnt<3,T> & setMat( Matnnt<3,T> & m, const Vecnt<3,T> & axis, T angle );
00511
00512
00513   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00514   // non-member functions, specialized for n == 3, T == float
00515   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00516
00524   NVSG_API void decompose( const Matnnt<3,float> &m, Quatt<float> &orientation
00525                          , Vecnt<3,float> &scaling, Quatt<float> &scaleOrientation );
00526
00527
00528   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00529   // non-member functions, specialized for n == 4
00530   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00531
00551   template<typename T>
00552     Matnnt<4,T> & setMat( Matnnt<4,T> & m, T m00, T m01, T m02, T m03
00553                                          , T m10, T m11, T m12, T m13
00554                                          , T m20, T m21, T m22, T m23
00555                                          , T m30, T m31, T m32, T m33 );
00556
00564   template<typename T>
00565     Matnnt<4,T> & setMat( Matnnt<4,T> & m, const Vecnt<4,T> & v0
00566                                          , const Vecnt<4,T> & v1
00567                                          , const Vecnt<4,T> & v2
00568                                          , const Vecnt<4,T> & v3 );
00569
00578   template<typename T>
00579     Matnnt<4,T> & setMat( Matnnt<4,T> & m, const Quatt<T> & ori
00580                                          , const Vecnt<3,T> & trans = Vecnt<3,T>(0,0,0)
00581                                          , const Vecnt<3,T> & scale = Vecnt<3,T>(1,1,1) )
00582   {
00583     Matnnt<3,T>  m3( ori );
00584     m[0] = Vecnt<4,T>( scale[0] * m3[0], 0 );
00585     m[1] = Vecnt<4,T>( scale[1] * m3[1], 0 );
00586     m[2] = Vecnt<4,T>( scale[2] * m3[2], 0 );
00587     m[3] = Vecnt<4,T>( trans, 1 );
00588     return( m );
00589   }
00590
00591
00592   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00593   // non-member functions, specialized for n == 4, T == float
00594   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00595
00604   NVSG_API void decompose( const Matnnt<4,float> &m, Vecnt<3,float> &translation
00605                          , Quatt<float> &orientation, Vecnt<3,float> &scaling
00606                          , Quatt<float> &scaleOrientation );
00607
00608
00609   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00610   // Convenience type definitions
00611   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00612   typedef Matnnt<3,float>   Mat33f;
00613   typedef Matnnt<3,double>  Mat33d;
00614   typedef Matnnt<4,float>   Mat44f;
00615   typedef Matnnt<4,double>  Mat44d;
00616
00617
00618   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00619   // inlined member functions
00620   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00621
00622   template<unsigned int n, typename T>
00623   inline Matnnt<n,T>::Matnnt()
00624   {
00625   }
00626
00627   template<unsigned int n, typename T>
00628   inline Matnnt<n,T>::Matnnt( T m00, T m01, T m02
00629                             , T m10, T m11, T m12
00630                             , T m20, T m21, T m22 )
00631   {
00632     setMat( *this, m00, m01, m02
00633                  , m10, m11, m12
00634                  , m20, m21, m22 );
00635   }
00636
00637   template<unsigned int n, typename T>
00638   inline Matnnt<n,T>::Matnnt( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1, const Vecnt<n,T> & v2 )
00639   {
00640     setMat( *this, v0, v1, v2 );
00641   }
00642
00643   template<unsigned int n, typename T>
00644   inline Matnnt<n,T>::Matnnt( T m00, T m01, T m02, T m03
00645                             , T m10, T m11, T m12, T m13
00646                             , T m20, T m21, T m22, T m23
00647                             , T m30, T m31, T m32, T m33 )
00648   {
00649     setMat( *this, m00, m01, m02, m03
00650                  , m10, m11, m12, m13
00651                  , m20, m21, m22, m23
00652                  , m30, m31, m32, m33 );
00653   }
00654
00655   template<unsigned int n, typename T>
00656   template<unsigned int m, typename S>
00657   inline Matnnt<n,T>::Matnnt( const Matnnt<m,S> & rhs )
00658   {
00659     for ( unsigned int i=0 ; i<std::min( n, m ) ; ++i )
00660     {
00661       m_mat[i] = Vecnt<n,T>(rhs[i]);
00662     }
00663   }
00664
00665   template<unsigned int n, typename T>
00666   inline Matnnt<n,T>::Matnnt( const Vecnt<n,T> & v0
00667                             , const Vecnt<n,T> & v1
00668                             , const Vecnt<n,T> & v2
00669                             , const Vecnt<n,T> & v3 )
00670   {
00671     setMat( *this, v0, v1, v2, v3 );
00672   }
00673
00674   template<unsigned int n, typename T>
00675   inline Matnnt<n,T>::Matnnt( const Vecnt<n,T> & axis, T angle )
00676   {
00677     setMat( *this, axis, angle );
00678   }
00679
00680   template<unsigned int n, typename T>
00681   inline Matnnt<n,T>::Matnnt( const Quatt<T> & ori )
00682   {
00683     setMat( *this, ori );
00684   }
00685
00686   template<unsigned int n, typename T>
00687   inline Matnnt<n,T>::Matnnt( const Quatt<T> & ori, const Vecnt<n-1,T> & trans )
00688   {
00689     setMat( *this, ori, trans );
00690   }
00691
00692   template<unsigned int n, typename T>
00693   inline Matnnt<n,T>::Matnnt( const Quatt<T> & ori, const Vecnt<n-1,T> & trans, const Vecnt<n-1,T> & scale )
00694   {
00695     setMat( *this, ori, trans, scale );
00696   }
00697
00698   template<unsigned int n, typename T>
00699   inline const T * Matnnt<n,T>::getPtr() const
00700   {
00701     return( m_mat[0].getPtr() );
00702   }
00703
00704   template<unsigned int n, typename T>
00705   bool Matnnt<n,T>::invert()
00706   {
00707     unsigned int p[n];
00708
00709     bool ok = true;
00710     for ( unsigned int k=0 ; ok && k<n ; ++k )
00711     {
00712       T max(0);
00713       p[k] = 0;
00714       for ( unsigned int i=k ; ok && i<n ; ++i )
00715       {
00716         T s(0);
00717         for ( unsigned int j=k ; j<n ; ++j )
00718         {
00719           s += abs( m_mat[i][j] );
00720         }
00721         ok = ( std::numeric_limits<T>::epsilon() < abs(s) );
00722         if ( ok )
00723         {
00724           T q = abs( m_mat[i][k] ) / s;
00725           if ( q > max )
00726           {
00727             max = q;
00728             p[k] = i;
00729           }
00730         }
00731       }
00732
00733       ok = ( std::numeric_limits<T>::epsilon() < max );
00734       if ( ok )
00735       {
00736         if ( p[k] != k )
00737         {
00738           for ( unsigned int j=0 ; j<n ; ++j )
00739           {
00740             std::swap( m_mat[k][j], m_mat[p[k]][j] );
00741           }
00742         }
00743
00744         T pivot = m_mat[k][k];
00745         ok = ( std::numeric_limits<T>::epsilon() < abs( pivot ) );
00746         if ( ok )
00747         {
00748           for ( unsigned int j=0 ; j<n ; ++j )
00749           {
00750             if ( j != k )
00751             {
00752               m_mat[k][j] /= - pivot;
00753               for ( unsigned int i=0 ; i<n ; ++i )
00754               {
00755                 if ( i != k )
00756                 {
00757                   m_mat[i][j] += m_mat[i][k] * m_mat[k][j];
00758                 }
00759               }
00760             }
00761           }
00762
00763           for ( unsigned int i=0 ; i<n ; ++i )
00764           {
00765             m_mat[i][k] /= pivot;
00766           }
00767           m_mat[k][k] = 1.0f / pivot;
00768         }
00769       }
00770     }
00771
00772     if ( ok )
00773     {
00774       for ( unsigned int k=n-2 ; k<n ; --k )  //  NOTE: ( unsigned int k < n ) <=> ( int k >= 0 )
00775       {
00776         if ( p[k] != k )
00777         {
00778           for ( unsigned int i=0 ; i<n ; ++i )
00779           {
00780             std::swap( m_mat[i][k], m_mat[i][p[k]] );
00781           }
00782         }
00783       }
00784     }
00785
00786     return( ok );
00787   }
00788
00789   template<unsigned int n, typename T>
00790   template<typename S>
00791   inline Vecnt<n,T> & Matnnt<n,T>::operator[]( S i )
00792   {
00793     NVSG_CTASSERT( std::numeric_limits<S>::is_integer );
00794     NVSG_ASSERT( i < n );
00795     return( m_mat[i] );
00796   }
00797
00798   template<unsigned int n, typename T>
00799   template<typename S>
00800   inline const Vecnt<n,T> & Matnnt<n,T>::operator[]( S i ) const
00801   {
00802     NVSG_CTASSERT( std::numeric_limits<S>::is_integer );
00803     NVSG_ASSERT( i < n );
00804     return( m_mat[i] );
00805   }
00806
00807   template<unsigned int n, typename T>
00808   template<typename S>
00809   inline Matnnt<n,T> & Matnnt<n,T>::operator+=( const Matnnt<n,S> & rhs )
00810   {
00811     for ( unsigned int i=0 ; i<n ; ++i )
00812     {
00813       m_mat[i] += rhs[i];
00814     }
00815     return( *this );
00816   }
00817
00818   template<unsigned int n, typename T>
00819   template<typename S>
00820   inline Matnnt<n,T> & Matnnt<n,T>::operator-=( const Matnnt<n,S> & rhs )
00821   {
00822     for ( unsigned int i=0 ; i<n ; ++i )
00823     {
00824       m_mat[i] -= rhs[i];
00825     }
00826     return( *this );
00827   }
00828
00829   template<unsigned int n, typename T>
00830   template<typename S>
00831   inline Matnnt<n,T> & Matnnt<n,T>::operator*=( S s )
00832   {
00833     for ( unsigned int i=0 ; i<n ; ++i )
00834     {
00835       m_mat[i] *= s;
00836     }
00837     return( *this );
00838   }
00839
00840   template<unsigned int n, typename T>
00841   inline Matnnt<n,T> & Matnnt<n,T>::operator*=( const Matnnt<n,T> & rhs )
00842   {
00843     *this = *this * rhs;
00844     return( *this );
00845   }
00846
00847   template<unsigned int n, typename T>
00848   template<typename S>
00849   inline Matnnt<n,T> & Matnnt<n,T>::operator/=( S s )
00850   {
00851     for ( unsigned int i=0 ; i<n ; ++i )
00852     {
00853       m_mat[i] /= s;
00854     }
00855     return( *this );
00856   }
00857
00858
00859   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00860   // inlined non-member functions
00861   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00862   template<unsigned int n, typename T>
00863   inline T maxElement( const Matnnt<n,T> & m )
00864   {
00865     T me = maxElement( m[0] );
00866     for ( unsigned int i=1 ; i<n ; ++i )
00867     {
00868       T t = maxElement( m[i] );
00869       if ( me < t )
00870       {
00871         me = t;
00872       }
00873     }
00874     return( me );
00875   }
00876
00877   template<unsigned int n, typename T>
00878   inline T minElement( const Matnnt<n,T> & m )
00879   {
00880     T me = minElement( m[0] );
00881     for ( unsigned int i=1 ; i<n ; ++i )
00882     {
00883       T t = minElement( m[i] );
00884       if ( t < me )
00885       {
00886         me = t;
00887       }
00888     }
00889     return( me );
00890   }
00891
00892   template<unsigned int n, typename T>
00893   inline bool operator==( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 )
00894   {
00895     bool eq = true;
00896     for ( unsigned int i=0 ; i<n && eq ; ++i )
00897     {
00898       eq = ( m0[i] == m1[i] );
00899     }
00900     return( eq );
00901   }
00902
00903   template<unsigned int n, typename T>
00904   inline bool operator!=( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 )
00905   {
00906     return( ! ( m0 == m1 ) );
00907   }
00908
00909   template<unsigned int n, typename T>
00910   inline Matnnt<n,T> operator~( const Matnnt<n,T> & m )
00911   {
00912     Matnnt<n,T> ret;
00913     for ( unsigned int i=0 ; i<n ; ++i )
00914     {
00915       for ( unsigned int j=0 ; j<n ; ++j )
00916       {
00917         ret[i][j] = m[j][i];
00918       }
00919     }
00920     return( ret );
00921   }
00922
00923   template<unsigned int n, typename T>
00924   inline Matnnt<n,T> operator+( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 )
00925   {
00926     Matnnt<n,T> ret(m0);
00927     ret += m1;
00928     return( ret );
00929   }
00930
00931   template<unsigned int n, typename T>
00932   inline Matnnt<n,T> operator-( const Matnnt<n,T> & m )
00933   {
00934     Matnnt<n,T> ret;
00935     for ( unsigned int i=0 ; i<n ; ++i )
00936     {
00937       ret[i] = -m[i];
00938     }
00939     return( ret );
00940   }
00941
00942   template<unsigned int n, typename T>
00943   inline Matnnt<n,T> operator-( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 )
00944   {
00945     Matnnt<n,T> ret(m0);
00946     ret -= m1;
00947     return( ret );
00948   }
00949
00950   template<unsigned int n, typename T>
00951   inline Matnnt<n,T> operator*( const Matnnt<n,T> & m, T s )
00952   {
00953     Matnnt<n,T> ret(m);
00954     ret *= s;
00955     return( ret );
00956   }
00957
00958   template<unsigned int n, typename T>
00959   inline Matnnt<n,T> operator*( T s, const Matnnt<n,T> & m )
00960   {
00961     return( m * s );
00962   }
00963
00964   template<unsigned int n, typename T>
00965   inline Vecnt<n,T> operator*( const Matnnt<n,T> & m, const Vecnt<n,T> & v )
00966   {
00967     Vecnt<n,T> ret;
00968     for ( unsigned int i=0 ; i<n ; ++i )
00969     {
00970       ret[i] = m[i] * v;
00971     }
00972     return( ret );
00973   }
00974
00975   template<unsigned int n, typename T>
00976   inline Vecnt<n,T> operator*( const Vecnt<n,T> & v, const Matnnt<n,T> & m )
00977   {
00978     Vecnt<n,T> ret;
00979     for ( unsigned int i=0 ; i<n ; ++i )
00980     {
00981       ret[i] = 0;
00982       for ( unsigned int j=0 ; j<n ; ++j )
00983       {
00984         ret[i] += v[j] * m[j][i];
00985       }
00986     }
00987     return( ret );
00988   }
00989
00990   template<unsigned int n, typename T>
00991   inline Matnnt<n,T> operator*( const Matnnt<n,T> & m0, const Matnnt<n,T> & m1 )
00992   {
00993     Matnnt<n,T> ret;
00994     for ( unsigned int i=0 ; i<n ; ++i )
00995     {
00996       for ( unsigned int j=0 ; j<n ; ++j )
00997       {
00998         ret[i][j] = 0;
00999         for ( unsigned int k=0 ; k<n ; ++k )
01000         {
01001           ret[i][j] += m0[i][k] * m1[k][j];
01002         }
01003       }
01004     }
01005     return( ret );
01006   }
01007
01008   template<>
01009   inline Matnnt<4, float> operator*(const Matnnt<4,float> & m0, const Matnnt<4,float> & m1)
01010   {
01011     return Matnnt<4,float> (
01012       m0[0][0]*m1[0][0] + m0[0][1]*m1[1][0] + m0[0][2]*m1[2][0] + m0[0][3]*m1[3][0],
01013       m0[0][0]*m1[0][1] + m0[0][1]*m1[1][1] + m0[0][2]*m1[2][1] + m0[0][3]*m1[3][1],
01014       m0[0][0]*m1[0][2] + m0[0][1]*m1[1][2] + m0[0][2]*m1[2][2] + m0[0][3]*m1[3][2],
01015       m0[0][0]*m1[0][3] + m0[0][1]*m1[1][3] + m0[0][2]*m1[2][3] + m0[0][3]*m1[3][3],
01016
01017       m0[1][0]*m1[0][0] + m0[1][1]*m1[1][0] + m0[1][2]*m1[2][0] + m0[1][3]*m1[3][0],
01018       m0[1][0]*m1[0][1] + m0[1][1]*m1[1][1] + m0[1][2]*m1[2][1] + m0[1][3]*m1[3][1],
01019       m0[1][0]*m1[0][2] + m0[1][1]*m1[1][2] + m0[1][2]*m1[2][2] + m0[1][3]*m1[3][2],
01020       m0[1][0]*m1[0][3] + m0[1][1]*m1[1][3] + m0[1][2]*m1[2][3] + m0[1][3]*m1[3][3],
01021
01022       m0[2][0]*m1[0][0] + m0[2][1]*m1[1][0] + m0[2][2]*m1[2][0] + m0[2][3]*m1[3][0],
01023       m0[2][0]*m1[0][1] + m0[2][1]*m1[1][1] + m0[2][2]*m1[2][1] + m0[2][3]*m1[3][1],
01024       m0[2][0]*m1[0][2] + m0[2][1]*m1[1][2] + m0[2][2]*m1[2][2] + m0[2][3]*m1[3][2],
01025       m0[2][0]*m1[0][3] + m0[2][1]*m1[1][3] + m0[2][2]*m1[2][3] + m0[2][3]*m1[3][3],
01026
01027       m0[3][0]*m1[0][0] + m0[3][1]*m1[1][0] + m0[3][2]*m1[2][0] + m0[3][3]*m1[3][0],
01028       m0[3][0]*m1[0][1] + m0[3][1]*m1[1][1] + m0[3][2]*m1[2][1] + m0[3][3]*m1[3][1],
01029       m0[3][0]*m1[0][2] + m0[3][1]*m1[1][2] + m0[3][2]*m1[2][2] + m0[3][3]*m1[3][2],
01030       m0[3][0]*m1[0][3] + m0[3][1]*m1[1][3] + m0[3][2]*m1[2][3] + m0[3][3]*m1[3][3]
01031     );
01032   }
01033
01034   template<unsigned int n, typename T>
01035   inline Matnnt<n,T> operator/( const Matnnt<n,T> & m, T s )
01036   {
01037     Matnnt<n,T> ret(m);
01038     ret /= s;
01039     return( ret );
01040   }
01041
01042   template<unsigned int n, typename T>
01043   void setIdentity( Matnnt<n,T> & m )
01044   {
01045     for ( unsigned int i=0 ; i<n ; ++i )
01046     {
01047       for ( unsigned int j=0 ; j<i ; ++j )
01048       {
01049         m[i][j] = T(0);
01050       }
01051       m[i][i] = T(1);
01052       for ( unsigned int j=i+1 ; j<n ; ++j )
01053       {
01054         m[i][j] = T(0);
01055       }
01056     }
01057   }
01058
01059
01060   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
01061   // inlined non-member functions, specialized for n == 3
01062   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
01063   template<typename T>
01064   inline T determinant( const Matnnt<3,T> & m )
01065   {
01066     return( m[0] * ( m[1] ^ m[2] ) );
01067   }
01068
01069   template<typename T>
01070   inline Matnnt<3,T> & setMat( Matnnt<3,T> & m, T m00, T m01, T m02
01071                                               , T m10, T m11, T m12
01072                                               , T m20, T m21, T m22 )
01073   {
01074     m[0][0] = m00;  m[0][1] = m01;  m[0][2] = m02;
01075     m[1][0] = m10;  m[1][1] = m11;  m[1][2] = m12;
01076     m[2][0] = m20;  m[2][1] = m21;  m[2][2] = m22;
01077     return( m );
01078   }
01079
01080   template<typename T>
01081   inline Matnnt<3,T> & setMat( Matnnt<3,T> & m, const Vecnt<3,T> & v0
01082                                               , const Vecnt<3,T> & v1
01083                                               , const Vecnt<3,T> & v2 )
01084   {
01085     m[0] = v0;  m[1] = v1;  m[2] = v2;
01086     return( m );
01087   }
01088
01089   template<typename T>
01090   Matnnt<3,T> & setMat( Matnnt<3,T> & m, const Vecnt<3,T> & axis, T angle )
01091   {
01092     NVSG_PRIVATE_ASSERT( isNormalized( axis ) );
01093     T c = cos( angle );
01094     T s = sin( angle );
01095     NVSG_PRIVATE_ASSERT( abs( s * s + c * c - 1 ) <= std::numeric_limits<T>::epsilon() );
01096     T t = 1 - c;
01097     T x = axis[0];
01098     T y = axis[1];
01099     T z = axis[2];
01100
01101     m[0] = Vecnt<3,T>( t * x * x + c,     t * x * y + s * z, t * x * z - s * y );
01102     m[1] = Vecnt<3,T>( t * x * y - s * z, t * y * y + c,     t * y * z + s * x );
01103     m[2] = Vecnt<3,T>( t * x * z + s * y, t * y * z - s * x, t * z * z + c     );
01104
01105     NVSG_PRIVATE_ASSERT( isRotation( m ) );
01106     return( m );
01107   }
01108
01109   template<typename T>
01110   inline Matnnt<3,T> & setMat( Matnnt<3,T> & m, const Quatt<T> & q )
01111   {
01112     NVSG_PRIVATE_ASSERT( isNormalized( q ) );
01113
01114     T x = q[0];
01115     T y = q[1];
01116     T z = q[2];
01117     T w = q[3];
01118
01119     m[0] = Vecnt<3,T>( 1 - 2 * ( y * y + z * z ), 2 * ( x * y + z * w ),     2 * ( x * z - y * w )     );
01120     m[1] = Vecnt<3,T>( 2 * ( x * y - z * w ),     1 - 2 * ( x * x + z * z ), 2 * ( y * z + x * w )     );
01121     m[2] = Vecnt<3,T>( 2 * ( x * z + y * w ),     2 * ( y * z - x * w ),     1 - 2 * ( x * x + y * y ) );
01122
01123     NVSG_PRIVATE_ASSERT( isRotation( m ) );
01124     return( m );
01125   }
01126
01127
01128   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
01129   // inlined non-member functions, specialized for n == 4
01130   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
01131   template<typename T>
01132   inline Matnnt<4,T> & setMat( Matnnt<4,T> & m, T m00, T m01, T m02, T m03
01133                                               , T m10, T m11, T m12, T m13
01134                                               , T m20, T m21, T m22, T m23
01135                                               , T m30, T m31, T m32, T m33 )
01136   {
01137     m[0][0] = m00;  m[0][1] = m01;  m[0][2] = m02;  m[0][3] = m03;
01138     m[1][0] = m10;  m[1][1] = m11;  m[1][2] = m12;  m[1][3] = m13;
01139     m[2][0] = m20;  m[2][1] = m21;  m[2][2] = m22;  m[2][3] = m23;
01140     m[3][0] = m30;  m[3][1] = m31;  m[3][2] = m32;  m[3][3] = m33;
01141     return( m );
01142   }
01143
01144   template<typename T>
01145   inline Matnnt<4,T> & setMat( Matnnt<4,T> & m, const Vecnt<4,T> & v0
01146                                               , const Vecnt<4,T> & v1
01147                                               , const Vecnt<4,T> & v2
01148                                               , const Vecnt<4,T> & v3 )
01149   {
01150     m[0] = v0;  m[1] = v1;  m[2] = v2;  m[3] = v3;
01151     return( m );
01152   }
01153
01154   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
01155   // inlined non-member functions, specialized for n == 4, T == float
01156   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
01157   inline void decompose( const Matnnt<4,float> &m, Vecnt<3,float> &translation
01158                        , Quatt<float> &orientation, Vecnt<3,float> &scaling
01159                        , Quatt<float> &scaleOrientation )
01160   {
01161     translation = Vecnt<3,float>( m[3] );
01162     Matnnt<3,float> m33( m );
01163     decompose( m33, orientation, scaling, scaleOrientation );
01164   }
01165
01166
01167
01169   extern NVSG_API const Mat44f  cIdentity44f;
01170
01171 } // namespace nvmath
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


MeshedPrimitiveSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/PrimitiveSet.h"

Include dependency graph for MeshedPrimitiveSet.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:57 2008 for NVSGSDK by NVIDIA


MeshedPrimitiveSet.h Source File

MeshedPrimitiveSet.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2004
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/nvsg.h"
00017 #include "nvsg/PrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00024   class IndexMesh : public IndexSet
00025   {
00026     public:
00027       IndexMesh( void );
00028       IndexMesh( unsigned int width, unsigned int height );
00029       unsigned int getWidth( void ) const;
00030       unsigned int getHeight( void ) const;
00031       void setDimensions( unsigned int width, unsigned int height );
00032
00033     private :
00034       unsigned int  m_width;
00035       unsigned int  m_height;
00036   };
00037
00045   class MeshedPrimitiveSet : public PrimitiveSet
00046   {
00047     public:
00049       NVSG_API MeshedPrimitiveSet();
00050
00055       NVSG_API virtual ~MeshedPrimitiveSet();
00056
00066       NVSG_API virtual bool isDataShared() const;
00067
00075       NVSG_API virtual DataID getDataID() const;
00076
00080       NVSG_API bool hasMeshes()  const;
00081
00085       NVSG_API unsigned int getNumberOfMeshes() const;
00086
00090       NVSG_API const IndexMesh * getMeshes() const;
00091
00099       NVSG_API void setMeshes( const IndexMesh * meshes, unsigned int numMeshes );
00100
00117       NVSG_API void setMeshes( unsigned int pos, const IndexMesh * meshes, unsigned int numMeshes );
00118
00128       NVSG_API virtual bool isEquivalent( const Object * p
00129                                         , bool ignoreNames
00130                                         , bool deepCompare ) const;
00131
00132     protected:
00138       NVSG_API MeshedPrimitiveSet( const MeshedPrimitiveSet& rhs );
00139
00144       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00145
00150       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00151
00157       NVSG_API MeshedPrimitiveSet & operator=(const MeshedPrimitiveSet & rhs);
00158
00159     private:
00160       nvutil::RCPtr<nvutil::RCVector<IndexMesh> > m_meshes;
00161   };
00162
00163
00164   // - - - - - - - - - - - - - - - - - - - - - - - - -
00165   // inlines
00166   // - - - - - - - - - - - - - - - - - - - - - - - - -
00167
00168   inline bool MeshedPrimitiveSet::hasMeshes()  const
00169   {
00170     NVSG_TRACE();
00171     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00172     return( !m_meshes->empty() );
00173   }
00174
00175   inline unsigned int MeshedPrimitiveSet::getNumberOfMeshes()  const
00176   {
00177     NVSG_TRACE();
00178     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00179     NVSG_ASSERT( m_meshes->size() <= UINT_MAX );
00180     return( static_cast<unsigned int>(m_meshes->size()) );
00181   }
00182
00183   inline const IndexMesh * MeshedPrimitiveSet::getMeshes() const
00184   {
00185     NVSG_TRACE();
00186     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00187     return( &(*m_meshes)[0] );
00188   }
00189   inline IndexMesh::IndexMesh( void )
00190     : m_width(0)
00191     , m_height(0)
00192   {
00193   }
00194
00195   inline IndexMesh::IndexMesh( unsigned int width, unsigned int height )
00196     : std::vector<unsigned int>(width*height)
00197     , m_width(width)
00198     , m_height(height)
00199   {
00200   }
00201
00202   inline unsigned int IndexMesh::getWidth( void ) const
00203   {
00204     return( m_width );
00205   }
00206
00207   inline void IndexMesh::setDimensions( unsigned int width, unsigned int height )
00208   {
00209     m_width = width;
00210     m_height = height;
00211     resize( m_width * m_height );
00212   }
00213
00214   inline unsigned int IndexMesh::getHeight( void ) const
00215   {
00216     return( m_height );
00217   }
00218 } // namespace nvsg
00219
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


ModelViewTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvtraverser/Traverser.h"
#include "nvutil/TransformStack.h"

Include dependency graph for ModelViewTraverser.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:57 2008 for NVSGSDK by NVIDIA


ModelViewTraverser.h Source File

ModelViewTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvtraverser/Traverser.h"
00017 #include "nvutil/TransformStack.h"
00018
00019
00020 namespace nvtraverser
00021 {
00022
00024
00029   class SharedModelViewTraverser : public SharedTraverser
00030   {
00031     protected:
00033
00035       NVSG_API SharedModelViewTraverser();
00036
00038       NVSG_API virtual ~SharedModelViewTraverser();
00039
00041
00042       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00043                                                   );
00044
00046
00048       NVSG_API virtual void handleBillboard( const nvsg::Billboard *p
00049                                            );
00050
00051       NVSG_API virtual void handleLOD( const nvsg::LOD *lod );
00052
00054
00056       NVSG_API virtual void handleTransform( const nvsg::Transform *p
00057                                           );
00058
00060
00061       NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00062                                                 );
00063
00065
00067       NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00068                                                 );
00069
00077       NVSG_API virtual void traverseCamera(const nvsg::Camera * camera);
00078
00083       NVSG_API virtual void lockViewState();
00084
00089       NVSG_API virtual void unlockViewState();
00090
00091     protected:
00092       const nvsg::Camera      * m_lockedCamera;
00093       nvutil::TransformStack    m_transformStack;
00094   };
00095
00097
00102   class ExclusiveModelViewTraverser : public ExclusiveTraverser
00103   {
00104   protected:
00106
00108     NVSG_API ExclusiveModelViewTraverser();
00109
00111     NVSG_API virtual ~ExclusiveModelViewTraverser();
00112
00114
00115     NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransform *p
00116       );
00117
00119
00121     NVSG_API virtual void handleBillboard( nvsg::Billboard *p
00122       );
00123
00124     NVSG_API virtual void handleLOD( nvsg::LOD *lod );
00125
00127
00129     NVSG_API virtual void handleTransform( nvsg::Transform *p
00130       );
00131
00133
00134     NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00135       );
00136
00138
00140     NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00141       );
00142
00150     NVSG_API virtual void traverseCamera(nvsg::Camera * camera);
00151
00156     NVSG_API virtual void lockViewState();
00157
00162     NVSG_API virtual void unlockViewState();
00163
00164   protected:
00165     nvsg::Camera            * m_lockedCamera;
00166     nvutil::TransformStack    m_transformStack;
00167   };
00168 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


NBF.h File Reference

#include "nvsgcommon.h"
#include "nvutil/BitMask.h"

Include dependency graph for NBF.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Classes

struct | str_t
The str_t structure specifies how a string is stored in a .NBF file. More...

struct | sstr_t
The sstr_t structure specifies how a small string is stored in a .NBF file. More...

struct | vertexAttrib_t
The vertexAttrib_t structure specifies how vertex attributes are stored in a .NBF file. More...

struct | texCoordSet_t
The texCoordSet_t structure specifies how a texture coordinate set is stored in a .NBF file. More...

struct | geometrySet_t
The geometrySet_t structure specifies how a geometry set is stored in a .NBF file. More...

struct | indexSet_t
The indexSet_t structure specifies how an index set is stored in a .NBF file. More...

struct | meshSet_t
The meshSet_t structure specifies how an mesh set is stored in a .NBF file. More...

struct | texBinding_t
The texBinding_t structure specifies how a texture binding is stored in a .NBF file. More...

struct | texImage_t
The texImage_t structure specifies how a texture image is stored in a .NBF file. More...

struct | trafo_t
The trafo_t structure specifies how a transformation is stored in a .NBF file. More...

struct | tweak_t
The tweak_t structure specifies how a tweakable parameter is stored in a .NBF file. More...

struct | sampler_t
The sampler_t structure specifies how a sampler parameter is stored in a .NBF file. More...

struct | bone_t
The bone_t structure specifies how a bone is stored in a .NBF file. More...

struct | skin_t
The skin_t structure specifies how a skin is stored in a .NBF file. More...

struct | keyVariant_t
The keyVariant_t structure specifies how a pair of a VariantKey and a StateVariant is stored in a .NBF file. More...

struct | plane_t
The plane_t structure specifies how a pair of a bool and a Plane3f is stored in a .NBF file. More...

struct | switchMask_t
The switchMask_t structure specifies how a SwitchMask is stored in a .NBF file. More...

struct | NBFHeader
The NBFHeader structure represents the NBF header format. More...

struct | NBFScene
The NBFScene structure represents a scene in the context of computer graphics. More...

struct | NBFViewState
The NBFViewState represents an optional view state used to render the scene. More...

struct | NBFObject
The NBFObject structure represents general object data. More...

struct | NBFIndexAnimation
The NBFIndexAnimation represents an animation that will be applied to uint_t objects. More...

struct | NBFTrafoAnimation
The NBFTrafoAnimation represents an animation that will be applied to trafo_t objects. More...

struct | NBFVertexAttributeAnimation
The NBFVertexAttributeAnimation represents an animation that will be applied to vertexAttrib_t objects. More...

struct | NBFAnimation
The NBFAnimation structure represents the common anchor of all animation structures. More...

struct | NBFFramedAnimation
The NBFFramedAnimation structure represents a framed animation. More...

struct | NBFFramedIndexAnimation
The NBFFramedIndexAnimation structure represents a framed animation that will be applied to uint_t objects. More...

struct | NBFFramedTrafoAnimation
The NBFFramedTrafoAnimation structure represents a framed animation that will be applied to trafo_t objects. More...

struct | NBFFramedVertexAttributeAnimation
The NBFFramedVertexAttributeAnimation structure represents a framed animation that will be applied to vertexAttrib_t objects. More...

struct | NBFInterpolatedAnimation
The NBFInterpolatedAnimation structure represents a interpolated animation. More...

struct | NBFInterpolatedTrafoAnimation
The NBFInterpolatedTrafoAnimation structure represents a interpolated animation that will be applied to trafo_t objects. More...

struct | NBFInterpolatedVertexAttributeAnimation
The NBFInterpolatedVertexAttributeAnimation structure represents a interpolated animation that will be applied to vertexAttrib_t objects. More...

struct | NBFCamera
The NBFCamera represents a camera. More...

struct | NBFParallelCamera
The NBFParallelCamera represents a parallel camera. More...

struct | NBFPerspectiveCamera
The NBFPerspectiveCamera represents a perspective camera. More...

struct | NBFDrawable
The NBFDrawable represents any kind of a drawable object. More...

struct | NBFVertexAttributeSet
The NBFVertexAttributeSet structure represents a set of vertex attributes. More...

struct | NBFAnimatedVertexAttributeSet
The NBFAnimatedVertexAttributeSet structure represents a set of animated vertex attributes. More...

struct | NBFSkin
The NBFSkin structure represents a set of skin information for a vertex attribute. More...

struct | NBFPrimitiveSet
The NBFPrimitiveSet structure represents a geometry with an NBFVertexAttributeSet. More...

struct | NBFIndependentPrimitiveSet
The NBFIndependentPrimitiveSet structure represents a set of independent primitives. More...

struct | NBFMeshedPrimitiveSet
The NBFMeshedPrimitiveSet structure represents a mesh set. More...

struct | NBFStrippedPrimitiveSet
The NBFStrippedPrimitiveSet structure represents a strip set. More...

struct | NBFSkinnedTriangles
The NBFSkinnedTriangles structure represents skin animated triangles. More...

struct | NBFNode
The NBFNode structure represents a general node. More...

struct | NBFGeoNode
The NBFGeoNode structure represents a geometry node. More...

struct | NBFVolumeNode
The NBFVolumeNode structure represents a volume node. More...

struct | NBFGroup
The NBFGroup structure represents a group node. More...

struct | NBFLOD
The NBFLOD structure represents a 'Level Of Detail' group node. More...

struct | NBFSwitch
The NBFSwitch structure represents a switch group node. More...

struct | NBFBillboard
The NBFBillboard structure represents a billboard group node. More...

struct | NBFTransform
The NBFTransform structure represents a transform group node. More...

struct | NBFFlipbookAnimation
The NBFFlipbookAnimation structure represents an animated group node. More...

struct | NBFAnimatedTransform
The NBFAnimatedTransform structure represents an animated transform group node. More...

struct | NBFLightSource
The NBFLightSource structure represents a light source node. More...

struct | NBFDirectedLight
struct | NBFPointLight
struct | NBFSpotLight
struct | NBFStateSet
The NBFStateSet structure represents a set of pairs of VariantKeys and StateVariants. More...

struct | NBFStateVariant
The NBFStateVariant structure represents a set of StatePasses. More...

struct | NBFStatePass
The NBFStatePass structure represents a set of heterogeneous NBFStateAttributes. More...

struct | NBFStateAttribute
The NBFStateAttribute structure represents a state attribute. More...

struct | NBFAlphaTestAttribute
The NBFAlphaTestAttribute structure represents an alpha test state attribute in the NBF format. More...

struct | NBFBlendAttribute
The NBFBlendAttribute structure represents a blend function. More...

struct | NBFCgFx
The NBFCgFx structure represents an effect attribute. More...

struct | NBFDepthAttribute
The NBFDepthAttribute structure represents depth buffer settings. More...

struct | NBFFaceAttribute
The NBFFaceAttribute structure represents a render mode. More...

struct | NBFLightingAttribute
The NBFLightingAttribute structure represents a render mode. More...

struct | NBFLineAttribute
The NBFLineAttribute structure represents a render mode. More...

struct | NBFMaterial
The NBFMaterial structure represents a material. More...

struct | NBFPointAttribute
The NBFPointAttribute structure represents a render mode. More...

struct | NBFTextureAttribute
The NBFTextureAttribute structure represents a texture attribute. More...

struct | NBFTextureAttributeItem
The NBFTextureAttributeItem structure represents a single texture object. More...

struct | NBFUnlitColorAttribute
The NBFUnlitColorAttribute structure represents the color for unlit objects. More...

Defines

#define | PADDING(n) PADDING_i(n,__LINE__)
Convenient macro to add padding bits, part one of three.

#define | PADDING_i(n, l) PADDING_ii(n,l)
Convenient macro to add padding bits, part two of three.

#define | PADDING_ii(n, l) ubyte_t padding##l[n]
Convenient macro to add padding bits, part three of three.

Typedefs

typedef char | byte_t
Specifies an 8-bit signed type.

typedef unsigned char | ubyte_t
Specifies an 8-bit unsigned type.

typedef short | short_t
Specifies a 16-bit signed integer type.

typedef unsigned short | ushort_t
Specifies a 16-bit unsigned integer type.

typedef int | int_t
Specifies a 32-bit signed integer type.

typedef unsigned int | uint_t
Specifies a 32-bit unsigned integer type.

typedef unsigned long long | uint64_t
Specifies a 64-bit unsigned integer type.

typedef float | float2_t [2]
Specifies a 2-component float vector.

typedef float | float3_t [3]
Specifies a 3-component float vector.

typedef float | float4_t [4]
Specifies a 4-component float vector.

typedef float | float44_t [4][4]
Specifies a 4x4-component float matrix.

Enumerations

enum {
NBF_UNKNOWN = 0x00000000, NBF_TRAFO_ANIMATION = 0x00000100, NBF_VNVECTOR_ANIMATION, NBF_VERTEX_ATTRIBUTE_ANIMATION,
NBF_FRAMED_ANIMATION = 0x00000120, NBF_FRAMED_TRAFO_ANIMATION, NBF_FRAMED_VNVECTOR_ANIMATION, NBF_FRAMED_VERTEX_ATTRIBUTE_ANIMATION,
NBF_FRAMED_INDEX_ANIMATION, NBF_INTERPOLATED_ANIMATION = 0x00000140, NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION, NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION,
NBF_LINEAR_INTERPOLATED_VERTEX_ATTRIBUTE_ANIMATION, NBF_CAMERA = 0x00000200, NBF_MONO_CAMERA, NBF_JITTER_CAMERA,
NBF_SIMPLE_CAMERA, NBF_PARALLEL_CAMERA, NBF_PERSPECTIVE_CAMERA, NBF_STEREO_CAMERA,
NBF_DRAWABLE = 0x00000300, NBF_VERTEX_ATTRIBUTE_SET, NBF_TRIANGLES, NBF_ANIMATED_TRIANGLES,
NBF_SKINNED_TRIANGLES, NBF_TRISTRIPS, NBF_QUADS, NBF_ANIMATED_QUADS,
NBF_QUADSTRIPS, NBF_LINES, NBF_LINESTRIPS, NBF_TRIFANS,
NBF_POINTS, NBF_QUADMESHES, NBF_ANIMATED_VERTEX_ATTRIBUTE_SET, NBF_SKIN,
NBF_NODE = 0x00000400, NBF_GEO_NODE, NBF_GROUP, NBF_LOD,
NBF_SWITCH, NBF_TRANSFORM, NBF_ANIMATED_TRANSFORM, NBF_LIGHT_SOURCE,
NBF_DIRECTED_LIGHT, NBF_POINT_LIGHT, NBF_SPOT_LIGHT, NBF_BILLBOARD,
NBF_VOLUME_NODE, NBF_FLIPBOOK_ANIMATION, NBF_STATE_SET = 0x00000500, NBF_STATE_VARIANT,
NBF_STATE_PASS, NBF_STATE_ATTRIBUTE = 0x00000600, NBF_CGFX, NBF_MATERIAL,
NBF_FACE_ATTRIBUTE, NBF_TEXTURE_ATTRIBUTE, NBF_TEXTURE_ATTRIBUTE_ITEM, NBF_LINE_ATTRIBUTE,
NBF_POINT_ATTRIBUTE, NBF_BLEND_ATTRIBUTE, NBF_DEPTH_ATTRIBUTE, NBF_ALPHA_TEST_ATTRIBUTE,
NBF_LIGHTING_ATTRIBUTE, NBF_UNLIT_COLOR_ATTRIBUTE, NBF_CUSTOM_OBJECT
}
Unique NBF Object Codes. More...

Functions

NVSG_CTASSERT_MODULO_BYTESIZE (str_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (vertexAttrib_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (texCoordSet_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (geometrySet_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (indexSet_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (meshSet_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (texBinding_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (texImage_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (trafo_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (tweak_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (bone_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (skin_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (keyVariant_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (plane_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (switchMask_t, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFHeader, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFScene, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFViewState, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFObject, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFIndexAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFTrafoAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFVertexAttributeAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFFramedAnimation, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFFramedIndexAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFFramedTrafoAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFFramedVertexAttributeAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFInterpolatedAnimation, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFInterpolatedTrafoAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFInterpolatedVertexAttributeAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFCamera, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFParallelCamera, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFPerspectiveCamera, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFDrawable, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFVertexAttributeSet, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFAnimatedVertexAttributeSet, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFSkin, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFPrimitiveSet, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFIndependentPrimitiveSet, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFMeshedPrimitiveSet, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFStrippedPrimitiveSet, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFNode, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFGeoNode, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFGroup, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFLOD, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFSwitch, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFBillboard, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFTransform, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFFlipbookAnimation, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFAnimatedTransform, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFLightSource, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFDirectedLight, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFPointLight, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFSpotLight, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFStateSet, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFStateVariant, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFStatePass, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFStateAttribute, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFAlphaTestAttribute, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFBlendAttribute, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFCgFx, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFDepthAttribute, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFFaceAttribute, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFLightingAttribute, 4)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFLineAttribute, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFMaterial, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFPointAttribute, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFTextureAttribute, 8)
Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE (NBFUnlitColorAttribute, 8)
Compile-time assert on size of structure.

Variables

const ubyte_t | NBF_VER_MAJOR = 0x3d
NBF major version number.

const ubyte_t | NBF_VER_MINOR = 0x03
NBF version compatibility level.

const ubyte_t | NBF_VER_BUGFIX = 0x00
NBF version bugfix level.

const ubyte_t | NBF_LITTLE_ENDIAN = 0x00
Specifies little endian byte order.

const ubyte_t | NBF_BIG_ENDIAN = 0x01
Specifies big endian byte order.

Detailed Description

Define Documentation

#define PADDING ( n ) PADDING_i(n,__LINE__)

Convenient macro to add padding bits, part one of three.

#define PADDING_i | ( | n,
 |  | l | ) | PADDING_ii(n,l)

Convenient macro to add padding bits, part two of three.

#define PADDING_ii | ( | n,
 |  | l | ) | ubyte_t padding##l[n]

Convenient macro to add padding bits, part three of three.

Typedef Documentation

typedef char byte_t

Specifies an 8-bit signed type.

typedef unsigned char ubyte_t

Specifies an 8-bit unsigned type.

typedef short short_t

Specifies a 16-bit signed integer type.

typedef unsigned short ushort_t

Specifies a 16-bit unsigned integer type.

typedef int int_t

Specifies a 32-bit signed integer type.

typedef unsigned int uint_t

Specifies a 32-bit unsigned integer type.

typedef unsigned long long uint64_t

Specifies a 64-bit unsigned integer type.

typedef float float2_t[2]

Specifies a 2-component float vector.

typedef float float3_t[3]

Specifies a 3-component float vector.

typedef float float4_t[4]

Specifies a 4-component float vector.

typedef float float44_t[4][4]

Specifies a 4x4-component float matrix.

Enumeration Type Documentation

anonymous enum

Unique NBF Object Codes.

Each concrete NBFObject type is assigned to a unique NBF object code. This code is a 32-bit unsigned integer value, stored at offset 0, of each concrete NBFObject. The purpose of the unique 'per-object' code is to provide a Load-Time Type Information (LTTI) to resolve concrete NBFObjects while loading NBF files.

Enumeration values:
NBF_UNKNOWN | Unknown, and hence, invalid object code.
NBF_FRAMED_TRAFO_ANIMATION | Identifies an NBFFramedTrafoAnimation object.
NBF_FRAMED_VNVECTOR_ANIMATION | Obsolete.
NBF_FRAMED_VERTEX_ATTRIBUTE_ANIMATION | Identifies an NBFFramedVertexAttributeAnimation object.
NBF_FRAMED_INDEX_ANIMATION | Identifies an NBFFramedIndexAnimation.
NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION | Identifies an NBFInterpolatedTrafoAnimation object.
NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION | Obsolete.
NBF_PARALLEL_CAMERA | Identifies an NBFParallelCamera object.
NBF_PERSPECTIVE_CAMERA | Identifies an NBFPerspectiveCamera object.
NBF_VERTEX_ATTRIBUTE_SET | Identifies an NBFVertexAttributeSet object.
NBF_TRIANGLES | Identifies an NBFIndependentPrimitiveSet object.
NBF_ANIMATED_TRIANGLES | Obsolete.
NBF_SKINNED_TRIANGLES | Identifies an NBFSkinnedTriangles object.
NBF_TRISTRIPS | Identifies an NBFStrippedPrimitiveSet object.
NBF_QUADS | Identifies an NBFIndependentPrimitiveSet object (support since v0.3).
NBF_ANIMATED_QUADS | Obsolete.
NBF_QUADSTRIPS | Identifies an NBFStrippedPrimitiveSet object (support since v0.4).
NBF_LINES | Identifies an NBFIndependentPrimitiveSet object (support since v0.5).
NBF_LINESTRIPS | Identifies an NBFStrippedPrimitiveSet object (support since v0.5).
NBF_TRIFANS | Identifies an NBFTriFans object (support since v0.6).
NBF_POINTS | Identifies an NBFPoints object (support since v0.6).
NBF_QUADMESHES | Identifies an NBFQuadMeshes object.
NBF_ANIMATED_VERTEX_ATTRIBUTE_SET | Identifies an NBFAnimatedVertexAttributeSet.
NBF_SKIN | Identifies an NBFSkin.
NBF_GEO_NODE | Identifies a NBFGeoNode object.
NBF_GROUP | Identifies a NBFGroup object.
NBF_LOD | Identifies a NBFLOD object.
NBF_SWITCH | Identifies a NBFSwitch object.
NBF_TRANSFORM | Identifies a NBFTransform object.
NBF_ANIMATED_TRANSFORM | Identifies a NBFAnimatedTransform object.
NBF_DIRECTED_LIGHT | Identifies an NBFDirectedLight object.
NBF_POINT_LIGHT | Identifies an NBFPointLight object.
NBF_SPOT_LIGHT | Identifies an NBFSpotLight object.
NBF_BILLBOARD | Identifies an NBFBillboard object.
NBF_VOLUME_NODE | Identifies an NBFVolumeNode object.
NBF_FLIPBOOK_ANIMATION | Identifies an NBFFlipbookAnimation object.
NBF_STATE_SET | Identifies an NBFStateSet object.
NBF_STATE_VARIANT | Identifies an NBFStateVariant object.
NBF_STATE_PASS | Identifies an NBFStatePass object.
NBF_CGFX | Identifies an NBFCgFx object.
NBF_MATERIAL | Identifies an NBFMaterial object.
NBF_FACE_ATTRIBUTE | Identifies an NBFFaceAttribute object.
NBF_TEXTURE_ATTRIBUTE | Identifies an NBFTextureAttribute object.
NBF_TEXTURE_ATTRIBUTE_ITEM | Identifies an NBFTextureAttributeItem object.
NBF_LINE_ATTRIBUTE | Identifies an NBFLineAttribute object.
NBF_POINT_ATTRIBUTE | Identifies an NBFPointAttribute object.
NBF_BLEND_ATTRIBUTE | Identifies an NBFBlendAttribute object.
NBF_DEPTH_ATTRIBUTE | Identifies an NBFDepthAttribute object.
NBF_ALPHA_TEST_ATTRIBUTE | Identifies an NBFAlphaTestAttribute object.
NBF_LIGHTING_ATTRIBUTE | Identifies an NBFLightingAttribute object.
NBF_UNLIT_COLOR_ATTRIBUTE | Identifies an NBFUnlitColorAttribute object.
NBF_CUSTOM_OBJECT | Custom objects must not have codes lower than this.

Function Documentation

NVSG_CTASSERT_MODULO_BYTESIZE | ( | str_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | vertexAttrib_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | texCoordSet_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | geometrySet_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | indexSet_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | meshSet_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | texBinding_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | texImage_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | trafo_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | tweak_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | bone_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | skin_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | keyVariant_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | plane_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | switchMask_t | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFHeader | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFScene | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFViewState | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFObject | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFIndexAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFTrafoAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFVertexAttributeAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFFramedAnimation | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFFramedIndexAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFFramedTrafoAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFFramedVertexAttributeAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFInterpolatedAnimation | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFInterpolatedTrafoAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFInterpolatedVertexAttributeAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFCamera | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFParallelCamera | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFPerspectiveCamera | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFDrawable | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFVertexAttributeSet | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFAnimatedVertexAttributeSet | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFSkin | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFPrimitiveSet | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFIndependentPrimitiveSet | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFMeshedPrimitiveSet | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFStrippedPrimitiveSet | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFNode | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFGeoNode | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFGroup | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFLOD | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFSwitch | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFBillboard | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFTransform | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFFlipbookAnimation | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFAnimatedTransform | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFLightSource | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFDirectedLight | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFPointLight | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFSpotLight | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFStateSet | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFStateVariant | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFStatePass | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFStateAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFAlphaTestAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFBlendAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFCgFx | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFDepthAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFFaceAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFLightingAttribute | ,
 |  | 4 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFLineAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFMaterial | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFPointAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFTextureAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

NVSG_CTASSERT_MODULO_BYTESIZE | ( | NBFUnlitColorAttribute | ,
 |  | 8 |
 | ) |

Compile-time assert on size of structure.

Variable Documentation

const ubyte_t NBF_VER_MAJOR = 0x3d

NBF major version number.

const ubyte_t NBF_VER_MINOR = 0x03

NBF version compatibility level.

const ubyte_t NBF_VER_BUGFIX = 0x00

NBF version bugfix level.

const ubyte_t NBF_LITTLE_ENDIAN = 0x00

Specifies little endian byte order.

const ubyte_t NBF_BIG_ENDIAN = 0x01

Specifies big endian byte order.

Generated on Tue Jan 15 10:27:58 2008 for NVSGSDK by NVIDIA


NBF.h Source File

NBF.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvutil/BitMask.h"
00017
00018 // NBF is independent of packing. However, this forces
00019 // the compile-time asserts below to fire on inconsistencies
00020 #pragma pack(push, 1)
00021
00022 // convenient aliases for used built-in types
00023 typedef char                    byte_t;
00024 typedef unsigned char           ubyte_t;
00025 typedef short                   short_t;
00026 typedef unsigned short          ushort_t;
00027 typedef int                     int_t;
00028 typedef unsigned int            uint_t;
00029 #ifdef LINUX
00030 # if __WORDSIZE == 64           // defined indirectly through stdint.h
00031 // avoid a conflict with GNU stdint.h on Linux64
00032 // note: long is a 64-bit type on Linux64, while it is 32bit on Win64
00033 // Linux64
00034 typedef unsigned long           uint64_t;
00035 # else
00036 // Linux32
00037 typedef unsigned long long      uint64_t;
00038 # endif
00039 #else
00040 // Win32 and Win64
00041 typedef unsigned long long      uint64_t;
00042 #endif
00043 typedef float                   float2_t[2];
00044 typedef float                   float3_t[3];
00045 typedef float                   float4_t[4];
00046 typedef float                   float44_t[4][4];
00047
00048 #define PADDING(n) PADDING_i(n,__LINE__)
00049 #define PADDING_i(n,l) PADDING_ii(n,l)
00050 #define PADDING_ii(n,l) ubyte_t padding##l[n]
00051
00052 // NBF version
00053 const ubyte_t NBF_VER_MAJOR  =  0x3d;
00054 const ubyte_t NBF_VER_MINOR  =  0x03;
00055 const ubyte_t NBF_VER_BUGFIX =  0x00;
00056
00057 // constants specifying a certain byte order
00058 const ubyte_t NBF_LITTLE_ENDIAN = 0x00;
00059 const ubyte_t NBF_BIG_ENDIAN =  0x01;
00060
00061 // convenient helper types
00062
00064 struct str_t
00065 {
00066   uint_t      numChars;
00067
00068   uint_t      chars;
00069 };
00070 NVSG_CTASSERT_MODULO_BYTESIZE(str_t,4);
00071
00073
00074 struct sstr_t
00075 {
00076   ushort_t    numChars;
00077
00078   uint_t      chars;
00079 };
00080
00082
00083 struct vertexAttrib_t
00084 {
00085   uint_t      size;
00086   uint_t      type;
00087   uint_t      numVData;
00088   uint_t      vdata;
00089 };
00090 NVSG_CTASSERT_MODULO_BYTESIZE(vertexAttrib_t,4);
00091
00093
00094 struct texCoordSet_t
00095 {
00096   uint_t      numTexCoords;
00097   uint_t      coordDim;
00098
00099   uint_t      texCoords;
00100 };
00101 NVSG_CTASSERT_MODULO_BYTESIZE(texCoordSet_t,4);
00102
00104
00105 struct geometrySet_t
00106 {
00107   uint_t      stateSet;
00108   uint_t      numDrawables;
00109   uint_t      drawables;
00110 };
00111 NVSG_CTASSERT_MODULO_BYTESIZE(geometrySet_t,4);
00112
00114
00115 struct indexSet_t
00116 {
00117   uint_t      numIndices;
00118   uint_t      indices;
00119
00120 };
00121 NVSG_CTASSERT_MODULO_BYTESIZE(indexSet_t,4);
00122
00124
00125 struct meshSet_t
00126 {
00127   uint_t      width;
00128   uint_t      height;
00129   uint_t      indices;
00130
00131 };
00132 NVSG_CTASSERT_MODULO_BYTESIZE(meshSet_t,4);
00133
00135
00137 struct texBinding_t
00138 {
00139   uint_t      texUnit;
00140   uint_t      texAttribItem;
00141 };
00142 NVSG_CTASSERT_MODULO_BYTESIZE(texBinding_t,4);
00143
00145
00146 struct texImage_t
00147 {
00148   uint_t      flags;
00149   str_t       file;
00150   // the following are only relevant in case the image is not from a file but from a image data lump.
00151   uint_t      width;
00152   uint_t      height;
00153   uint_t      depth;
00154   PADDING(12);
00155   uint_t      pixelFormat;
00156   uint_t      dataType;
00157   uint_t      pixels;
00158 };
00159 NVSG_CTASSERT_MODULO_BYTESIZE(texImage_t,4);
00160
00162 struct trafo_t
00163 {
00164   float4_t    orientation;
00165   float3_t    scaling;
00166   float3_t    translation;
00167   float3_t    center;
00168   float4_t    scaleOrientation;
00169 };
00170 NVSG_CTASSERT_MODULO_BYTESIZE(trafo_t,4);
00171
00173
00174 struct tweak_t
00175 {
00176   str_t       name;
00177
00178   // type flags
00179   enum {
00180     TYPE_STRUCT = BIT0
00181   , TYPE_ARRAY  = BIT1
00182   , TYPE_FLOAT  = BIT2
00183   , TYPE_INT    = BIT3
00184   , TYPE_BOOL   = BIT4
00185   , TYPE_STRING = BIT5
00186   };
00187   uint_t      type;
00188   uint_t      numValues;
00189   union
00190   {
00191     uint_t    floats;
00192     str_t     str;
00193   };
00194
00195   // the following is relevant only for arrays and structs (nesting tweaks)
00196   uint_t   numTweaks;
00197   uint_t   tweaks;
00198 };
00199 NVSG_CTASSERT_MODULO_BYTESIZE(tweak_t,4);
00200
00202
00203 struct sampler_t
00204 {
00205   str_t       name;
00206   uint_t      texImg;
00207 };
00208
00210
00211 struct bone_t
00212 {
00213   float       weight;
00214
00215   uint_t      animation;
00216
00217 };
00218 NVSG_CTASSERT_MODULO_BYTESIZE(bone_t,4);
00219
00221
00222 struct skin_t
00223 {
00224   uint_t      numBones;
00225   uint_t      bones;
00226
00227   float3_t    vertex;
00228   float3_t    normal;
00229 };
00230 NVSG_CTASSERT_MODULO_BYTESIZE(skin_t,4);
00231
00233 struct keyVariant_t
00234 {
00235   uint_t      key;
00236   uint_t      variant;
00237 };
00238 NVSG_CTASSERT_MODULO_BYTESIZE(keyVariant_t,4);
00239
00241 struct plane_t
00242 {
00243   uint_t      active;
00244   float3_t    normal;
00245   float       offset;
00246 };
00247 NVSG_CTASSERT_MODULO_BYTESIZE(plane_t,4);
00248
00250 struct switchMask_t
00251 {
00252   uint_t        maskKey;
00253   uint_t        numChildren;
00254   uint_t        children;
00255 };
00256 NVSG_CTASSERT_MODULO_BYTESIZE(switchMask_t,4);
00257
00259
00263 enum
00264 {
00265   // scene object
00266   NBF_UNKNOWN                     = 0x00000000
00267   // animation objects (0x100 - 0x1FF)
00268 , NBF_TRAFO_ANIMATION           = 0x00000100
00269 , NBF_VNVECTOR_ANIMATION
00270 , NBF_VERTEX_ATTRIBUTE_ANIMATION
00271   // framed animations
00272 , NBF_FRAMED_ANIMATION          = 0x00000120
00273 , NBF_FRAMED_TRAFO_ANIMATION
00274 , NBF_FRAMED_VNVECTOR_ANIMATION
00275 , NBF_FRAMED_VERTEX_ATTRIBUTE_ANIMATION
00276 , NBF_FRAMED_INDEX_ANIMATION
00277   // interpolated animations
00278 , NBF_INTERPOLATED_ANIMATION    = 0x00000140
00279 , NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION
00280 , NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION
00281 , NBF_LINEAR_INTERPOLATED_VERTEX_ATTRIBUTE_ANIMATION
00282   // camera objects (0x200 - 0x2FF)
00283 , NBF_CAMERA                    = 0x00000200
00284 , NBF_MONO_CAMERA
00285 , NBF_JITTER_CAMERA
00286 , NBF_SIMPLE_CAMERA
00287 , NBF_PARALLEL_CAMERA
00288 , NBF_PERSPECTIVE_CAMERA
00289 , NBF_STEREO_CAMERA
00290   // drawable objects (0x300 - 0x3FF)
00291 , NBF_DRAWABLE                  = 0x00000300
00292 , NBF_VERTEX_ATTRIBUTE_SET
00293 , NBF_TRIANGLES
00294 , NBF_ANIMATED_TRIANGLES
00295 , NBF_SKINNED_TRIANGLES
00296 , NBF_TRISTRIPS
00297 , NBF_QUADS
00298 , NBF_ANIMATED_QUADS
00299 , NBF_QUADSTRIPS
00300 , NBF_LINES
00301 , NBF_LINESTRIPS
00302 , NBF_TRIFANS
00303 , NBF_POINTS
00304 , NBF_QUADMESHES
00305 , NBF_ANIMATED_VERTEX_ATTRIBUTE_SET
00306 , NBF_SKIN
00307   // node objects (0x400 - 0x4FF)
00308 , NBF_NODE                      = 0x00000400
00309 , NBF_GEO_NODE
00310 , NBF_GROUP
00311 , NBF_LOD
00312 , NBF_SWITCH
00313 , NBF_TRANSFORM
00314 , NBF_ANIMATED_TRANSFORM
00315 , NBF_LIGHT_SOURCE
00316 , NBF_DIRECTED_LIGHT
00317 , NBF_POINT_LIGHT
00318 , NBF_SPOT_LIGHT
00319 , NBF_BILLBOARD
00320 , NBF_VOLUME_NODE
00321 , NBF_FLIPBOOK_ANIMATION
00322   // state set objects (0x500 - 0x5FF)
00323 , NBF_STATE_SET                 = 0x00000500
00324 , NBF_STATE_VARIANT
00325 , NBF_STATE_PASS
00326   // state attribute objects (0x600 - 0x6FF)
00327 , NBF_STATE_ATTRIBUTE           = 0x00000600
00328 , NBF_CGFX
00329 , NBF_MATERIAL
00330 , NBF_FACE_ATTRIBUTE
00331 , NBF_TEXTURE_ATTRIBUTE
00332 , NBF_TEXTURE_ATTRIBUTE_ITEM
00333 , NBF_LINE_ATTRIBUTE
00334 , NBF_POINT_ATTRIBUTE
00335 , NBF_BLEND_ATTRIBUTE
00336 , NBF_DEPTH_ATTRIBUTE
00337 , NBF_ALPHA_TEST_ATTRIBUTE
00338 , NBF_LIGHTING_ATTRIBUTE
00339 , NBF_UNLIT_COLOR_ATTRIBUTE
00340   // custom objects (>=0x700)
00341 , NBF_CUSTOM_OBJECT
00342 };
00343
00345
00351 struct NBFHeader
00352 {
00353   // signature
00354   byte_t      signature[4];
00355   // NBF version
00356   ubyte_t     nbfMajorVersion;
00357   ubyte_t     nbfMinorVersion;
00358   ubyte_t     nbfBugfixLevel;
00359
00360
00361   // NVSG version
00362   ubyte_t     nvsgMajorVersion;
00363   ubyte_t     nvsgMinorVersion;
00364   ubyte_t     nvsgBugfixLevel;
00365
00366
00367   // Reserved bytes
00368   ubyte_t     reserved[16];
00369   // Date
00370   ubyte_t     dayLastModified;
00371   ubyte_t     monthLastModified;
00372   ubyte_t     yearLastModified[2];
00373   // Time stamp
00374   ubyte_t     secondLastModified;
00375   ubyte_t     minuteLastModified;
00376   ubyte_t     hourLastModified;
00377   // endianess
00378   ubyte_t     byteOrder;
00379
00380
00381   PADDING(2);
00382   // scene object
00383   uint_t      scene;
00384   // optional view state
00385   uint_t      viewState;
00386
00387 };
00388 NVSG_CTASSERT_MODULO_BYTESIZE(NBFHeader,4);
00389
00391
00393 struct NBFScene
00394 {
00395   float3_t    ambientColor;
00396   float4_t    backColor;
00397   uint_t      backImg;
00398   uint_t      numCameras;
00399   uint_t      cameras;
00400   uint_t      numCameraAnimations;
00401   uint_t      cameraAnimations;
00402   uint_t      numberOfAnimationFrames;
00403   uint_t      root;
00404 };
00405 NVSG_CTASSERT_MODULO_BYTESIZE(NBFScene,4);
00406
00408
00409 struct NBFViewState
00410 {
00411   uint_t      objectCode;
00412   uint_t      camera;
00413   ubyte_t     isStereo;
00414   ubyte_t     isStereoAutomatic;
00415   PADDING(2);
00416   uint_t      combineMethod;
00417   uint_t      numFSAAJitters;
00418   uint_t      fsaaJitters;
00419   uint_t      numDoFJitters;
00420   uint_t      dofJitters;
00421   float       stereoAutomaticFactor;
00422   float       stereoEyeDistance;
00423   float       targetDistance;
00424 };
00425 NVSG_CTASSERT_MODULO_BYTESIZE(NBFViewState,4);
00426
00428 struct NBFObject
00429 {
00430   uint_t      objectCode;
00431   ubyte_t     isShared;
00432
00433
00434   PADDING(3);
00435   uint64_t    objectDataID;
00436   uint_t      sourceObject;
00437
00438   sstr_t       objectName;
00439   sstr_t       objectAnno;
00440 };
00441 // NOTE: Because of the uint64_t member objectDataID above, which is 8-byte aligned,
00442 // we need to ensure the size of NBFObject is fixed - that is, independent of whatever
00443 // the compilers actual packing value might be! We achieve this by making the size of
00444 // NBFObject a multiple of 8 bytes (see compile time assert below).
00445 NVSG_CTASSERT_MODULO_BYTESIZE(NBFObject,8);
00446
00448
00452 struct NBFIndexAnimation : public NBFObject
00453 {
00454   uint_t      indices;
00455
00456
00457   PADDING(4);
00458 };
00459 NVSG_CTASSERT_MODULO_BYTESIZE(NBFIndexAnimation,8);
00460
00462
00467 struct NBFTrafoAnimation : public NBFObject
00468 {
00469   uint_t      trafos;
00470
00471
00472   PADDING(4);
00473 };
00474 NVSG_CTASSERT_MODULO_BYTESIZE(NBFTrafoAnimation,8);
00475
00477
00482 struct NBFVertexAttributeAnimation : public NBFObject
00483 {
00484   uint_t      attribs;
00485
00486
00487   PADDING(4);
00488 };
00489 NVSG_CTASSERT_MODULO_BYTESIZE(NBFVertexAttributeAnimation,8);
00490
00492
00494 struct NBFAnimation
00495 {
00496   uint_t  loopCount;
00497   uint_t  speed;
00498   bool    forward;
00499   bool    swinging;
00500   PADDING(6);
00501 };
00502
00504
00509 struct NBFFramedAnimation : public NBFAnimation
00510 {
00511   uint_t      numSteps;
00512
00513
00514
00515
00516
00517
00518   PADDING(4);
00519 };
00520 NVSG_CTASSERT_MODULO_BYTESIZE(NBFFramedAnimation,4);
00521
00523
00525 struct NBFFramedIndexAnimation : public NBFIndexAnimation
00526                                , public NBFFramedAnimation
00527 {
00528 };
00529 NVSG_CTASSERT_MODULO_BYTESIZE(NBFFramedIndexAnimation,8);
00530
00532
00534 struct NBFFramedTrafoAnimation : public NBFTrafoAnimation
00535                                , public NBFFramedAnimation
00536 {
00537 };
00538 NVSG_CTASSERT_MODULO_BYTESIZE(NBFFramedTrafoAnimation,8);
00539
00541
00543 struct NBFFramedVertexAttributeAnimation : public NBFVertexAttributeAnimation
00544                                          , public NBFFramedAnimation
00545 {
00546 };
00547 NVSG_CTASSERT_MODULO_BYTESIZE(NBFFramedVertexAttributeAnimation,8);
00548
00550
00556 struct NBFInterpolatedAnimation : public NBFAnimation
00557 {
00558   uint_t      numKeys;
00559   uint_t      keys;
00560
00561 };
00562 NVSG_CTASSERT_MODULO_BYTESIZE(NBFInterpolatedAnimation,4);
00563
00565
00569 struct NBFInterpolatedTrafoAnimation : public NBFTrafoAnimation
00570                                      , public NBFInterpolatedAnimation
00571 {
00572 };
00573 NVSG_CTASSERT_MODULO_BYTESIZE(NBFInterpolatedTrafoAnimation,8);
00574
00576
00580 struct NBFInterpolatedVertexAttributeAnimation : public NBFVertexAttributeAnimation
00581                                                , public NBFInterpolatedAnimation
00582 {
00583 };
00584 NVSG_CTASSERT_MODULO_BYTESIZE(NBFInterpolatedVertexAttributeAnimation,8);
00585
00587
00591 struct NBFCamera : public NBFObject
00592 {
00593   uint_t      numHeadLights;
00594   uint_t      headLights;
00595
00596   float3_t    upVector;
00597   float3_t    position;
00598   float3_t    direction;
00599   float       farDist;
00600   float       nearDist;
00601   float       focusDist;
00602   ubyte_t     isAutoClipPlanes;
00603   PADDING(3);
00604   float2_t    windowSize;
00605
00606   float2_t    windowOffset;
00607
00608   PADDING(4);
00609 };
00610 NVSG_CTASSERT_MODULO_BYTESIZE(NBFCamera,8);
00611
00613
00615 struct NBFParallelCamera : public NBFCamera
00616 {
00617 };
00618 NVSG_CTASSERT_MODULO_BYTESIZE(NBFParallelCamera,8);
00619
00621
00623 struct NBFPerspectiveCamera : public NBFCamera
00624 {
00625 };
00626 NVSG_CTASSERT_MODULO_BYTESIZE(NBFPerspectiveCamera,8);
00627
00629
00633 struct NBFDrawable : public NBFObject
00634 {
00635 };
00636 NVSG_CTASSERT_MODULO_BYTESIZE(NBFDrawable,8);
00637
00639
00641 struct NBFVertexAttributeSet : public NBFObject
00642 {
00643   uint_t      enableFlags;
00644   uint_t      normalizeEnableFlags;
00645   vertexAttrib_t  vattribs[16];
00646 };
00647 NVSG_CTASSERT_MODULO_BYTESIZE(NBFVertexAttributeSet,8);
00648
00654 struct NBFAnimatedVertexAttributeSet : public NBFVertexAttributeSet
00655 {
00656   uint_t      animations[16];
00657
00658   uint_t      normalizeFlags;
00659
00660   PADDING(4);
00661 };
00662 NVSG_CTASSERT_MODULO_BYTESIZE(NBFAnimatedVertexAttributeSet,8);
00663
00669 struct NBFSkin : public NBFObject
00670 {
00671   float44_t   bindShapeMatrix;
00672   uint_t      numCounts;
00673   uint_t      counts;
00674   uint_t      indices;
00675   uint_t      weights;
00676   ubyte_t     skinningType[16];
00677   uint_t      numJoints;
00678   uint_t      inverseBindMatrices;
00679   uint_t      joints;
00680   PADDING(4);
00681 };
00682 NVSG_CTASSERT_MODULO_BYTESIZE(NBFSkin,8);
00683
00685
00686 struct NBFPrimitiveSet : public NBFDrawable
00687 {
00688   uint_t      vertexAttributeSet;
00689   uint_t      skin;
00690 };
00691 NVSG_CTASSERT_MODULO_BYTESIZE(NBFPrimitiveSet,8);
00692
00694
00696 struct NBFIndependentPrimitiveSet : public NBFPrimitiveSet
00697 {
00698   uint_t      numIndices;
00699   uint_t      indices;
00700 };
00701 NVSG_CTASSERT_MODULO_BYTESIZE(NBFIndependentPrimitiveSet,8);
00702
00704
00706 struct NBFMeshedPrimitiveSet : public NBFPrimitiveSet
00707 {
00708   uint_t      numMeshes;
00709   uint_t      meshes;
00710
00711 };
00712 NVSG_CTASSERT_MODULO_BYTESIZE(NBFMeshedPrimitiveSet,8);
00713
00715
00717 struct NBFStrippedPrimitiveSet : public NBFPrimitiveSet
00718 {
00719   uint_t      numStrips;
00720   uint_t      strips;
00721
00722 };
00723 NVSG_CTASSERT_MODULO_BYTESIZE(NBFStrippedPrimitiveSet,8);
00724
00726
00728 struct NBFSkinnedTriangles : public NBFIndependentPrimitiveSet
00729 {
00730   uint_t      numSkins;
00731   uint_t      skins;
00732 };
00733 NVSG_CTASSERT_MODULO_BYTESIZE(NBFSkinnedTriangles,8);
00734
00736
00740 struct NBFNode : public NBFObject
00741 {
00742   str_t       annotation;
00743   PADDING(6);
00744   ubyte_t     systemHints;
00745   ubyte_t     userHints;
00746 };
00747 NVSG_CTASSERT_MODULO_BYTESIZE(NBFNode,8);
00748
00750
00751 struct NBFGeoNode : public NBFNode
00752 {
00753   uint_t      numGeometrySets;
00754   uint_t      geometrySets;
00755 };
00756 NVSG_CTASSERT_MODULO_BYTESIZE(NBFGeoNode,8);
00757
00759
00760 struct NBFVolumeNode : public NBFNode
00761 {
00762   str_t       bricksName;
00763   uint_t      levelToDisplay;
00764   uint_t      shader;
00765   str_t       volumeName;
00766   float       voxelLimitFraction;
00767 };
00768
00770
00773 struct NBFGroup : public NBFNode
00774 {
00775   uint_t      numChildren;
00776   uint_t      children;
00777
00778   uint_t      numClipPlanes;
00779   uint_t      clipPlanes;
00780   uint_t      numLightSource;
00781   uint_t      lightSources;
00782 };
00783 NVSG_CTASSERT_MODULO_BYTESIZE(NBFGroup,8);
00784
00786
00787 struct NBFLOD : public NBFGroup
00788 {
00789   float3_t    center;
00790   uint_t      numRanges;
00791   uint_t      ranges;
00792
00793   PADDING(4);
00794 };
00795 NVSG_CTASSERT_MODULO_BYTESIZE(NBFLOD,8);
00796
00798
00799 struct NBFSwitch : public NBFGroup
00800 {
00801   uint_t      activeMaskKey;
00802   uint_t      numMasks;
00803   uint_t      masks;
00804   PADDING(4);
00805 };
00806 NVSG_CTASSERT_MODULO_BYTESIZE(NBFSwitch,8);
00807
00809
00810 struct NBFBillboard: public NBFGroup
00811 {
00812   float3_t  rotationAxis;
00813   ubyte_t   alignment;
00814   PADDING(3);
00815 };
00816 NVSG_CTASSERT_MODULO_BYTESIZE(NBFBillboard,8);
00817
00819
00820 struct NBFTransform : public NBFGroup
00821 {
00822   trafo_t             trafo;
00823   PADDING(4);
00824 };
00825 NVSG_CTASSERT_MODULO_BYTESIZE(NBFTransform,8);
00826
00828
00829 struct NBFFlipbookAnimation : public NBFGroup
00830 {
00831   uint_t      animation;
00832
00833   PADDING(4);
00834 };
00835 NVSG_CTASSERT_MODULO_BYTESIZE(NBFFlipbookAnimation,8);
00836
00838
00839 struct NBFAnimatedTransform : public NBFTransform
00840 {
00841   uint_t      animation;
00842
00843   PADDING(4);
00844 };
00845 NVSG_CTASSERT_MODULO_BYTESIZE(NBFAnimatedTransform,8);
00846
00848
00850 struct NBFLightSource : public NBFObject
00851 {
00852   float       intensity;
00853   float3_t    ambientColor;
00854   float3_t    diffuseColor;
00855   float3_t    specularColor;
00856   ubyte_t     castShadow;
00857   ubyte_t     enabled;
00858   PADDING(2);
00859   uint_t      animation;
00860
00861 };
00862 NVSG_CTASSERT_MODULO_BYTESIZE(NBFLightSource,8);
00863
00864 // The NBFDirectedLight structure represents a directed light source.
00866 struct NBFDirectedLight : public NBFLightSource
00867 {
00868   float3_t direction;
00869   PADDING(4);
00870 };
00871 NVSG_CTASSERT_MODULO_BYTESIZE(NBFDirectedLight,8);
00872
00873 // The NBFPointLight structure represents a point light source.
00875 struct NBFPointLight : public NBFLightSource
00876 {
00877   float3_t position;
00878   float3_t attenuation;
00879
00880
00881
00882 };
00883 NVSG_CTASSERT_MODULO_BYTESIZE(NBFPointLight,8);
00884
00885 // The NBFSpotLight structure represents a spot light.
00887 struct NBFSpotLight : public NBFLightSource
00888 {
00889   float3_t position;
00890   float3_t direction;
00891   float3_t attenuation;
00892
00893
00894
00895   float    cutoffAngle;
00896
00897   float    falloffExponent;
00898   PADDING(4);
00899 };
00900 NVSG_CTASSERT_MODULO_BYTESIZE(NBFSpotLight,8);
00901
00903
00904 struct NBFStateSet : public NBFObject
00905 {
00906   uint_t activeKey;
00907   uint_t numStateVariants;
00908   uint_t keyStateVariantPairs;
00909   PADDING(4);
00910 };
00911 NVSG_CTASSERT_MODULO_BYTESIZE(NBFStateSet,8);
00912
00914
00915 struct NBFStateVariant : public NBFObject
00916 {
00917   uint_t      numStatePasses;
00918   uint_t      statePasses;
00919 };
00920 NVSG_CTASSERT_MODULO_BYTESIZE(NBFStateVariant,8);
00921
00923
00924 struct NBFStatePass : public NBFObject
00925 {
00926   uint_t      numStateAttribs;
00927   uint_t      stateAttribs;
00928 };
00929 NVSG_CTASSERT_MODULO_BYTESIZE(NBFStatePass,8);
00930
00932
00934 struct NBFStateAttribute : public NBFObject
00935 {
00936 };
00937 NVSG_CTASSERT_MODULO_BYTESIZE(NBFStateAttribute,8);
00938
00940
00941 struct NBFAlphaTestAttribute : public NBFStateAttribute
00942 {
00943   ubyte_t     alphaFunction;
00944   ubyte_t     enabledMSAlpha;
00945   PADDING(2);
00946   float       threshold;
00947 };
00948 NVSG_CTASSERT_MODULO_BYTESIZE(NBFAlphaTestAttribute,8);
00949
00951
00952 struct NBFBlendAttribute : public NBFStateAttribute
00953 {
00954   ubyte_t     sourceFunction;
00955   ubyte_t     destinationFunction;
00956   PADDING(6);
00957 };
00958 NVSG_CTASSERT_MODULO_BYTESIZE(NBFBlendAttribute,8);
00959
00961
00962 struct NBFCgFx : public NBFStateAttribute
00963 {
00964   PADDING(3);
00965   ubyte_t     fromFile;
00966   str_t       source;
00967   uint_t      numTweaks;
00968   uint_t      tweaks;
00969   uint_t      numSamplers;
00970   uint_t      samplers;
00971   str_t       currTech;
00972   PADDING(4);
00973 };
00974 NVSG_CTASSERT_MODULO_BYTESIZE(NBFCgFx,8);
00975
00977
00978 struct NBFDepthAttribute : public NBFStateAttribute
00979 {
00980   ubyte_t     depthFunction;
00981   ubyte_t     depthTestingEnabled;
00982   ubyte_t     depthWritingEnabled;
00983   PADDING(5);
00984 };
00985 NVSG_CTASSERT_MODULO_BYTESIZE(NBFDepthAttribute,8);
00986
00988
00989 struct NBFFaceAttribute : public NBFStateAttribute
00990 {
00991   ubyte_t     cullMode;
00992   ubyte_t     polygonOffsetEnabled;
00993   PADDING(2);
00994   float       polygonOffsetFactor;
00995
00996   float       polygonOffsetUnits;
00997
00998   ubyte_t     twoSidedLighting;
00999   ubyte_t     frontFaceMode;
01000   ubyte_t     backFaceMode;
01001   PADDING(1);
01002 };
01003 NVSG_CTASSERT_MODULO_BYTESIZE(NBFFaceAttribute,8);
01004
01006
01007 struct NBFLightingAttribute : public NBFStateAttribute
01008 {
01009   ubyte_t     enabled;
01010   PADDING(3);
01011 };
01012 NVSG_CTASSERT_MODULO_BYTESIZE(NBFLightingAttribute,4);
01013
01015
01016 struct NBFLineAttribute : public NBFStateAttribute
01017 {
01018   ubyte_t     antiAliasing;
01019   PADDING(3);
01020   uint_t      stippleFactor;
01021   uint_t      stipplePattern;
01022   float       width;
01023 };
01024 NVSG_CTASSERT_MODULO_BYTESIZE(NBFLineAttribute,8);
01025
01027
01028 struct NBFMaterial : public NBFStateAttribute
01029 {
01030   float3_t    frontAmbientColor;
01031   float3_t    frontDiffuseColor;
01032   float3_t    frontEmissiveColor;
01033   float       frontOpacity;
01034   float3_t    frontSpecularColor;
01035   float       frontSpecularExponent;
01036   float3_t    backAmbientColor;
01037   float3_t    backDiffuseColor;
01038   float3_t    backEmissiveColor;
01039   float       backOpacity;
01040   float3_t    backSpecularColor;
01041   float       backSpecularExponent;
01042 };
01043 NVSG_CTASSERT_MODULO_BYTESIZE(NBFMaterial,8);
01044
01046
01047 struct NBFPointAttribute : public NBFStateAttribute
01048 {
01049   ubyte_t     antiAliasing;
01050   PADDING(3);
01051   float       size;
01052 };
01053 NVSG_CTASSERT_MODULO_BYTESIZE(NBFPointAttribute,8);
01054
01056
01057 struct NBFTextureAttribute : public NBFStateAttribute
01058 {
01059   uint_t      numBindings;
01060   uint_t      bindings;
01061
01062 };
01063 NVSG_CTASSERT_MODULO_BYTESIZE(NBFTextureAttribute,8);
01064
01066
01069 struct NBFTextureAttributeItem : public NBFObject
01070 {
01071   uint_t        texImg;
01072   uint_t        texTarget;
01073   float4_t      texEnvColor;
01074   uint_t        texEnvMode;
01075
01076   uint_t        texEnvScale;
01077   uint_t        texWrapS;
01078   uint_t        texWrapT;
01079   uint_t        texWrapR;
01080   uint_t        minFilter;
01081
01082
01083   uint_t        magFilter;
01084
01085   float4_t      texBorderColor;
01086   trafo_t       trafo;
01087   uint_t        texGenMode[4];
01088   float4_t      texGenPlane[2][4];
01089 };
01090 NVSG_CTASSERT_MODULO_BYTESIZE(NBFTextureAttributeItem,8);
01091
01094 struct NBFUnlitColorAttribute : public NBFStateAttribute
01095 {
01096   float4_t      color;
01097 };
01098 NVSG_CTASSERT_MODULO_BYTESIZE(NBFUnlitColorAttribute,8);
01099
01100 #pragma pack(pop)
01101
01102 #undef __NVSG_CTASSERT_PREFIX
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Node.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Boxnt.h"
#include "nvmath/Spherent.h"
#include "nvsg/Drawable.h"
#include "nvsg/StateSet.h"
#include "nvsg/Object.h"
#include "nvutil/BitMask.h"
#include <vector>

Include dependency graph for Node.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:27:58 2008 for NVSGSDK by NVIDIA


Node.h Source File

Node.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Boxnt.h"
00017 #include "nvmath/Spherent.h"
00018 #include "nvsg/Drawable.h"
00019 #include "nvsg/StateSet.h"
00020 #include "nvsg/Object.h"
00021 #include "nvutil/BitMask.h"
00022 #include <vector>
00023
00024 namespace nvsg
00025 {
00029 class Node : public Object
00030 {
00031   public:
00066     enum NodeHints
00067     {
00068       NH_CULL_MASK              = BIT0 | BIT1,
00069       NH_CULL_NEVER             = BIT0,
00070       NH_CULL_ALWAYS            = BIT1,
00071
00072       NH_NO_SHADOW_CASTER       = BIT2,
00073       NH_NO_SHADOW_RECEIVER     = BIT3,
00074
00075       NH_OVERLAY                = BIT4,
00076
00077       NH_MODIFY_FREQUENCY_MASK  = BIT5 | BIT6,
00078       NH_MODIFY_FREQUENCY_LOW   = BIT5,
00079       NH_MODIFY_FREQUENCY_HIGH  = BIT6,
00080
00081       NH_RESERVED_BITS          = 0x80,
00082       NH_CUSTOM_BITS            = 0xFF00,
00083     };
00084
00085   public:
00086
00089     NVSG_API Node();
00090
00093     NVSG_API Node(const Node& rhs);
00094
00097     NVSG_API virtual ~Node();
00098
00101     NVSG_API unsigned int getNumberOfParents() const;
00102
00115     NVSG_API GroupHandle * getParent(unsigned int index) const;
00116
00120     NVSG_API const nvmath::Box3f & getBoundingBox() const;
00121
00131     NVSG_API const nvmath::Sphere3f & getBoundingSphere() const;
00132
00140     NVSG_API void invalidateBoundingVolumes();
00141
00154     NVSG_API bool containsTransparentGeometry() const;
00155
00162     NVSG_API void invalidateTransparencyContainment();
00163
00168     NVSG_API bool containsCgFx() const;
00169
00186     NVSG_API void invalidateCgFxContainment();
00187
00192     NVSG_API bool containsLight() const;
00193
00210     NVSG_API void invalidateLightContainment();
00211
00216     NVSG_API bool containsLOD() const;
00217
00234     NVSG_API void invalidateLODContainment();
00235
00240     NVSG_API bool containsVolumeNode() const;
00241
00258     NVSG_API void invalidateVolumeNodeContainment();
00259
00263     NVSG_API bool containsAnimation() const;
00264
00279     NVSG_API void invalidateAnimationContainment();
00280
00286     NVSG_API unsigned short getHints( unsigned short mask = 0xFFFF ) const;
00287
00291     NVSG_API void setHints( unsigned short hints );
00292
00298     NVSG_API void addHints( unsigned short hints );
00299
00305     NVSG_API void removeHints( unsigned short hints );
00306
00313     NVSG_API bool containsHints( unsigned short hints ) const;
00314
00321     NVSG_API unsigned short getHintsContainment( unsigned short hints ) const;
00322
00329     NVSG_API void invalidateHintsContainment( unsigned short hints );
00330
00336     NVSG_API virtual bool invalidateIncarnation();
00337
00344     NVSG_API virtual bool validateIncarnation() const;
00345
00356     NVSG_API void invalidateContainment( unsigned int mask );
00357
00361     NVSG_API unsigned int getContainmentFlags() const;
00362
00366     NVSG_API unsigned int getContainmentValidFlags() const;
00367
00368   #if !defined( NDEBUG )
00369
00373     NVSG_API void assertInvalidBoundingSphere() const;
00374   #endif
00375
00376   protected:
00386     NVSG_API virtual nvmath::Box3f calculateBoundingBox() const = 0;
00387
00397     NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const = 0;
00398
00408     NVSG_API virtual bool determineCgFxContainment() const;
00409
00419     NVSG_API virtual bool determineLightContainment() const;
00420
00430     NVSG_API virtual bool determineLODContainment() const;
00431
00441     NVSG_API virtual bool determineVolumeNodeContainment() const;
00442
00449     NVSG_API virtual unsigned short determineHintsContainment( unsigned short hints ) const;
00450
00461     NVSG_API virtual bool determineTransparencyContainment() const = 0;
00462
00468     NVSG_API virtual bool determineAnimationContainment() const;
00469
00479     NVSG_API Node & operator=(const Node & rhs);
00480
00484     NVSG_API void addAsParentTo(NodeHandle* child);
00485
00489     NVSG_API void removeAsParentFrom(NodeHandle* child);
00490
00491   protected:
00492
00493     // bit defines visible for derived nodes
00494     enum
00495     {
00496
00497       // CgFx containment
00498       NF_CONTAINS_CGFX                = BIT0,
00499       NF_CONTAINS_CGFX_VALID          = BIT1,
00500
00501       // transparency containment
00502       NF_CONTAINS_TRANSPARENCY        = BIT2,
00503       NF_CONTAINS_TRANSPARENCY_VALID  = BIT3,
00504
00505       // bounding sphere
00506       NF_BOUNDING_BOX_VALID           = BIT4,
00507       NF_BOUNDING_SPHERE_VALID        = BIT5,
00508
00509       NF_BOUNDING_VOLUMES_VALID       = NF_BOUNDING_BOX_VALID | NF_BOUNDING_SPHERE_VALID,
00510       // light containment
00511       NF_CONTAINS_LIGHT               = BIT6,
00512       NF_CONTAINS_LIGHT_VALID         = BIT7,
00513       // volume node containment
00514       NF_CONTAINS_VOLUME_NODE         = BIT8,
00515       NF_CONTAINS_VOLUME_NODE_VALID   = BIT9,
00516       // LOD containment
00517       NF_CONTAINS_LOD                 = BIT0,
00518       NF_CONTAINS_LOD_VALID           = BIT11,
00519       // Animation containment
00520       NF_CONTAINS_ANIMATION           = BIT12,
00521       NF_CONTAINS_ANIMATION_VALID     = BIT13,
00522
00523       NF_CONTAINS_MASK = NF_CONTAINS_TRANSPARENCY
00524                        | NF_CONTAINS_CGFX
00525                        | NF_CONTAINS_LIGHT
00526                        | NF_CONTAINS_VOLUME_NODE
00527                        | NF_CONTAINS_LOD
00528                        | NF_CONTAINS_ANIMATION,
00529
00530       NF_CONTAINS_VALID_MASK = NF_CONTAINS_MASK << 1
00531
00532     };
00533
00534     mutable unsigned int      m_flags; // node flags visible to all derived
00535
00536   private:
00537     // helpers with managing parent/child relationships
00538     friend class Group; // Group needs access to these helpers - no one else!
00539     void addParent(Group * parent);
00540     void removeParent(Group * parent);
00541
00542     // Validates all caches maintained by the Group.
00543     // Will be called from validateIncarnation
00544     void validateCaches() const;
00545
00546   private:
00547
00548     class Parent {
00549     public:
00550       explicit Parent(Group * parent); // explicit constructor
00551       // default copy ctor already does the right thing
00552       // default dtor does the right thing
00553
00554       // comparison is required for the std;:find algorithm
00555       bool operator==(const Group * rhs) const; // identify Parent by object
00556       bool operator!=(const Group * rhs) const; // dito
00557
00558       // accessors
00559       Group * operator->() const; // dereference the object
00560       GroupHandle * parent() const {return m_hdl;} // access the handle
00561
00562       // lifetime management
00563       void addRef();
00564       void removeRef();
00565       bool isShared() const; // the same parent reference by the same child multiple times?
00566
00567     private:
00568       Group * m_obj;
00569       GroupHandle * m_hdl;
00570       nvutil::RefCount<int> m_refCnt;
00571     };
00572
00573     typedef std::vector<Parent> ParentVector;
00574     typedef ParentVector::const_iterator ConstParentIterator;
00575     typedef ParentVector::iterator ParentIterator;
00576
00577     unsigned short   m_hints;      // optional hints specified. see NodeHints
00578     ParentVector     m_parents;    // node's parents
00579
00580     mutable nvmath::Box3f     m_boundingBox; // ... the node's bounding box
00581     mutable nvmath::Sphere3f  m_boundingSphere; // ... the node's bounding sphere
00582     mutable unsigned short    m_hintsContainment;
00583     mutable unsigned short    m_hintsContainmentValid;
00584 };
00585
00586 //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
00587
00588 inline unsigned int Node::getNumberOfParents() const
00589 {
00590   NVSG_TRACE();
00591   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00592   NVSG_ASSERT( m_parents.size() <= UINT_MAX );
00593   return( static_cast<unsigned int>(m_parents.size()) );
00594 }
00595
00596 inline GroupHandle * Node::getParent( unsigned int i ) const
00597 {
00598   NVSG_TRACE();
00599   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00600   NVSG_ASSERT(i < m_parents.size()); // undefined behavior for invalid index!
00601   return m_parents[i].parent();
00602 }
00603
00604 inline void Node::invalidateTransparencyContainment()
00605 {
00606   NVSG_TRACE();
00607   invalidateContainment(NF_CONTAINS_TRANSPARENCY);
00608 }
00609
00610 inline void Node::invalidateCgFxContainment()
00611 {
00612   NVSG_TRACE();
00613   invalidateContainment(NF_CONTAINS_CGFX);
00614 }
00615
00616 inline void Node::invalidateLightContainment()
00617 {
00618   NVSG_TRACE();
00619   invalidateContainment(NF_CONTAINS_LIGHT);
00620 }
00621
00622 inline void Node::invalidateLODContainment()
00623 {
00624   NVSG_TRACE();
00625   invalidateContainment(NF_CONTAINS_LOD);
00626 }
00627
00628 inline void Node::invalidateVolumeNodeContainment()
00629 {
00630   NVSG_TRACE();
00631   invalidateContainment(NF_CONTAINS_VOLUME_NODE);
00632 }
00633
00634 inline void Node::invalidateAnimationContainment()
00635 {
00636   NVSG_TRACE();
00637   invalidateContainment(NF_CONTAINS_ANIMATION);
00638 }
00639
00640 inline unsigned int Node::getContainmentFlags() const
00641 {
00642   NVSG_TRACE();
00643   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00644   return( m_flags & NF_CONTAINS_MASK );
00645 }
00646
00647 inline unsigned int Node::getContainmentValidFlags() const
00648 {
00649   NVSG_TRACE();
00650   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00651   return( m_flags & NF_CONTAINS_VALID_MASK );
00652 }
00653
00654 inline unsigned short Node::getHints( unsigned short mask ) const
00655 {
00656   NVSG_TRACE();
00657   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00658   return( m_hints & mask );
00659 }
00660
00661 inline void Node::setHints( unsigned short hints )
00662 {
00663   NVSG_TRACE();
00664   NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00665   if ( m_hints != hints )
00666   {
00667     unsigned short changedHints = ( hints & ~m_hints ) | ( ~hints & m_hints );
00668     m_hints = hints;
00669     invalidateHintsContainment( changedHints );
00670   }
00671 }
00672
00673 inline void Node::addHints( unsigned short hints )
00674 {
00675   NVSG_TRACE();
00676   NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00677   unsigned short changedHints = hints & ~m_hints;
00678   if ( changedHints )
00679   {
00680     m_hints |= hints;
00681     invalidateHintsContainment( changedHints );
00682   }
00683 }
00684
00685 inline void Node::removeHints( unsigned short hints )
00686 {
00687   NVSG_TRACE();
00688   NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00689   unsigned short changedHints = hints & m_hints;
00690   if ( changedHints )
00691   {
00692     m_hints &= ~hints;
00693     invalidateHintsContainment( changedHints );
00694   }
00695 }
00696
00697
00698 // convenient helper
00699
00706 inline bool isEmptyBoundingSphere(NodeHandle* node)
00707 {
00708   NVSG_TRACE();
00709   return nvmath::isEmpty(nvutil::ReadableObject<Node>(node)->getBoundingSphere());
00710 }
00711
00718 inline nvmath::Sphere3f getBoundingSphere(NodeHandle * node)
00719 {
00720   NVSG_TRACE();
00721   return nvutil::ReadableObject<Node>(node)->getBoundingSphere();
00722 }
00723
00724 template <typename T>
00725 inline T node_cast(const Node * node)
00726 {
00727   NVSG_CTASSERT(!!(nvutil::Conversion<T,const Node*>::exists));
00728   return dynamic_cast<T>(node);
00729 }
00730
00731 template <typename T>
00732 inline T node_cast(Node * node)
00733 {
00734   NVSG_CTASSERT(!!(nvutil::Conversion<T,Node*>::exists));
00735   return dynamic_cast<T>(node);
00736 }
00737
00738 } // namespace
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NodeHintsCullTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CullData.h"
#include "nvtraverser/CullTraverser.h"

Include dependency graph for NodeHintsCullTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:58 2008 for NVSGSDK by NVIDIA


NodeHintsCullTraverser.h Source File

NodeHintsCullTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/CullData.h"
00017 #include "nvtraverser/CullTraverser.h"
00018
00019 namespace nvsg
00020 {
00021   class Node;
00022 }
00023
00024 namespace nvtraverser
00025 {
00041   class NodeHintsCullTraverser : public CullTraverser
00042   {
00043   public:
00050     NVSG_API NodeHintsCullTraverser(unsigned short uisNodeHints = nvsg::Node::NH_CULL_NEVER);
00051
00061     NVSG_API unsigned short getHints( unsigned short mask = 0xFFFF ) const;
00062
00069     NVSG_API void setHints( unsigned short hints );
00070
00075     NVSG_API void addHints( unsigned short hints );
00076
00086     NVSG_API void removeHints( unsigned short hints );
00087
00088   protected:
00094     NVSG_API virtual ~NodeHintsCullTraverser(void);
00095
00100     NVSG_API virtual nvsg::CullCode cullCode( const nvmath::Sphere3f & bs ) const;
00101
00102   protected:
00103     // The current set of active hints
00104     unsigned short   m_NodeHints;
00105   };
00106
00107   inline unsigned short NodeHintsCullTraverser::getHints( unsigned short mask ) const
00108   {
00109     return( m_NodeHints & mask );
00110   }
00111
00112   inline void NodeHintsCullTraverser::setHints( unsigned short hints )
00113   {
00114     m_NodeHints = hints;
00115   }
00116
00117   inline void NodeHintsCullTraverser::addHints( unsigned short hints )
00118   {
00119     m_NodeHints |= hints;
00120   }
00121
00122   inline void NodeHintsCullTraverser::removeHints( unsigned short hints )
00123   {
00124     m_NodeHints &= ~hints;
00125   }
00126 }
00127
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NormalizeTraverser.h File Reference

#include <set>
#include "nvsgcommon.h"
#include "nvtraverser/Traverser.h"

Include dependency graph for NormalizeTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:27:59 2008 for NVSGSDK by NVIDIA


NormalizeTraverser.h Source File

NormalizeTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <set>
00016 #include "nvsgcommon.h"
00017 #include "nvtraverser/Traverser.h"
00018
00019 namespace nvtraverser
00020 {
00021
00023   class NormalizeTraverser : public ExclusiveTraverser
00024   {
00025     public:
00027       NVSG_API NormalizeTraverser(void);
00028
00030
00031       NVSG_API unsigned int getVertexAttributeIndex() const;
00032
00034
00035       NVSG_API void setVertexAttributeIndex( unsigned int attrib );
00036
00037     protected:
00039       NVSG_API virtual ~NormalizeTraverser(void);
00040
00042       NVSG_API virtual void  doApply( nvsg::NodeHandle * root );
00043
00045       NVSG_API virtual void handleVertexAttributeSet( nvsg::VertexAttributeSet * p );
00046
00048       NVSG_API virtual void handleAnimatedVertexAttributeSet( nvsg::AnimatedVertexAttributeSet * p );
00049
00051       NVSG_API virtual void handleFramedVertexAttributeAnimation( nvsg::FramedAnimation<nvsg::VertexAttribute> * p );
00052
00054       NVSG_API virtual void handleLinearInterpolatedVertexAttributeAnimation( nvsg::LinearInterpolatedAnimation<nvsg::VertexAttribute> * p );
00055
00056     private:
00057       template<unsigned char N, typename T>
00058         void  normalizeData( nvsg::VertexAttributeSet * p );
00059
00060     private:
00061       unsigned int                          m_attrib;
00062       std::set<nvsg::VertexAttributeSet *>  m_multiOwnedVAS;
00063   };
00064
00065   inline unsigned int NormalizeTraverser::getVertexAttributeIndex() const
00066   {
00067     return( m_attrib );
00068   }
00069
00070   inline void NormalizeTraverser::setVertexAttributeIndex( unsigned int attrib )
00071   {
00072     m_attrib = attrib;
00073   }
00074 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NVBLoader.h File Reference

#include "nvsg/PlugInterface.h"
#include "nvutil/Tools.h"
#include "inc/NVNVB.h"
#include "inc/NVNVB2.h"

Include dependency graph for NVBLoader.h:

Include dependency graph

Go to the source code of this file.

Classes

class | NVBLoader
A Scene Loader for nvb files. More...

Functions

NVNVB_API bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

NVNVB_API bool | queryPlugInterfaceType (const nvutil::UPITID &pitid, std::vector< nvutil::UPIID > &piids)
Query the supported types of PlugIn Interfaces.

Detailed Description

Function Documentation

NVNVB_API bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) |

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a NVBLoader. If the PlugIn ID piid equals PIID_NVB_SCENE_LOADER, a NVBLoader is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

NVNVB_API bool queryPlugInterfaceType | ( | const nvutil::UPITID & | pitid,
 |  | std::vector< nvutil::UPIID > & | piids
 | ) |

Query the supported types of PlugIn Interfaces.

Every PlugIn has to resolve this function. It is used to query the supported Interface types of this PlugIn. If the Plug In Type ID pitid equals PITID_SCENE_LOADER, the vector piids is filled with one element PIID_NVB_SCENE_LOADER.

Returns:
true, if a PITID_SCENE_LOADER is requested, otherwise false
Parameters:
pitid | PlugIn Type ID to query
piids | vector of PlugIn IDs to fill

Generated on Tue Jan 15 10:27:59 2008 for NVSGSDK by NVIDIA


NVBLoader.h Source File

NVBLoader.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include  "nvsg/PlugInterface.h"
00016 #include  "nvutil/Tools.h"
00017 #include  "inc/NVNVB.h"
00018 #include  "inc/NVNVB2.h"
00019
00020 //  Don't need to document the API specifier
00021 #if ! defined( DOXYGEN_IGNORE )
00022 #ifdef NVBLOADER_EXPORTS
00023 # define NVNVB_API __declspec(dllexport)
00024 #else
00025 # define NVNVB_API __declspec(dllimport)
00026 #endif
00027 #endif  //  DOXYGEN_IGNORE
00028
00030
00034 NVNVB_API bool getPlugInterface( const nvutil::UPIID& piid
00035                                , nvutil::PlugIn *& pi
00036                                );
00037
00039
00044 NVNVB_API bool queryPlugInterfaceType( const nvutil::UPITID& pitid
00045                                      , std::vector<nvutil::UPIID>& piids
00046                                      );
00047
00049
00053 class NVBLoader : public nvsg::SceneLoader
00054 {
00055   public:
00056     NVBLoader();
00057
00059
00060     void    deleteThis( void );
00061
00063
00068     nvsg::SceneHandle * load( const std::string& filename
00069                             , const std::vector<std::string> &searchPaths
00070                             , nvsg::ViewStateHandle *& viewState
00072                             );
00073
00074   protected:
00076     virtual  ~NVBLoader(void);
00077
00078   private:
00079     NVNVB   * m_nvnvb;
00080     NVNVB2  * m_nvnvb2;
00081 };
00082
00083 inline NVBLoader::NVBLoader()
00084   : m_nvnvb(NULL)
00085   , m_nvnvb2(NULL)
00086 {
00087 }
00088
00089 inline NVBLoader::~NVBLoader()
00090 {
00091   if ( m_nvnvb )
00092   {
00093     delete m_nvnvb;
00094   }
00095   if ( m_nvnvb2 )
00096   {
00097     delete m_nvnvb2;
00098   }
00099 }
00100
00101 inline void NVBLoader::deleteThis( void )
00102 {
00103   delete this;
00104 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NVBLoadTraverser.h File Reference

#include "nvtraverser/Traverser.h"

Include dependency graph for NVBLoadTraverser.h:

Include dependency graph

Go to the source code of this file.

Classes

class NVBLoadTraverser
Internally used traverser for post-processing a just loaded NVB file. More...

Detailed Description

Generated on Tue Jan 15 10:27:59 2008 for NVSGSDK by NVIDIA


NVBLoadTraverser.h Source File

NVBLoadTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include  "nvtraverser/Traverser.h"
00016
00018 class NVBLoadTraverser : public nvtraverser::ExclusiveTraverser
00019 {
00020   public:
00022     NVBLoadTraverser( std::vector<nvsg::MaterialHandle*> &faceMappedMaterials );
00023
00025     virtual ~NVBLoadTraverser(void);
00026
00027   protected:
00029
00030     virtual void  handleCgFx( nvsg::CgFx *p );
00031
00033
00034     virtual void  handleGeoNode( nvsg::GeoNode *p );
00035
00037     virtual void  handleLOD( nvsg::LOD *p )                                { NVSG_ASSERT( false ); }
00038
00040
00041     virtual void  handleMaterial( nvsg::Material *p, bool reset );
00042
00044
00045     virtual void  handleStateSet( nvsg::StateSet *p );
00046
00048     virtual void  handleSwitch( nvsg::Switch *p )                          { NVSG_ASSERT( false ); }
00049
00051
00053     virtual void  handleTriangles( nvsg::Triangles *p );
00054
00055   private:
00056     bool                                  m_bApplyingCgFx;
00057     nvsg::MaterialHandle                * m_currentMaterial;
00058     std::vector<nvsg::MaterialHandle*>  * m_faceMappedMaterials;
00059     std::vector<nvmath::Vec2f>            m_texCoords;
00060 };
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvmath.h File Reference

#include "nvsgcommon.h"
#include <math.h>
#include <algorithm>
#include <float.h>
#include <limits>

Include dependency graph for nvmath.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvmath

Detailed Description

Generated on Tue Jan 15 10:27:59 2008 for NVSGSDK by NVIDIA


nvmath.h Source File

nvmath.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include  <math.h>
00018 #include  <algorithm> // for std::max, std::min (_MAX, _MIN)
00019 #include  <float.h>
00020 #include  <limits>
00021
00023 namespace nvmath
00024 {
00025   // define the stand trig values
00026 #ifdef PI
00027 # undef PI
00028 # undef PI_HALF
00029 # undef PI_QUARTER
00030 #endif
00031
00032   const float PI            = 3.14159265358979323846f;
00034   const float PI_HALF       = 1.57079632679489661923f;
00036   const float PI_QUARTER    = 0.78539816339744830962f;
00038   const float SQRT_TWO      = 1.41421356237309504880f;
00040   const float SQRT_TWO_HALF = 0.70710678118654752440f;
00041
00043
00044   template<class T> T     clamp( T v
00045                                , T l
00046                                , T u
00047                                )
00048   {
00049     return std::min(u, std::max(l,v));
00050   }
00051
00053
00054   template<typename T>
00055   inline T degToRad( T angle )
00056   {
00057     return( angle*(PI/180) );
00058   }
00059
00061   template<typename T>
00062   inline int highestBit( T i )
00063   {
00064     NVSG_CTASSERT( std::numeric_limits<T>::is_integer );
00065     int hb = -1;
00066     for ( T h = i ; h ; h>>=1, hb++ )
00067       ;
00068     return hb;
00069   }
00070
00072   template<typename T>
00073   inline T highestBitValue(T i)
00074   {
00075     NVSG_CTASSERT( std::numeric_limits<T>::is_integer );
00076     T h = 0;
00077     while (i)
00078     {
00079       h = (i & (~i+1)); // grab lowest bit
00080       i &= ~h; // clear lowest bit
00081     }
00082     return h;
00083   }
00084
00086
00087   template<typename T>
00088   inline bool isPowerOfTwo( T n )
00089   {
00090     NVSG_CTASSERT( std::numeric_limits<T>::is_integer );
00091     return (n && !(n & (n-1)));
00092   }
00093
00095
00096   template<typename T>
00097   inline T lerp( float alpha
00098                , const T &v0
00099                , const T &v1
00100                )
00101   {
00102     return( (T)(v0 + alpha * ( v1 - v0 )) );
00103   }
00104
00105   template<typename T>
00106   inline void lerp( float alpha, const T & v0, const T & v1, T & vr )
00107   {
00108     vr = v0 + alpha * ( v1 - v0 );
00109   }
00110
00117   template<typename T>
00118   inline const T & max( const T &a, const T &b, const T &c )
00119   {
00120     return( std::max( a, std::max( b, c ) ) );
00121   }
00122
00129   template<typename T>
00130   inline const T & min( const T &a, const T &b, const T &c )
00131   {
00132     return( std::min( a, std::min( b, c ) ) );
00133   }
00134
00139   template<typename T>
00140   inline T powerOfTwoAbove( T n )
00141   {
00142     NVSG_CTASSERT( std::numeric_limits<T>::is_integer );
00143     if ( isPowerOfTwo( n ) )
00144     {
00145       return( n );
00146     }
00147     else
00148     {
00149       return highestBitValue(n) << 1;
00150     }
00151   }
00152
00157   template<typename T>
00158   inline T powerOfTwoBelow( T n )
00159   {
00160     NVSG_CTASSERT( std::numeric_limits<T>::is_integer );
00161     if ( isPowerOfTwo( n ) )
00162     {
00163       return( n );
00164     }
00165     else
00166     {
00167       return highestBitValue(n);
00168     }
00169   }
00170
00174   template<typename T>
00175   inline T powerOfTwoNearest( T n)
00176   {
00177     NVSG_CTASSERT( std::numeric_limits<T>::is_integer );
00178     if ( isPowerOfTwo( n ) )
00179     {
00180       return n;
00181     }
00182
00183     T prev = highestBitValue(n); // POT below
00184     T next = prev<<1; // POT above
00185     return (next-n) < (n-prev) ? next : prev; // return nearest
00186   }
00187
00189
00191   inline float radToDeg( float angle )
00192   {
00193     return( angle*180.0f/PI );
00194   }
00195
00197
00199   template<typename T>
00200   inline int sign( const T &t )
00201   {
00202     return( ( t < 0 ) ? -1 : ( ( t > 0 ) ? 1 : 0 ) );
00203   }
00204
00206
00208   template<typename T>
00209   inline T square( const T& t )
00210   {
00211     return( t * t );
00212   }
00213
00215
00216   template<typename T>
00217   inline int compare(T lhs, T rhs)
00218   {
00219     return (lhs == rhs) ? 0 : (lhs < rhs) ? -1 : 1;
00220   }
00221
00222   // specializations for float and double below
00223
00225
00226   template<>
00227   inline int compare(float lhs, float rhs)
00228   {
00229     return ((fabs(lhs-rhs) < FLT_EPSILON) ? 0 : (lhs < rhs) ? -1 : 1);
00230   }
00231
00233
00234   template<>
00235   inline int compare(double lhs, double rhs)
00236   {
00237     return ((fabs(lhs-rhs) < DBL_EPSILON) ? 0 : (lhs < rhs) ? -1 : 1);
00238   }
00239 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NVNVB.h File Reference

#include <set>
#include "nvsg/nvsgapi.h"
#include "nvsg/CoreTypes.h"
#include "nvsg/Face.h"
#include "nvsg/SkinnedTriangles.h"
#include "NVBBreaker/inc/NVBLoader.h"

Include dependency graph for NVNVB.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Classes

class NVNVB
Internally used class for loading NVB files. More...

Detailed Description

Generated on Tue Jan 15 10:28:00 2008 for NVSGSDK by NVIDIA


NVNVB.h Source File

NVNVB.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <set>
00016 #include "nvsg/nvsgapi.h"
00017 #include "nvsg/CoreTypes.h"
00018 #include "nvsg/Face.h"
00019 #include "nvsg/SkinnedTriangles.h"
00020 #include "NVBBreaker/inc/NVBLoader.h"
00021
00022 // forward declarations
00023 //  it's not neccessary to document this helper class !
00024 #if ! defined( DOXYGEN_IGNORE )
00025
00026 class JointData
00027 {
00028   public:
00029     JointData( sdword jointID, const nvmath::Vec3f & offset, float weight );
00030
00031   public:
00032     sdword        m_jointID;
00033     nvmath::Vec3f m_offset;
00034     float         m_weight;
00035 };
00036
00037 inline JointData::JointData( sdword jointID, const nvmath::Vec3f & offset, float weight )
00038 : m_jointID(jointID)
00039 , m_offset(offset)
00040 , m_weight(weight)
00041 {
00042 }
00043
00044 #endif  //  DOXYGEN_IGNORE
00045
00047 class NVNVB : public NVBRenderManager::NVBBreaker
00048 {
00049   public:
00050     NVNVB(void);
00051     ~NVNVB(void);
00052
00053   public:
00055
00056     nvsg::SceneHandle * load( const std::string& filename
00057                             , const std::vector<std::string> &searchPaths
00058                             , nvsg::ViewStateHandle *& viewState
00059                             );
00060
00061     // Application-dependent import methods, called by the importer
00063     virtual bool  NewScene      ( const NVBRenderManager::NVBSceneInfo& scene );
00065     virtual bool  NewCamera     ( const NVBRenderManager::NVBCameraInfo& camera );
00067     virtual bool  NewLight      ( const NVBRenderManager::NVBLightInfo& light );
00069     virtual bool  NewMaterial   ( const NVBRenderManager::NVBMaterialInfo& material );
00071     virtual bool  NewTexture    ( const NVBRenderManager::NVBTextureInfo& texture );
00073     virtual bool  NewMesh       ( const NVBRenderManager::NVBMeshInfo& mesh );
00075     virtual bool  NewShape      ( const NVBRenderManager::NVBShapeInfo& shape );
00077     virtual bool  NewHelper     ( const NVBRenderManager::NVBHelperInfo& helper );
00079     virtual bool  NewController ( const NVBRenderManager::NVBControllerInfo& controller );
00081     virtual bool  NewMotion     ( const NVBRenderManager::NVBMotionInfo& motion );
00082
00084     virtual bool  EndImport     ( void );
00085
00087     virtual bool  NVBImportError  ( const char* errortext, udword errorcode );
00088
00090     virtual void  NVBLog          ( NVBRenderManager::TLogLevel level, LPSTR fmt, ... );
00092     virtual void  SetLogCallback  ( NVBRenderManager::TloggingCB cbfn, unsigned long userparam = 0 );
00093
00094   private:
00095     void        addMap( sdword mapID, float coeff, nvsg::TextureAttributeHandle * texAttrib, unsigned int& unit );
00096     void        addMaps( const NVBRenderManager::NVBMaterialInfo& material, nvsg::StateSet * ss );
00097     nvsg::TransformHandle * newTransform( sdword ID, const Point &pos, const Quat &rot, const String &name );
00098
00099   private:
00100     std::map<nvsg::CameraHandle *, sdword>                              m_cameraToTransformID;
00101     std::vector<nvsg::MaterialHandle *>                                 m_faceMappedMaterial;
00102     std::map<nvsg::GroupHandle*,std::vector<nvsg::TrianglesHandle*> >   m_groupToTriangles;
00103     std::set<sdword>                                                    m_invalidTextureIDs;
00104     std::map<sdword, nvsg::AnimatedTransformHandle *>                   m_IDToAnimatedTransform;
00105     std::map<sdword, nvsg::MaterialHandle *>                            m_IDToMaterial;
00106     std::map<sdword, std::string>                                       m_IDToTextureFileName;
00107     std::map<sdword, nvmath::Quatf>                                     m_IDToTextureOrientation;
00108     std::map<sdword, nvmath::Vec3f>                                     m_IDToTextureScaling;
00109     std::map<sdword, nvmath::Vec3f>                                     m_IDToTextureTranslation;
00110     std::map<sdword, nvsg::TransformHandle*>                            m_IDToTransform;
00111     std::map<nvsg::LightSourceHandle *, sdword>                         m_lightToTransformID;
00112     std::map<sdword,nvsg::StateSetHandle*>                              m_matIDToStateSet;
00113     int                                                                 m_numCgFxAttribs;
00114     nvsg::GroupHandle                                                 * m_rootNode;
00115     nvsg::SceneHandle                                                 * m_scene;
00116     std::vector<std::string>                                            m_searchPaths;
00117     std::map<nvsg::TrianglesHandle*,udword>                             m_trianglesToMatID;
00118     std::map<nvsg::TrianglesHandle*,udword>                             m_trianglesToWireColor;
00119     nvsg::ViewStateHandle                                             * m_viewState;
00120     std::map<udword,nvsg::StateSetHandle*>                              m_wireColorToStateSet;
00121
00122     //  For skinned data, store for each meshID (sdword) the associated skinning information.
00123     //  The skinning information is a pair of per material information and the absolute number of normals in the mesh
00124     //  Per material, the associated PrimitiveSetHandle (holding the Skin) and the Joint information per vertex is stored
00125     //  The joint information (per vertex) is the index of the normal vector and the JointData, as explained above (joint id, offset, and weight)
00126     std::map<sdword,std::pair<std::vector<std::pair<nvsg::PrimitiveSetHandle*,std::vector<std::pair<unsigned int,std::vector<JointData> > > > >,unsigned int> > m_IDToJointData;
00127     //        ^mesh id            ^per material         ^associated PS         ^per vertex      |       ^normal index   ^per joint                  ^absolute number of normals in mesh
00128     //                  ^ pair of per-material data and absolute number of normals in mesh      |
00129     //                                        ^ pair of associated SVASH and per-vertex data    |
00130     //                                                                                          ^ pair of normal index and per-joint data
00131
00132 #if !defined(NDEBUG)
00133     std::set<udword> m_meshIds;
00134 #endif
00135 };
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NVNVB2.h File Reference

#include <map>
#include "nvsg/nvsgapi.h"
#include "nvsg/CoreTypes.h"

Include dependency graph for NVNVB2.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Detailed Description

Generated on Tue Jan 15 10:28:00 2008 for NVSGSDK by NVIDIA


NVNVB2.h Source File

NVNVB2.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include  <map>
00015 #include  "nvsg/nvsgapi.h"
00016 #include  "nvsg/CoreTypes.h"
00017
00018
00019
00020 //  it's not necessary to document all these helper classes !
00021 #if ! defined( DOXYGEN_IGNORE )
00022
00023 class NVB2Animation
00024 {
00025   public:
00026     float         frequency;
00027     std::vector<nvmath::Quatf> rotations;
00028     std::vector<nvmath::Vec3f> positions;
00029     std::vector<nvmath::Vec3f> scales;
00030 };
00031
00032 class NVB2Attribute
00033 {
00034   public:
00035     ~NVB2Attribute();
00036
00037   public:
00038     std::map<std::string,NVB2Attribute*> entries;
00039     unsigned int                    arraySize;
00040     unsigned int                    arrayType;
00041     std::vector<char>                    array;
00042     unsigned int                    udWord;
00043 };
00044
00045 class NVB2Material
00046 {
00047   public:
00048     std::string               name;
00049     std::vector<unsigned int> textureIdxs;
00050     std::vector<unsigned int> textureChannels;
00051     nvmath::Vec4f             diffuse;
00052     nvmath::Vec4f             specular;
00053     float                     shininess;
00054     nvmath::Vec4f             ambient;
00055     nvmath::Vec4f             emission;
00056     float                     transparency;
00057     bool                      fog;
00058     nvmath::Vec4f             fogColor;
00059     NVB2Attribute             attribute;
00060
00061     nvsg::StateSetHandle    * stateSet;
00062 };
00063
00064 class NVB2TexCoordSet
00065 {
00066   public:
00067     unsigned int  texDim;
00068     std::vector<float> texCoords;
00069     std::vector<nvmath::Vec3f> binormals;
00070     std::vector<nvmath::Vec3f> tangents;
00071 };
00072
00073 class NVB2Mesh
00074 {
00075   public:
00076     unsigned int            materialID;
00077     std::vector<nvmath::Vec3f>           vertices;
00078     std::vector<nvmath::Vec3f>           normals;
00079     std::vector<nvmath::Vec4f>           colors;
00080     std::vector<nvmath::Vec4f>           weights;
00081     std::vector<unsigned int>    boneIdxs;
00082     std::vector<NVB2TexCoordSet> texCoordSets;
00083     std::vector<unsigned int>    faceIdxs;
00084     NVB2Attribute           attribute;
00085     nvmath::Vec3f                   aabbMin;
00086     nvmath::Vec3f                   aabbMax;
00087 };
00088
00089 class NVB2Texture
00090 {
00091   public:
00092     unsigned int            texType;
00093     std::string                  fileName;
00094     nvmath::Mat44f                  xform;
00095     nvsg::TextureAttributeItemHandle  * textureAttributeItem;
00096 };
00097
00098 class NVB2Node
00099 {
00100   public:
00101     NVB2Node();
00102     virtual ~NVB2Node();
00103
00104   public:
00105     std::string                  name;
00106     nvmath::Mat44f                  xform;
00107     std::vector<unsigned int>    children;
00108     unsigned int            parent;
00109     unsigned int            target;
00110     NVB2Animation           animation;
00111     NVB2Attribute           attribute;
00112
00113     nvmath::Quatf           orientation;
00114     nvmath::Vec3f           position;
00115     nvsg::TransformHandle * transform;
00116 };
00117
00118 class NVB2Camera : public NVB2Node
00119 {
00120   public:
00121     float fieldOfView;
00122     float focalLength;
00123 };
00124
00125 class NVB2Light : public NVB2Node
00126 {
00127   public:
00128     nvmath::Vec4f         color;
00129     nvmath::Vec4f         specular;
00130     nvmath::Vec4f         ambient;
00131     unsigned int  lightType;
00132     float         specularExp;
00133     nvmath::Vec3f         direction;
00134     float         range;
00135     float         attConst;
00136     float         attLinear;
00137     float         attQuadratic;
00138     float         falloff;
00139     float         theta;
00140     float         phi;
00141 };
00142
00143 class NVB2Model : public NVB2Node
00144 {
00145   public:
00146     std::vector<NVB2Mesh>  meshes;
00147     nvmath::Vec3f          aabbMin;
00148     nvmath::Vec3f          aabbMax;
00149 };
00150
00151 class NVNVB2
00152 {
00153   public:
00154     NVNVB2();
00155
00156   public:
00157     nvsg::SceneHandle * load( const std::string& filename, const std::vector<std::string> &searchPaths
00158                             , nvsg::ViewStateHandle *& viewState );
00159
00160   private:
00161     void          interpretAttribute( NVB2Attribute &attribute );
00162     void          interpretCamera( NVB2Camera *camera );
00163     void          interpretLight( NVB2Light *light );
00164     void          interpretMaterials( void );
00165     void          interpretMesh( NVB2Mesh &mesh, nvsg::GeoNode *geoNode );
00166     void          interpretModel( NVB2Model *node );
00167     void          interpretNode( NVB2Node *node );
00168     void          interpretNodes( void );
00169     void          interpretTextures( void );
00170     void          interpretTransform( NVB2Node *node );
00171     void          loadAnimation( NVB2Animation &animation );
00172     void          loadAttribute( NVB2Attribute &attribute );
00173     void          loadCamera( NVB2Camera *camera );
00174     void          loadLight( NVB2Light *light );
00175     unsigned int  loadMaterial( NVB2Material &material );
00176     void          loadMesh( NVB2Mesh &mesh );
00177     void          loadModel( NVB2Model *node );
00178     void          loadNode( NVB2Node *node );
00179     void          loadScene( void );
00180     void          loadTexCoordSet( NVB2TexCoordSet &texCoordSet );
00181     void          loadTexture( NVB2Texture &texture );
00182
00183   private:
00184     FILE                        * m_fh;
00185     std::vector<NVB2Node*>        m_nodes;
00186     std::vector<NVB2Material>     m_materials;
00187     nvsg::SceneHandle           * m_scene;
00188     std::vector<std::string>      m_searchPaths;
00189     std::vector<NVB2Texture>      m_textures;
00190     nvsg::ViewStateHandle       * m_viewState;
00191 };
00192
00193 typedef enum
00194 {
00195     LT_ANONYMOUS,
00196     LT_POINT,
00197     LT_DIRECTIONAL,
00198     LT_SPOT
00199 } NVB2LightType;
00200
00201 typedef enum
00202 {
00203     NT_ANONYMOUS       = 0x00000000,
00204     NT_GEOMETRY        = 0x00000001,
00205     NT_LIGHT           = 0x00000002,
00206     NT_CAMERA          = 0x00000003
00207 } NVB2NodeType;
00208
00209 typedef enum
00210 {
00211     NVB2TT_CUSTOM              = 0x00000000,
00212     NVB2TT_AMBIENT             = 0x00000001,
00213     NVB2TT_DIFFUSE             = 0x00000002,
00214     NVB2TT_SPECULAR            = 0x00000003, // specular color map
00215     NVB2TT_SPECULAR_POWER      = 0x00000004, // specular highlight map
00216     NVB2TT_GLOSS               = 0x00000005,
00217     NVB2TT_SELF_ILLUMATION     = 0x00000006,
00218     NVB2TT_BUMP                = 0x00000007,
00219     NVB2TT_NORMAL              = 0x00000008,
00220     NVB2TT_OPACITY             = 0x00000009,
00221     NVB2TT_REFLECTION          = 0x0000000A,
00222     NVB2TT_REFRACTION          = 0x0000000B,
00223     NVB2TT_CUBE_MAP            = 0x0000000C
00224 } NVB2TexType;
00225
00226 enum
00227 {
00228     NV_FLOAT                = 0x00000001,
00229     NV_CHAR                 = 0x00000002,
00230     NV_UNSIGNED_CHAR        = 0x00000004,
00231     NV_UNSIGNED_INT         = 0x00000008,
00232     NV_INT                  = 0x00000010,
00233     NV_SHORT                = 0x00000040,
00234
00235     NV_ARRAY                = 0x00010000,
00236     NV_FLOAT_ARRAY          = 0x00010001,
00237     NV_CHAR_ARRAY           = 0x00010002,
00238     NV_UNSIGNED_CHAR_ARRAY  = 0x00010004,
00239     NV_UNSIGNED_INT_ARRAY   = 0x00010008,
00240     NV_INT_ARRAY            = 0x00010010,
00241     NV_ATTRIBUTE_ARRAY      = 0x00010020,
00242     NV_SHORT_ARRAY          = 0x00010040,
00243     NV_STRING               = 0x00010002,
00244
00245     NV_UNASSIGNED           = 0xFFFFFFFF
00246 };
00247
00248 #endif  //  DOXYGEN_IGNORE
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvsg.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CgFx.h"
#include "nvutil/BitMask.h"
#include <string>
#include <vector>

Include dependency graph for nvsg.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg

Functions

void | nvsgLibInit () __attribute__((constructor))
void | nvsgLibExit () __attribute__((destructor))
void | enterCritSec ()
void | leaveCritSec ()

Detailed Description

Generated on Tue Jan 15 10:28:01 2008 for NVSGSDK by NVIDIA


nvsg.h Source File

nvsg.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/CgFx.h"
00017 #include "nvutil/BitMask.h"
00018
00019 #include <string>
00020 #include <vector>
00021
00022 #if defined(LINUX)
00023 // Linux specific library entry points
00024 void nvsgLibInit() __attribute__((constructor));
00025 void nvsgLibExit() __attribute__((destructor));
00026 #endif
00027
00028 extern void enterCritSec();
00029 extern void leaveCritSec();
00030
00032
00034 namespace nvsg
00035 {
00036   enum NVSGThreadingModelEnum
00037   {
00038     NVSG_SINGLETHREADED = 0
00039   , NVSG_MULTITHREADED
00040   };
00041
00042   enum NVSG3DAPIEnum
00043   {
00044     NVSG_3DAPI_GL = 0
00045   };
00046
00047   enum NVSGFeatureSupportedEnum
00048   {
00049     NVSG_FAST_TEXTURE_UPLOAD  = BIT0,
00050     NVSG_VOLUME_RENDERING     = BIT1
00051   };
00052
00054
00083   NVSG_API void nvsgInitialize( NVSGThreadingModelEnum threadingModel = NVSG_SINGLETHREADED
00084                               , NVSG3DAPIEnum graphicsAPI = NVSG_3DAPI_GL );
00085
00087
00091   NVSG_API void nvsgTerminate();
00092
00094   NVSG_API void getVersionString(
00095     std::string & string
00096   );
00097
00099   NVSG_API void getSDKName(
00100     std::string & string
00101   );
00102
00104   NVSG_API void getCopyrightString(
00105     std::string & string
00106   );
00107
00109   NVSG_API void getVendorName(
00110     std::string & string
00111   );
00112
00117   NVSG_API unsigned int getSupportedFeatures();
00118 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NVSGLight.cg File Reference

Classes

struct NVSGLight
The NVSGLight structure specifies the data layout for an effect light parameter. More...

Detailed Description

Generated on Tue Jan 15 10:28:01 2008 for NVSGSDK by NVIDIA


NVSGLoader.h File Reference

#include <fstream>
#include "nvsg/nvsgapi.h"
#include "nvsg/CoreTypes.h"
#include "nvsg/PlugInterface.h"
#include "nvsg/Skin.h"
#include "nvutil/Tools.h"

Include dependency graph for NVSGLoader.h:

Include dependency graph

Go to the source code of this file.

Classes

class | NVSGLoader
A Scene Loader for nvsg files. More...

Typedefs

typedef unsigned int | DWORD
typedef bool | BOOL

Functions

void | lib_init () __attribute__((constructor))
NVSGLOADER_API bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

NVSGLOADER_API bool | queryPlugInterfaceType (const nvutil::UPITID &pitid, std::vector< nvutil::UPIID > &piids)
Query the supported types of PlugIn Interfaces.

Detailed Description

Function Documentation

NVSGLOADER_API bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) |

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a NVSGLoader. If the PlugIn ID piid equals PIID_NVSG_SCENE_LOADER, a NVSGLoader is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

NVSGLOADER_API bool queryPlugInterfaceType | ( | const nvutil::UPITID & | pitid,
 |  | std::vector< nvutil::UPIID > & | piids
 | ) |

Query the supported types of PlugIn Interfaces.

Every PlugIn has to resolve this function. It is used to query the supported Interface types of this PlugIn. If the Plug In Type ID pitid equals PITID_SCENE_LOADER, the vector piids is filled with one element PIID_NVSG_SCENE_LOADER.

Returns:
true, if a PITID_SCENE_LOADER is requested, otherwise false

Generated on Tue Jan 15 10:28:01 2008 for NVSGSDK by NVIDIA


NVSGLoader.h Source File

NVSGLoader.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include  <fstream>
00016 #include  "nvsg/nvsgapi.h"
00017 #include  "nvsg/CoreTypes.h"
00018 #include  "nvsg/PlugInterface.h"
00019 #include  "nvsg/Skin.h"
00020 #include  "nvutil/Tools.h"
00021
00022 // storage-class defines
00023 #if ! defined( DOXYGEN_IGNORE )
00024 # if defined(_WIN32)
00025 #  ifdef NVSGLOADER_EXPORTS
00026 #   define NVSGLOADER_API __declspec(dllexport)
00027 #  else
00028 #   define NVSGLOADER_API __declspec(dllimport)
00029 #  endif
00030 # else
00031 #   define NVSGLOADER_API
00032 # endif
00033 #endif
00034
00035 #if defined(LINUX)
00036 typedef unsigned int DWORD;
00037 typedef bool BOOL;
00038 void lib_init() __attribute__ ((constructor));   // will be called before dlopen() returns
00039 #endif
00040
00041 // exports required for a scene loader plug-in
00042 #if defined(LINUX)
00043 extern "C"
00044 {
00045 #endif
00046
00048
00052 NVSGLOADER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00053
00055
00060 NVSGLOADER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00061
00062 #if defined(LINUX)
00063 }
00064 #endif
00065
00067
00069 class NVSGLoader : public nvsg::SceneLoader
00070 {
00071   public :
00072     //  Default constructor.
00073     NVSGLoader();
00074     ~NVSGLoader();
00075
00076   public :
00078
00079     void  deleteThis( void );
00080
00082
00087     nvsg::SceneHandle * load( const std::string& filename
00088                             , const std::vector<std::string> &searchPaths
00089                             , nvsg::ViewStateHandle *& viewState
00091                             );
00092
00093   private :
00094     void                                                cleanup( void );
00095     bool                                                getNextLine( void );
00096     const std::string                                 & getNextToken( void );
00097     nvsg::SceneHandle                                 * import( const std::string &filename, nvsg::ViewStateHandle *& viewState );
00098     bool                                                onIncompatibleValues( int value0, int value1, const std::string &node, const std::string &field0, const std::string &field1 ) const;
00099     template<typename T> bool                           onInvalidValue( T value, const std::string &node, const std::string &field ) const;
00100     bool                                                onEmptyToken( const std::string &tokenType, const std::string &token ) const;
00101     bool                                                onFileNotFound( const std::string &file ) const;
00102     bool                                                onFilesNotFound( bool found, const std::vector<std::string> &files ) const;
00103     void                                                onUnexpectedEndOfFile( bool error ) const;
00104     void                                                onUnexpectedToken( const std::string &expected, const std::string &token ) const;
00105     void                                                onUnknownToken( const std::string &context, const std::string &token ) const;
00106     bool                                                onUndefinedToken( const std::string &context, const std::string &token ) const;
00107     bool                                                onUnsupportedToken( const std::string &context, const std::string &token ) const;
00108     nvsg::Billboard::Alignment                          readAlignment();
00109     nvsg::AlphaTestAttributeHandle                    * readAlphaTestAttribute( const char *name );
00110     nvsg::AlphaFunction                                 readAlphaFunction( void );
00111     nvsg::AnimatedTransformHandle                     * readAnimatedTransform( const char *name, const std::string & extName );
00112     nvsg::AnimatedVertexAttributeSetHandle            * readAnimatedVertexAttributeSet( const char *name );
00113     template<typename T> bool                           readAnimationToken( nvsg::Animation<T> *a, std::string & token );
00114     void                                                readAttributes( std::vector<nvsg::StateAttributeHandle*> &attribs );
00115     nvsg::BillboardHandle                             * readBillboard( const char *name, const std::string & extName );
00116     nvsg::BlendAttributeHandle                        * readBlendAttribute( const char *name );
00117     nvsg::BlendFunction                                 readBlendFunction( void );
00118     bool                                                readBool( void );
00119     bool                                                readCameraToken( nvsg::Camera * pc, const char *token );
00120     nvsg::CgFxHandle                                  * readCgFx( const char *name );
00121     nvsg::NodeHandle                                  * readChild( const char *token = NULL );
00122     void                                                readChildren( nvsg::Group *g );
00123     unsigned int                                        readCount( const char *token = NULL );
00124     unsigned int                                        readType( const char *token = NULL );
00125     nvsg::DepthAttributeHandle                        * readDepthAttribute( const char *name );
00126     nvsg::DepthFunction                                 readDepthFunction( void );
00127     nvsg::DirectedLightHandle                         * readDirectedLight( const char *name );
00128     DWORD                                               readDWORD( void );
00129     nvsg::FaceAttributeHandle                         * readFaceAttribute( const char *name );
00130     nvsg::FaceMode                                      readFaceMode( void );
00131     nvsg::FlipbookAnimationHandle                     * readFlipbookAnimation( const char *name, const std::string & extName );
00132     float                                               readFloat( const std::string &token );
00133     void                                                readFloats( std::vector<float> &v );
00134     nvsg::FramedIndexAnimationHandle                  * readFramedIndexAnimation( const char *name );
00135     nvsg::FramedTrafoAnimationHandle                  * readFramedTrafoAnimation( const char *name );
00136     nvsg::FramedVertexAttributeAnimationHandle        * readFramedVertexAttributeAnimation( const char *name );
00137     nvsg::GeoNodeHandle                               * readGeoNode( const char *name );
00138     nvsg::GroupHandle                                 * readGroup( const char *name, const std::string & extName );
00139     bool                                                readGroupToken( nvsg::Group *g, const char *token, const std::string & extName );
00140     void                                                readImages( nvsg::TextureImage * ti );
00141     bool                                                readIndependentPrimitiveSetToken( nvsg::IndependentPrimitiveSet * ips, const char *token );
00142     void                                                readIndexMesh( nvsg::IndexMesh &im, const char *token );
00143     void                                                readIndexSet( nvsg::IndexSet &v, const char *token );
00144     long                                                readInt( const char *token = NULL );
00145     void                                                readInts( std::vector<unsigned int> &ints );
00146     nvsg::LinearInterpolatedTrafoAnimationHandle      * readLinearInterpolatedTrafoAnimation( const char *name );
00147     nvsg::LinearInterpolatedVertexAttributeAnimationHandle * readLinearInterpolatedVertexAttributeAnimation( const char *name );
00148     nvsg::LightingAttributeHandle                     * readLightingAttribute( const char *token );
00149     nvsg::LightSourceHandle                           * readLightSource( const char *token );
00150     bool                                                readLightSourceToken( nvsg::LightSource *ls, const std::string &token );
00151     nvsg::LineAttributeHandle                         * readLineAttribute( const char *name );
00152     nvsg::LinesHandle                                 * readLines( const char *name );
00153     nvsg::LineStripsHandle                            * readLineStrips( const char *name );
00154     nvsg::LODHandle                                   * readLOD( const char *name, const std::string & extName );
00155     nvmath::Mat33f                                      readMat33f( void );
00156     nvmath::Mat44f                                      readMat44f( void );
00157     nvsg::MaterialHandle                              * readMaterial( const char *name );
00158     bool                                                readMeshedPrimitiveSetToken( nvsg::MeshedPrimitiveSet * mps, const char *token );
00159     void                                                readMeshes( std::vector<nvsg::IndexMesh> &meshes );
00160     void                                                readMipmaps( unsigned int width, unsigned int height, unsigned int depth, unsigned int noc, nvsg::Image::PixelDataType pt, std::vector<const void *> & mipmaps );
00161     std::string                                         readName( const char *t = NULL );
00162     bool                                                readNodeToken( nvsg::Node *n, const char *token );
00163     bool                                                readObjectToken( nvsg::Object *n, const char *token );
00164     void                                                readPairsOfVec2fs( std::vector<std::pair<nvmath::Vec2f,nvmath::Vec2f> > &pairs );
00165     void                                                readVectorOfVec2fs( std::vector<nvmath::Vec2f > &vectors );
00166     nvsg::ParallelCameraHandle                        * readParallelCamera( const char *name );
00167     void                                                readPasses( std::vector<nvsg::StatePassHandle*> &passes );
00168     nvsg::PerspectiveCameraHandle                     * readPerspectiveCamera( const char *name );
00169     nvsg::Image::PixelFormat                            readPixelFormat();
00170     nvsg::Image::PixelDataType                          readPixelType();
00171     void                                              * readPixels( unsigned int nov, nvsg::Image::PixelDataType pt );
00172     nvsg::PointAttributeHandle                        * readPointAttribute( const char *name );
00173     nvsg::PointLightHandle                            * readPointLight( const char *name );
00174     nvsg::PointsHandle                                * readPoints( const char *name );
00175     bool                                                readPrimitiveSetToken( nvsg::PrimitiveSet * p, const char *token );
00176     nvsg::QuadMeshesHandle                            * readQuadMeshes( const char *name );
00177     nvsg::QuadsHandle                                 * readQuads( const char *name );
00178     nvsg::QuadStripsHandle                            * readQuadStrips( const char *name );
00179     bool                                                readQuadsToken( nvsg::Quads *q, const char *token );
00180     nvmath::Quatf                                       readQuatf( const std::string &token );
00181     void                                                readSampler(nvsg::CgFxEffect * effect, const std::string& name);
00182     nvsg::SceneHandle                                 * readScene( void );
00183     nvsg::SkinHandle                                  * readSkin( const char *name );
00184     nvsg::SkinnedTrianglesHandle                      * readSkinnedTriangles( const char *name );
00185     nvsg::SkinnedTriangles::Skin                        readSkinnedTriangleSkin( const std::string &token );
00186     nvsg::Skin::SkinningType                            readSkinningType();
00187     void                                                readSkinningTypes( nvsg::Skin * skin );
00188     void                                                readSkins( std::vector<nvsg::SkinnedTriangles::Skin> &skins );
00189     nvsg::SpotLightHandle                             * readSpotLight( const char *name );
00190     nvsg::StatePassHandle                             * readStatePass( const char *name );
00191     nvsg::StateSetHandle                              * readStateSet( const char *name );
00192     nvsg::StateVariantHandle                          * readStateVariant( const char *name );
00193     bool                                                readStrippedPrimitiveSetToken( nvsg::StrippedPrimitiveSet * sps, const char *token );
00194     void                                                readStrips( std::vector<nvsg::IndexSet> &strips );
00195     nvsg::SwitchHandle                                * readSwitch( const char *name, const std::string & extName );
00196     void                                                readTexGen( nvsg::TextureAttributeItem * texItem );
00197     nvsg::TextureAttributeHandle                      * readTextureAttribute( const char *name );
00198     nvsg::TextureAttributeItemHandle                  * readTextureAttributeItem( const char *name );
00199     void                                                readTextureAttributeItems(std::vector<nvsg::TextureAttributeItemHandle*>& texItems);
00200     nvsg::TextureEnvMode                                readTextureEnvMode( void );
00201     nvsg::TextureMagFilterMode                          readTextureMagFilterMode( void );
00202     nvsg::TextureMinFilterMode                          readTextureMinFilterMode( void );
00203     nvsg::TextureTarget                                 readTextureTarget();
00204     nvsg::TextureWrapMode                               readTextureWrapMode( void );
00205     nvsg::TextureImageHandle                          * readTextureImage( const char *name );
00206     nvsg::TransformHandle                             * readTransform( const char *name, const std::string & extName );
00207     bool                                                readTransformToken( nvsg::Transform *t, const char *token, const std::string & extName );
00208     nvsg::TrianglesHandle                             * readTriangles( const char *name );
00209     bool                                                readTrianglesToken( nvsg::Triangles *t, const char *token );
00210     nvsg::TriFansHandle                               * readTriFans( const char *name );
00211     nvsg::TriStripsHandle                             * readTriStrips( const char *name );
00212     void                                                readTweak(nvsg::CgFxEffect * effect, const std::string& name);
00213     nvsg::UnlitColorAttributeHandle                   * readUnlitColorAttribute( const char *name );
00214     void                                                readVariants( std::map<nvsg::VariantKey,nvsg::StateVariantHandle*> &variants );
00215     nvmath::Vec2f                                       readVec2f( const std::string &token );
00216     void                                                readVec2fs( std::vector<nvmath::Vec2f> &vecs );
00217     nvmath::Vec3f                                       readVec3f( const std::string &token );
00218     void                                                readVec3fs( std::vector<nvmath::Vec3f> &vecs );
00219     nvmath::Vec4f                                       readVec4f( const std::string &token );
00220     void                                                readVec4fs( std::vector<nvmath::Vec4f> &vecs );
00221     void                                                readVertexData( unsigned int type, unsigned char * vdata, std::string token );
00222     nvsg::VertexAttributeSetHandle                    * readVertexAttributeSet( const char *name );
00223     bool                                                readVertexAttributeSetToken( nvsg::VertexAttributeSet *vas, const char *token );
00224     nvsg::ViewStateHandle                             * readViewState( void );
00225     nvsg::VolumeNodeHandle                            * readVolumeNode( const char *name );
00226     void                                                storeTextureImage( const std::string & name, nvsg::TextureImageHandle * tih );
00227     bool                                                testNVSGVersion( void );
00228
00229     template<unsigned int n>      nvsg::Face<n>   readFace( const char *token );
00230     template<unsigned int n>      void            readFaces( std::vector<nvsg::Face<n> > &faces );
00231     template<typename T>          void            readPixelComponent( const std::string & token, T & pc );
00232     template<typename T>          void          * readPixels( unsigned int nov );
00233     template<typename ObjectType> void            storeNamedObject(const std::string& name, std::map<std::string, ObjectType*>& container, ObjectType * obj);
00234
00235   private :
00236     std::map<std::string,nvsg::AlphaTestAttributeHandle*>                           m_alphaTestAttributes;
00237     std::map<std::string,nvsg::AnimatedTransformHandle*>                            m_animatedTransforms;
00238     std::map<std::string,nvsg::AnimatedVertexAttributeSetHandle*>                   m_animatedVertexAttributeSets;
00239     std::map<std::string,nvsg::BillboardHandle*>                                    m_billboards;
00240     std::map<std::string,nvsg::BlendAttributeHandle*>                               m_blendAttributes;
00241     std::map<std::string,nvsg::CgFxHandle*>                                         m_cgfxs;
00242     nvmath::Vec3f                                                                   m_cameraDirection;
00243     nvmath::Vec3f                                                                   m_cameraUpVector;
00244     char                                                                          * m_currentLine;
00245     unsigned int                                                                    m_currentLineLength;
00246     std::string                                                                     m_currentString;
00247     std::string                                                                     m_currentToken;
00248     std::map<std::string,nvsg::DepthAttributeHandle*>                               m_depthAttributes;
00249     std::map<std::string,nvsg::DirectedLightHandle*>                                m_directedLights;
00250     bool                                                                            m_eof;
00251     std::map<std::string,nvsg::FaceAttributeHandle*>                                m_faceAttributes;
00252     std::map<std::string,nvsg::FlipbookAnimationHandle*>                            m_flipbookAnimations;
00253     std::map<std::string,nvsg::FramedIndexAnimationHandle*>                         m_framedIndexAnimations;
00254     std::map<std::string,nvsg::FramedTrafoAnimationHandle*>                         m_framedTrafoAnimations;
00255     std::map<std::string,nvsg::FramedVertexAttributeAnimationHandle*>               m_framedVertexAttributeAnimations;
00256     std::map<std::string,nvsg::GeoNodeHandle*>                                      m_geoNodes;
00257     std::map<std::string,nvsg::GroupHandle*>                                        m_groups;
00258     std::ifstream                                                                   m_ifs;
00259     unsigned int                                                                    m_line;
00260     std::map<std::string,nvsg::LinearInterpolatedTrafoAnimationHandle*>             m_linearInterpolatedTrafoAnimations;
00261     std::map<std::string,nvsg::LinearInterpolatedVertexAttributeAnimationHandle*>   m_linearInterpolatedVertexAttributeAnimations;
00262     std::map<std::string,nvsg::LightingAttributeHandle*>                            m_lightingAttributes;
00263     std::map<std::string,nvsg::LineAttributeHandle*>                                m_lineAttributes;
00264     std::map<std::string,nvsg::LinesHandle*>                                        m_lines;
00265     std::map<std::string,nvsg::LineStripsHandle*>                                   m_lineStrips;
00266     std::map<std::string,nvsg::LODHandle*>                                          m_LODs;
00267     std::map<std::string,nvsg::MaterialHandle*>                                     m_materials;
00268     std::map<std::string,nvsg::ParallelCameraHandle*>                               m_parallelCameras;
00269     std::map<std::string,nvsg::PerspectiveCameraHandle*>                            m_perspectiveCameras;
00270     std::map<std::string,nvsg::PointAttributeHandle*>                               m_pointAttributes;
00271     std::map<std::string,nvsg::PointLightHandle*>                                   m_pointLights;
00272     std::map<std::string,nvsg::PointsHandle*>                                       m_points;
00273     std::map<std::string,nvsg::QuadMeshesHandle*>                                   m_quadMeshes;
00274     std::map<std::string,nvsg::QuadsHandle*>                                        m_quads;
00275     std::map<std::string,nvsg::QuadStripsHandle*>                                   m_quadStrips;
00276     nvsg::SceneHandle                                                             * m_scene;
00277     std::map<std::string,nvsg::GroupHandle*>                                        m_skeletons;
00278     std::map<std::string,nvsg::SkinnedTrianglesHandle*>                             m_skinnedTriangles;
00279     std::map<std::string,nvsg::SkinHandle*>                                         m_skins;
00280     std::map<std::string,nvsg::SpotLightHandle*>                                    m_spotLights;
00281     std::map<std::string,nvsg::StatePassHandle*>                                    m_statePasses;
00282     std::map<std::string,nvsg::StateSetHandle*>                                     m_stateSets;
00283     std::map<std::string,nvsg::StateVariantHandle*>                                 m_stateVariants;
00284     std::vector<std::string>                                                        m_searchPaths;
00285     std::vector<std::pair<nvsg::SkinHandle*,std::vector<std::pair<std::string,nvmath::Mat44f> > > > m_skinJointData;
00286     std::map<std::string,nvsg::SwitchHandle*>                                       m_switches;
00287     std::map<std::string,nvsg::TextureAttributeHandle*>                             m_textureAttributes;
00288     std::map<std::string,nvsg::TextureAttributeItemHandle*>                         m_textureAttributeItems;
00289     std::map<std::string,nvsg::TextureImageHandle*>                                 m_textureImages;
00290     std::map<std::string,nvsg::TransformHandle*>                                    m_transforms;
00291     std::map<std::string,nvsg::TrianglesHandle*>                                    m_triangles;
00292     std::map<std::string,nvsg::TriFansHandle*>                                      m_triFans;
00293     std::map<std::string,nvsg::TriStripsHandle*>                                    m_triStrips;
00294     std::map<std::string,nvsg::UnlitColorAttributeHandle*>                          m_unlitColorAttributes;
00295     std::map<std::string,nvsg::VertexAttributeSetHandle*>                           m_vertexAttributeSets;
00296     std::map<std::string,nvsg::VolumeNodeHandle*>                                   m_volumeNodes;
00297     nvutil::StrTokenizer                                                            m_strTok;
00298 };
00299
00300 inline void NVSGLoader::deleteThis( void )
00301 {
00302   delete this;
00303 }
00304
00305 template<unsigned int n>
00306 inline nvsg::Face<n> NVSGLoader::readFace( const char *token )
00307 {
00308   nvsg::Face<n> f;
00309   f[0] = (UINT) readCount( token );
00310   for ( unsigned int i=1 ; i<n ; i++ )
00311   {
00312     f[i] = (UINT) readCount();
00313   }
00314   return( f );
00315 }
00316
00317 template<unsigned int n>
00318 inline void  NVSGLoader::readFaces( std::vector<nvsg::Face<n> > &faces )
00319 {
00320   faces.clear();
00321   const char * token = getNextToken().c_str();
00322   onUnexpectedToken( "[", token );
00323   token = getNextToken().c_str();
00324   while ( strcmp( token, "]" ) )
00325   {
00326     faces.push_back( readFace<n>( token ) );
00327     token = getNextToken().c_str();
00328   }
00329 }
00330
00331 template <typename ObjectType>
00332 inline void NVSGLoader::storeNamedObject( const std::string& name
00333                                         , std::map<std::string, ObjectType*>& container
00334                                         , ObjectType * obj )
00335 {
00336   if ( obj )
00337   {
00338     if ( container.find( name ) != container.end() )
00339     {
00340       container[name]->removeRef();
00341     }
00342     obj->addRef();
00343     container[name] = obj;
00344   }
00345 }
00346
00347 inline void NVSGLoader::storeTextureImage( const std::string & name, nvsg::TextureImageHandle * tih )
00348 {
00349   if ( tih )
00350   {
00351     if ( m_textureImages.find( name ) != m_textureImages.end() )
00352     {
00353       m_textureImages[name]->removeRef();
00354     }
00355     tih->addRef();
00356     m_textureImages[name] = tih;
00357   }
00358 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NVSGMaterial.cg File Reference

Classes

struct NVSGMaterial
The NVSGMaterial structure specifies the data layout for an effect material parameter. More...

Detailed Description

Generated on Tue Jan 15 10:28:01 2008 for NVSGSDK by NVIDIA


NVSGSaver.h File Reference

#include <set>
#include "nvsg/nvsgapi.h"
#include "nvsg/MeshedPrimitiveSet.h"
#include "nvsg/PlugInterface.h"
#include "nvsg/StateAttribute.h"
#include "nvsg/StrippedPrimitiveSet.h"
#include "nvsg/ViewState.h"
#include "nvtraverser/Traverser.h"

Include dependency graph for NVSGSaver.h:

Include dependency graph

Go to the source code of this file.

Classes

class | NVSGSaveTraverser
A Traverser to traverse a scene on saving to nvsg file format. More...

class | NVSGSaver
A Scene Saver for nvsg files. More...

Functions

NVSGSAVER_API bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

NVSGSAVER_API bool | queryPlugInterfaceType (const nvutil::UPITID &pitid, std::vector< nvutil::UPIID > &piids)
Query the supported types of PlugIn Interfaces.

Detailed Description

Function Documentation

NVSGSAVER_API bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) |

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a NVSGSaver. If the PlugIn ID piid equals PIID_NVSG_SCENE_SAVER, a NVSGSaver is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

NVSGSAVER_API bool queryPlugInterfaceType | ( | const nvutil::UPITID & | pitid,
 |  | std::vector< nvutil::UPIID > & | piids
 | ) |

Query the supported types of PlugIn Interfaces.

Every PlugIn has to resolve this function. It is used to query the supported Interface types of this PlugIn. If the Plug In Type ID pitid equals PITID_SCENE_SAVER, the vector piids is filled with one element PIID_NVSG_SCENE_SAVER.

Returns:
true, if a PITID_SCENE_SAVER is requested, otherwise false

Generated on Tue Jan 15 10:28:01 2008 for NVSGSDK by NVIDIA


NVSGSaver.h Source File

NVSGSaver.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include  <set>
00016 #include  "nvsg/nvsgapi.h"
00017 #include  "nvsg/MeshedPrimitiveSet.h"
00018 #include  "nvsg/PlugInterface.h"
00019 #include  "nvsg/StateAttribute.h"
00020 #include  "nvsg/StrippedPrimitiveSet.h"
00021 #include  "nvsg/ViewState.h"
00022 #include  "nvtraverser/Traverser.h"
00023
00024
00025 //  Don't need to document the API specifier
00026 #if ! defined( DOXYGEN_IGNORE )
00027 #if defined(_WIN32)
00028 # ifdef NVSGSAVER_EXPORTS
00029 #  define NVSGSAVER_API __declspec(dllexport)
00030 # else
00031 #  define NVSGSAVER_API __declspec(dllimport)
00032 # endif
00033 #else
00034 # define NVSGSAVER_API
00035 #endif
00036 #endif  //  DOXYGEN_IGNORE
00037
00038 // exports required for a scene loader plug-in
00039 #if defined(LINUX)
00040 extern "C"
00041 {
00042 #endif
00043
00044
00049 NVSGSAVER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00050
00052
00057 NVSGSAVER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00058 #if defined(LINUX)
00059 }
00060 #endif
00061
00063
00064 class NVSGSaveTraverser : public nvtraverser::SharedTraverser
00065 {
00066   public:
00068     NVSGSaveTraverser();
00069
00071     void  setFILE( FILE *fh
00072                  );
00073
00074   protected:
00075     bool preApply( nvsg::NodeHandle * root );
00076
00078
00079     void doApply( nvsg::NodeHandle * root );
00080
00081     // overloads to process concrete types for saving
00082     // ...Cameras
00084
00086     virtual void handleParallelCamera(const nvsg::ParallelCamera *p);
00087
00089
00091     virtual void handlePerspectiveCamera(const nvsg::PerspectiveCamera *p);
00092
00093     // ...Nodes
00095
00096     virtual void handleBillboard(const nvsg::Billboard *p);
00097
00099
00100     virtual void handleGeoNode(const nvsg::GeoNode *p);
00101
00103
00104     virtual void handleVolumeNode(const nvsg::VolumeNode *p);
00105
00107
00108     virtual void handleGroup( const nvsg::Group *p );
00109
00111
00113     virtual void handleFlipbookAnimation(const nvsg::FlipbookAnimation *p);
00114
00116
00117     virtual void handleTransform(const nvsg::Transform *p);
00118
00120
00122     virtual void handleAnimatedTransform(const nvsg::AnimatedTransform *p);
00123
00125
00127     virtual void handleLOD(const nvsg::LOD *p);
00128
00130
00132     virtual void handleSwitch(const nvsg::Switch *p);
00133
00135
00137     virtual void handleDirectedLight(const nvsg::DirectedLight *p);
00138
00140
00142     virtual void handlePointLight(const nvsg::PointLight *p);
00143
00145
00147     virtual void handleSpotLight(const nvsg::SpotLight *p);
00148
00149     // ...StateSet
00151
00153     virtual void handleStateSet(const nvsg::StateSet *p);
00154
00156
00158     virtual void handleStateVariant(const nvsg::StateVariant *p);
00159
00161
00163     virtual void handleStatePass(const nvsg::StatePass *p);
00164
00165     // ...StateAttribs
00167
00168     virtual void handleBlendAttribute(const nvsg::BlendAttribute *p);
00169
00171
00172     virtual void handleCgFx(const nvsg::CgFx *p);
00173
00175
00176     virtual void handleDepthAttribute(const nvsg::DepthAttribute *p);
00177
00179
00180     virtual void handleFaceAttribute(const nvsg::FaceAttribute *p);
00181
00183
00184     virtual void handleLineAttribute(const nvsg::LineAttribute *p);
00185
00187
00188     virtual void handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *p);
00189
00191
00192     virtual void handleLightingAttribute(const nvsg::LightingAttribute *p);
00193
00195
00196     virtual void handleMaterial(const nvsg::Material *p);
00197
00199
00200     virtual void handlePointAttribute(const nvsg::PointAttribute *p);
00201
00203
00204     virtual void handleTextureAttribute(const nvsg::TextureAttribute *p);
00205
00207
00208     virtual void handleTextureAttributeItem(const nvsg::TextureAttributeItem * p, unsigned int tu);
00209
00211
00212     virtual void handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *p);
00213
00214     // ...GeoSets
00216
00217     virtual void handleTriangles(const nvsg::Triangles *p);
00218
00220
00222     virtual void handleSkinnedTriangles(const nvsg::SkinnedTriangles *p);
00223
00225
00226     virtual void handleTriFans(const nvsg::TriFans *p);
00227
00229
00230     virtual void handleTriStrips(const nvsg::TriStrips *p);
00231
00233
00234     virtual void handleQuadMeshes(const nvsg::QuadMeshes *p);
00235
00237
00238     virtual void handleQuads(const nvsg::Quads *p);
00239
00241
00242     virtual void handleQuadStrips(const nvsg::QuadStrips *p);
00243
00245
00246     virtual void handleLines(const nvsg::Lines *p);
00247
00249
00250     virtual void handleLineStrips(const nvsg::LineStrips *p);
00251
00253
00254     virtual void handlePoints(const nvsg::Points *p);
00255
00257
00258     virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *p );
00259
00261
00262     virtual void handleAnimatedVertexAttributeSet( const nvsg::AnimatedVertexAttributeSet * p );
00263
00265
00266     virtual void handleSkin( const nvsg::Skin * p );
00267
00268     // ... Animations
00270
00271     virtual void handleFramedIndexAnimation(const nvsg::FramedAnimation<unsigned int> *p);
00272
00274
00275     virtual void handleFramedTrafoAnimation(const nvsg::FramedAnimation<nvmath::Trafo> *p);
00276
00278
00279     virtual void handleFramedVertexAttributeAnimation( const nvsg::FramedAnimation<nvsg::VertexAttribute> *p );
00280
00282
00283     virtual void handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> *p);
00284
00286
00287     virtual void handleLinearInterpolatedVertexAttributeAnimation( const nvsg::LinearInterpolatedAnimation<nvsg::VertexAttribute> *p );
00288
00289 private:
00290     template<typename T> void animationData( const nvsg::Animation<T> *p );
00291     const   std::string  getName( const std::string &name );
00292     std::string  getObjectName( const nvsg::Object *p );
00293     void    objectAnnotation( const nvsg::Object *p ); // writes optional annotation to file
00294     void    groupData( const nvsg::Group *p );
00295     void    independentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p
00296                                    , unsigned int primitiveSize, bool doVerticesAndNormals = true );
00297     void    initUnnamedCounters( void );
00298     bool    isFirstTime( const nvsg::Object *p );
00299     void    lightSourceData( const nvsg::LightSource *p );
00300     void    meshedPrimitiveSet( const nvsg::MeshedPrimitiveSet *p );
00301     void    nodeData( const nvsg::Node *p );
00302     void    primitiveSetData( const nvsg::PrimitiveSet *p );
00303     void    simpleCameraData( const nvsg::Camera *p );
00304     void    strippedPrimitiveSet( const nvsg::StrippedPrimitiveSet *p );
00305     void    textureImage( nvsg::TextureImageHandle * tih );
00306     void    transformData( const nvsg::Transform * p );
00307     void    vertexAttributeSetData( const nvsg::VertexAttributeSet * p );
00308     void    writeTweakable( const nvsg::CgFxEffect * effect, nvsg::CgFxParameter tweak );
00309     void    writeSampler( const nvsg::CgFxEffect * effect, nvsg::CgFxParameter sampler );
00310     void    writeVertexData( const nvsg::VertexAttribute & va );
00311
00312   private:
00313     FILE * m_fh;
00314
00315     std::set<const nvutil::RCObject *>                m_sharedRCObjects;
00316     std::map<nvsg::DataID, std::string>               m_sharedData;
00317     std::vector<std::pair<std::string,std::string> >  m_geometryNames;
00318     std::vector<nvsg::StateAttributeHandle *>         m_attributes;
00319     std::vector<nvsg::StatePassHandle *>              m_passes;
00320     std::vector<nvsg::StateVariantHandle *>           m_variants;
00321     std::vector<nvsg::TextureAttributeItemHandle *>   m_texAttribItems;
00322     nvsg::StateSetHandle *                            m_currentStateSet;
00323     std::map<nvsg::ObjectHandle *, std::string>       m_objectNames;
00324     std::set<std::string>                             m_nameSet;
00325     std::map<nvsg::TextureImageHandle *, std::string> m_textureImageNames;
00326     std::map<nvsg::TransformHandle *, std::string>    m_unnamedTransforms;
00327 };
00328
00330
00332 class NVSGSaver : public nvsg::SceneSaver
00333 {
00334   public :
00336
00337     void  deleteThis( void );
00338
00340
00341     bool  save( nvsg::SceneHandle     *scene
00342               , nvsg::ViewStateHandle *viewState
00343               , const std::string     &filename
00344               );
00345
00346   private :
00347     NVSGSaveTraverser m_traverser;
00348 };
00349
00350 inline void NVSGSaver::deleteThis( void )
00351 {
00352   delete this;
00353 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NVSGScene.cg File Reference

Classes

struct NVSGScene
The NVSGScene structure specifies some global scene relevant data. More...

Detailed Description

Generated on Tue Jan 15 10:28:01 2008 for NVSGSDK by NVIDIA


NVSGVersion.h File Reference

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Detailed Description

Generated on Tue Jan 15 10:28:01 2008 for NVSGSDK by NVIDIA


NVSGVersion.h Source File

NVSGVersion.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #if !defined( DOXYGEN_IGNORE )    //  no need to document the version header
00016 //---------------------------------------------------------------------------
00017 // Version Number
00018 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00019 // - This is the ONLY place to edit the version number.
00020 // - There must be no unnecessary leading zeros in the numbers.
00021 //   (e.g.: don't use '02' - use '2' instead)
00022 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00023 #define NVSG_VER_MAIN        4    // marketing main version
00024 #define NVSG_VER_AUX         0    // marketing auxiliary version
00025
00026 #define NVSG_VER_MAJOR       5
00027 #define NVSG_VER_MINOR       0
00028
00029 #if !defined(NVSG_VER_BUILD)
00030 #define NVSG_VER_BUILD       2
00031 #endif
00032
00033 //#define NVSG_ALPHA
00034 //#define NVSG_BETA
00035
00036 #ifdef LINUX
00037   #define NVSG_BETA
00038 #elif defined _WIN64
00039   #define NVSG_BETA
00040 #endif
00041
00042 // MaKe STRing helper macro
00043 #define MKSTR(s)    MKSTR_i(s)
00044 #define MKSTR_i(s)  MKSTR_ii(s)
00045 #define MKSTR_ii(s) #s
00046
00047 // conditionally add a leading zero to the single parts of the version string
00048 #define NVSG_VER_MAIN_STR           MKSTR(NVSG_VER_MAIN)
00049 #define NVSG_VER_AUX_STR            MKSTR(NVSG_VER_AUX)
00050 #define NVSG_VER_MAJOR_STR          MKSTR(NVSG_VER_MAJOR)
00051 #define NVSG_VER_MINOR_STR          MKSTR(NVSG_VER_MINOR)
00052 #define NVSG_VER_BUILD_STR          MKSTR(NVSG_VER_BUILD)
00053
00054 #define SDK_VENDOR "NVIDIA"
00055 #define SDK_NAME   "NVSG"
00056
00057 // internal version string
00058 #define _VER_STR   NVSG_VER_MAIN_STR "."\
00059                    NVSG_VER_AUX_STR "."\
00060                    NVSG_VER_MAJOR_STR "."\
00061                    NVSG_VER_MINOR_STR "."\
00062                    NVSG_VER_BUILD_STR
00063
00064 // no need to update these
00065 //
00066 #ifdef NVSG_ALPHA
00067   #if !defined(NDEBUG)
00068     #define VERSION_STR   _VER_STR " alpha" " (DEBUG)"
00069   #else  //DEBUG
00070     #define VERSION_STR   _VER_STR " alpha"
00071   #endif //DEBUG
00072 #else
00073   #ifdef NVSG_BETA
00074     #if !defined(NDEBUG)
00075       #define VERSION_STR   _VER_STR " beta (DEBUG)"
00076     #else  //DEBUG
00077       #define VERSION_STR   _VER_STR " beta"
00078     #endif //DEBUG
00079   #else  //BETA
00080     #if !defined(NDEBUG)
00081       #define VERSION_STR   _VER_STR " (DEBUG)"
00082     #else  //DEBUG
00083       #define VERSION_STR   _VER_STR
00084     #endif //DEBUG
00085   #endif //BETA
00086 #endif
00087
00088 #define NVSG_COPYRIGHT   SDK_VENDOR" "SDK_NAME" Version "VERSION_STR"\n© Copyright 2007 NVIDIA Corporation\n";
00089
00090 #endif  //  DOXYGEN_IGNORE
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvtraverser.h File Reference

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:01 2008 for NVSGSDK by NVIDIA


nvtraverser.h Source File

nvtraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015
00016
00020 namespace nvtraverser
00021 {
00022
00023 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvui.h File Reference

#include "nvsgcommon.h"

Include dependency graph for nvui.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:28:02 2008 for NVSGSDK by NVIDIA


nvui.h Source File

nvui.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017
00024 namespace nvui
00025 {
00026
00027 }
00028
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvutil.h File Reference

#include "nvsg/nvsgapi.h"
#include <string>

Include dependency graph for nvutil.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Defines

#define | stricmp _stricmp
#define | chdir _chdir
#define | getcwd _getcwd
#define | vsnprintf _vsnprintf

Functions

NVSG_API float | _atof (const std::string &str)
int | _stricmp (const char *string1, const char *string2)

Detailed Description

Generated on Tue Jan 15 10:28:05 2008 for NVSGSDK by NVIDIA


nvutil.h Source File

nvutil.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/nvsgapi.h"
00016 #include <string>
00017
00018 NVSG_API float _atof( const std::string &str );
00019
00020 // Note: C Runtime extensions as they are available on Windows,
00021 // are intentionally defined outside of any namespaces.
00022 #if defined(LINUX)
00023 # define stricmp _stricmp
00024
00025 int _stricmp(
00026    const char *string1,
00027    const char *string2
00028  );
00029
00030
00031 #endif
00032
00033 #if defined(_WIN32)
00034 # define chdir _chdir
00035 # define getcwd _getcwd
00036 # define vsnprintf _vsnprintf
00037 #endif
00038
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Object.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CoreTypes.h"
#include "nvsg/DAL.h"
#include "nvutil/Incarnation.h"
#include "nvutil/SWMRSync.h"
#include <typeinfo>

Include dependency graph for Object.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:05 2008 for NVSGSDK by NVIDIA


Object.h Source File

Object.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00016 #include "nvsgcommon.h" // commonly used stuff
00017 #include "nvsg/CoreTypes.h" // core type declarations and typedefs
00018 #include "nvsg/DAL.h" // base class definition
00019 // more dependencies
00020 #include "nvutil/Incarnation.h"
00021 #include "nvutil/SWMRSync.h"
00022 #include  <typeinfo>
00023
00024 namespace nvsg
00025 {
00031   typedef unsigned long long DataID;
00032
00043   enum
00044   {
00045     OC_INVALID = 0xFFFFFFFF
00046   , OC_OBJECT = 0
00047   // nodes (0x00-0x1F)
00048   , OC_NODE = OC_OBJECT
00049   , OC_GEONODE
00050   , OC_GROUP
00051   , OC_FLIPBOOKANIMATION
00052   , OC_LOD
00053   , OC_SWITCH
00054   , OC_TRANSFORM
00055   , OC_ANIMATEDTRANSFORM
00056   , OC_DIRECTEDLIGHT
00057   , OC_POINTLIGHT
00058   , OC_SPOTLIGHT
00059   , OC_BILLBOARD
00060   , OC_VOLUMENODE
00061   , OC_VOLUMEBRICK
00062   // drawables (0x20-0x3F)
00063   , OC_DRAWABLES = 0x20
00064   , OC_VERTEX_ATTRIBUTE_SET
00065   , OC_ANIMATED_VERTEX_ATTRIBUTE_SET
00066   , OC_QUADS
00067   , OC_QUADSTRIPS
00068   , OC_TRIANGLES
00069   , OC_SKINNEDTRIANGLES
00070   , OC_TRISTRIPS
00071   , OC_LINES
00072   , OC_LINESTRIPS
00073   , OC_TRIFANS
00074   , OC_POINTS
00075   , OC_SHAPE
00076   , OC_BITMAP
00077   , OC_PIXMAP
00078   , OC_MAPELEMENT
00079   , OC_MAPARRAY
00080   , OC_MAPMATRIX
00081   , OC_MAPLIST
00082   , OC_QUADMESHES
00083   , OC_SKIN
00084   // states (0x40-0x5F)
00085   , OC_STATESET = 0x40
00086   , OC_STATEVARIANT
00087   , OC_STATEPASS
00088   , OC_STATEATTRIBUTE
00089   , OC_CGFX
00090   , OC_FACEATTRIBUTE
00091   , OC_MATERIAL
00092   , OC_TEXTUREATTRIBUTE
00093   , OC_TEXTUREATTRIBUTEITEM
00094   , OC_STATESETEXT
00095   , OC_LINEATTRIBUTE
00096   , OC_LIGHTINGATTRIBUTE
00097   , OC_POINTATTRIBUTE
00098   , OC_BLENDATTRIBUTE
00099   , OC_ALPHATESTATTRIBUTE
00100   , OC_DEPTHATTRIBUTE
00101   , OC_UNLITCOLORATTRIBUTE
00102   // animations (0x60-0x7F)
00103   , OC_ANIMATION = 0x60
00104   , OC_FRAMEDINDEXANIMATION
00105   , OC_FRAMEDTRAFOANIMATION
00106   , OC_LINEARINTERPOLATEDTRAFOANIMATION
00107   , OC_FRAMEDVERTEXATTRIBUTEANIMATION
00108   , OC_LINEARINTERPOLATEDVERTEXATTRIBUTEANIMATION
00109   // cameras (0x80-0x9F)
00110   , OC_CAMERA = 0x80
00111   , OC_PARALLELCAMERA
00112   , OC_PERSPECTIVECAMERA
00113   // highlight objects (0xA0-0xBF)
00114   , OC_HIGHLIGHTOBJECT = 0xA0
00115   , OC_HIGHLIGHTBOX
00116   , OC_HIGHLIGHTEDGES
00117   // custom (0xC0 and higher)
00118   , OC_CUSTOMOBJECT = 0xC0
00119   };
00120
00131   class Object : public nvutil::HandledObject, public DALHostHolder           // an object can host DAL data
00132   {
00133   public:
00136     NVSG_API Object();
00137
00140     NVSG_API Object( const Object& rhs );
00141
00144     NVSG_API virtual ~Object();
00145
00159     unsigned int getObjectCode() const;
00160
00188     NVSG_API virtual unsigned int getHigherLevelObjectCode(unsigned int oc) const;
00189
00211     NVSG_API virtual bool isDataShared() const;
00212
00224     NVSG_API virtual DataID getDataID() const;
00225
00236     NVSG_API const nvutil::Incarnation& getIncarnation() const;
00237
00244     NVSG_API virtual bool validateIncarnation() const;
00245
00252     NVSG_API virtual bool invalidateIncarnation();
00253
00262     NVSG_API void setName(const std::string& name);
00263
00271     NVSG_API const std::string& getName() const;
00272
00280     NVSG_API void setAnnotation(const std::string& anno);
00281
00288     NVSG_API const std::string& getAnnotation() const;
00289
00306     NVSG_API virtual bool isEquivalent( const Object * object
00307                                       , bool ignoreNames = true
00308                                       , bool deepCompare = false) const;
00309
00326     NVSG_API void setUserData(const void* userData);
00327
00334     NVSG_API const void* getUserData() const;
00335
00336   protected: // accessible for derived classes
00337
00347     NVSG_API Object & operator=(const Object & rhs);
00348
00349
00352     NVSG_API void enterCS() const;
00353     NVSG_API void leaveCS() const;
00354
00355   protected:
00356
00382     unsigned int m_objectCode;
00383
00384   private:
00385     std::string * m_name; // optional name
00386     std::string * m_annotation; // optional annotation specified for the object
00387
00388     // helps managing exclusive access to mutable members while reading the object
00389     nvutil::SWMRSync m_lock;
00390
00391     mutable bool m_incarnationValid; // incarnation's valid flag
00392     nvutil::Incarnation  m_incarnation; // object's incarnation count
00393
00394     const void * m_userData; // dumb pointer to arbitrary user data
00395   };
00396
00397 #if !defined(NDEBUG)
00398   template <typename T>
00399   inline void NVSG_ASSERT_OBJECT_WRITE_LOCKED(const T* obj)
00400   {
00401     nvutil::getHandle<nvutil::Handle<nvutil::EmptyType> >(obj)->assertWriteLocked();
00402   }
00403   template <typename T>
00404   inline void NVSG_ASSERT_OBJECT_READ_LOCKED(const T* obj)
00405   {
00406     nvutil::getHandle<nvutil::Handle<nvutil::EmptyType> >(obj)->assertReadLocked();
00407   }
00408 #else
00409 # define NVSG_ASSERT_OBJECT_WRITE_LOCKED(x) static_cast<void*>(0);
00410 # define NVSG_ASSERT_OBJECT_READ_LOCKED(x) static_cast<void*>(0);
00411 #endif
00412
00413   inline unsigned int Object::getObjectCode() const
00414   {
00415     NVSG_TRACE();
00416     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00417     return m_objectCode;
00418   }
00419
00420   inline void Object::setUserData(const void * userData)
00421   {
00422     NVSG_TRACE();
00423     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00424     if ( m_userData != userData )
00425     {
00426       m_userData = userData; // no sanity check!
00427       invalidateIncarnation();
00428     }
00429   }
00430
00431   inline const void * Object::getUserData() const
00432   {
00433     NVSG_TRACE();
00434     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00435     return m_userData;
00436   }
00437
00438   inline void Object::enterCS() const
00439   {
00440     NVSG_TRACE();
00441     // might be called unlocked with invalidation up the tree hierarchy
00442     m_lock.lockExclusive();
00443   }
00444
00445   inline void Object::leaveCS() const
00446   {
00447     NVSG_TRACE();
00448     // might be called unlocked with invalidation up the tree hierarchy
00449     m_lock.unlockExclusive();
00450   }
00451
00453
00454   template<typename T>
00455   inline bool isTypeOf( ObjectHandle *p )
00456   {
00457     return( dynamic_cast<T *>( p ) != NULL );
00458   }
00459
00461
00462   inline bool areOfSameType( ObjectHandle *p0, ObjectHandle *p1 )
00463   { // found not initialized object codes if one of the following fires
00464     nvutil::ReadableObject<Object> obj0(p0);
00465     nvutil::ReadableObject<Object> obj1(p1);
00466     NVSG_ASSERT(obj0->getObjectCode()!=OC_INVALID);
00467     NVSG_ASSERT(obj1->getObjectCode()!=OC_INVALID);
00468     return( obj0->getObjectCode()==obj1->getObjectCode() );
00469   }
00470 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


OBJSaver.h File Reference

#include <set>
#include "nvsg/nvsgapi.h"
#include "nvsg/PlugInterface.h"
#include "nvsg/PlugInterfaceID.h"
#include "nvsg/ViewState.h"

Include dependency graph for OBJSaver.h:

Include dependency graph

Go to the source code of this file.

Classes

class | OBJSaver
A Scene Saver for obj files. More...

Functions

OBJSAVER_API bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

OBJSAVER_API bool | queryPlugInterfaceType (const nvutil::UPITID &pitid, std::vector< nvutil::UPIID > &piids)
Query the supported types of PlugIn Interfaces.

Detailed Description

Function Documentation

OBJSAVER_API bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) |

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a OBJSAVER. If the PlugIn ID piid equals PIID_NVSG_SCENE_SAVER, a OBJSAVER is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

OBJSAVER_API bool queryPlugInterfaceType | ( | const nvutil::UPITID & | pitid,
 |  | std::vector< nvutil::UPIID > & | piids
 | ) |

Query the supported types of PlugIn Interfaces.

Every PlugIn has to resolve this function. It is used to query the supported Interface types of this PlugIn. If the Plug In Type ID pitid equals PITID_SCENE_SAVER, the vector piids is filled with one element PIID_NVSG_SCENE_SAVER.

Returns:
true, if a PITID_SCENE_SAVER is requested, otherwise false

Generated on Tue Jan 15 10:28:05 2008 for NVSGSDK by NVIDIA


OBJSaver.h Source File

OBJSaver.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include  <set>
00016 #include  "nvsg/nvsgapi.h"
00017 #include  "nvsg/PlugInterface.h"
00018 #include  "nvsg/PlugInterfaceID.h"
00019 #include  "nvsg/ViewState.h"
00020
00021
00022 //  Don't need to document the API specifier
00023 #if ! defined( DOXYGEN_IGNORE )
00024 #if defined(_WIN32)
00025 # ifdef OBJSAVER_EXPORTS
00026 #  define OBJSAVER_API __declspec(dllexport)
00027 # else
00028 #  define OBJSAVER_API __declspec(dllimport)
00029 # endif
00030 #else
00031 # define OBJSAVER_API
00032 #endif
00033 #endif  //  DOXYGEN_IGNORE
00034
00035 // exports required for a scene loader plug-in
00036 #if defined(LINUX)
00037 extern "C"
00038 {
00039 #endif
00040
00041
00046 OBJSAVER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00047
00049
00054 OBJSAVER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00055 #if defined(LINUX)
00056 }
00057 #endif
00058
00060
00062 class OBJSaver : public nvsg::SceneSaver
00063 {
00064   public :
00066
00067     void  deleteThis( void );
00068
00070
00071     bool  save( nvsg::SceneHandle     *scene
00072               , nvsg::ViewStateHandle *viewState
00073               , const std::string     &filename
00074               );
00075 };
00076
00077 inline void OBJSaver::deleteThis( void )
00078 {
00079   delete this;
00080 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


OptimizeTraverser.h File Reference

#include <list>
#include "nvsgcommon.h"
#include "nvtraverser/Traverser.h"

Include dependency graph for OptimizeTraverser.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:06 2008 for NVSGSDK by NVIDIA


OptimizeTraverser.h Source File

OptimizeTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <list>
00016 #include "nvsgcommon.h"
00017 #include "nvtraverser/Traverser.h"
00018
00019 namespace nvtraverser
00020 {
00022   class OptimizeTraverser : public ExclusiveTraverser
00023   {
00024     public:
00026       NVSG_API OptimizeTraverser( void );
00027
00028     public:
00030
00032       NVSG_API bool getIgnoreNames( void ) const;
00033
00035
00036       NVSG_API void setIgnoreNames( bool ignore
00037                                   );
00038
00040
00041       NVSG_API bool getTreeModified( void ) const;
00042
00043     protected:
00045       NVSG_API virtual ~OptimizeTraverser( void );
00046
00048       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00049
00050       NVSG_API void setTreeModified( void );
00051
00052     private:
00053       bool  m_ignoreNames;
00054       bool  m_treeModified;
00055   };
00056
00057   inline bool OptimizeTraverser::getIgnoreNames( void ) const
00058   {
00059     return( m_ignoreNames );
00060   }
00061
00062   inline void OptimizeTraverser::setIgnoreNames( bool ignore )
00063   {
00064     m_ignoreNames = ignore;
00065   }
00066
00067   inline bool OptimizeTraverser::getTreeModified( void ) const
00068   {
00069     return( m_treeModified );
00070   }
00071
00072   inline void OptimizeTraverser::setTreeModified( void )
00073   {
00074     m_treeModified = true;
00075   }
00076 }
00077
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


OwnedObject.h File Reference

#include "nvsg/Object.h"
#include <vector>

Include dependency graph for OwnedObject.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:06 2008 for NVSGSDK by NVIDIA


OwnedObject.h Source File

OwnedObject.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/Object.h" // base class definition
00016 #include <vector>
00017
00018 namespace nvsg
00019 {
00020   template<typename OwnerType, typename OwnedHandleType>
00021   inline void addAsOwnerTo(OwnerType * owner, OwnedHandleType * owned)
00022   {
00023     nvutil::WritableObject<typename OwnedHandleType::ObjectType> obj(owned);
00024     obj->addOwner(owner);
00025   }
00026
00027   template<typename OwnerType, typename OwnedHandleType>
00028   inline void removeAsOwnerFrom(OwnerType * owner, OwnedHandleType * owned)
00029   {
00030     nvutil::WritableObject<typename OwnedHandleType::ObjectType> obj(owned);
00031     obj->removeOwner(owner);
00032   }
00033
00042   template<typename OwnerHandle>
00043   class OwnedObject : public Object
00044   {
00045     template <typename T, typename U> friend void addAsOwnerTo(T *,  U *);
00046     template <typename T, typename U> friend void removeAsOwnerFrom(T *,  U *);
00047
00048     private:
00049
00050       template <typename HandleType>
00051       class Owner
00052       {
00053       public:
00054         explicit Owner(typename HandleType::ObjectType * obj)
00055           : m_obj(obj)
00056           , m_hdl(nvutil::getHandle<HandleType>(obj))
00057         {}
00058
00059         // default copy ctor already does the right thing
00060         // default dtor already does the right thing
00061
00062         // comparison is required for the std:find algorithm
00063         bool operator==(const typename HandleType::ObjectType * rhs) const { return m_obj==rhs; } // identify by object
00064         bool operator!=(const typename HandleType::ObjectType * rhs) const { return m_obj!=rhs; } // dito
00065
00066         typename HandleType::ObjectType * operator->() const { return m_obj; } // access the object
00067         HandleType * owner()  const { return m_hdl; } // access the handle
00068
00069       private:
00070         typename HandleType::ObjectType * m_obj;
00071         HandleType * m_hdl;
00072       };
00073
00074       typedef Owner<OwnerHandle> OwnerType;
00075       std::vector<OwnerType>  m_owners;
00076
00077     public:
00084       unsigned int getNumberOfOwners() const;
00085
00094       OwnerHandle * getOwner( unsigned int index ) const;
00095
00102       OwnedObject<OwnerHandle>& operator=(const OwnedObject<OwnerHandle> & rhs);
00103
00109       virtual bool invalidateIncarnation();      // from bottom to top
00110
00111     protected:
00112
00113
00116       typedef typename std::vector<OwnerType>::iterator OwnerIterator;
00117
00120       typedef typename std::vector<OwnerType>::const_iterator ConstOwnerIterator;
00121
00125       OwnedObject();
00126
00130       OwnedObject( const Object & rhs );
00131
00135       OwnedObject( const OwnedObject<OwnerHandle> &rhs );
00136
00140       ~OwnedObject();
00141
00147       void addOwner(typename OwnerHandle::ObjectType * obj);
00148
00154       void removeOwner(typename OwnerHandle::ObjectType * obj);
00155
00159       ConstOwnerIterator ownersBegin() const { return m_owners.begin(); }
00160
00164       OwnerIterator ownersBegin() { return m_owners.begin(); }
00165
00169       ConstOwnerIterator ownersEnd() const { return m_owners.end(); }
00170
00174       OwnerIterator ownersEnd() { return m_owners.end(); }
00175   };
00176
00177   template<typename OwnerHandle>
00178     OwnedObject<OwnerHandle>::OwnedObject()
00179     : Object()
00180   {
00181   }
00182
00183   template<typename OwnerHandle>
00184     OwnedObject<OwnerHandle>::OwnedObject( const Object &rhs )
00185     : Object(rhs)
00186   {
00187     // must not copy owners!!!
00188     // this is what this implementation of the cpy ctor is for!
00189     NVSG_ASSERT( m_owners.empty() );
00190   }
00191
00192   template<typename OwnerHandle>
00193     OwnedObject<OwnerHandle>::OwnedObject( const OwnedObject<OwnerHandle> &rhs )
00194     : Object(rhs)
00195   {
00196     // must not copy owners!!!
00197     // this is what this implementation of the cpy ctor is for!
00198     NVSG_ASSERT( m_owners.empty() );
00199   }
00200
00201   template<typename OwnerHandle>
00202     OwnedObject<OwnerHandle>::~OwnedObject()
00203   {
00204     // if this fires, there was no proper cleanup of owner relationship elsewhere
00205     NVSG_ASSERT( m_owners.empty() );
00206   }
00207
00208   template<typename OwnerHandle>
00209   inline unsigned int OwnedObject<OwnerHandle>::getNumberOfOwners( void ) const
00210   {
00211     NVSG_TRACE();
00212     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00213     NVSG_ASSERT( m_owners.size() <= UINT_MAX );
00214     return( static_cast<unsigned int>(m_owners.size()) );
00215   }
00216
00217   template<typename OwnerHandle>
00218   inline OwnerHandle * OwnedObject<OwnerHandle>::getOwner( unsigned int index ) const
00219   {
00220     NVSG_TRACE();
00221     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00222
00223     NVSG_ASSERT( index < m_owners.size() );
00224     return( m_owners[index].owner() );
00225   }
00226
00227   template<typename OwnerHandle>
00228   inline OwnedObject<OwnerHandle> & OwnedObject<OwnerHandle>::operator=( const OwnedObject<OwnerHandle> &rhs )
00229   {
00230     NVSG_TRACE();
00231     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00232
00233     Object::operator=( rhs );
00234     return( *this );
00235   }
00236
00237   template<typename OwnerHandle>
00238     inline void OwnedObject<OwnerHandle>::addOwner(typename OwnerHandle::ObjectType * obj)
00239   {
00240     NVSG_TRACE();
00241     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00242
00243     // do not add an owner twice
00244     if ( m_owners.end() == std::find( m_owners.begin(), m_owners.end(), obj ) )
00245     {
00246       // must not add reference for an owner
00247       m_owners.push_back( Owner<OwnerHandle>(obj) );
00248     }
00249   }
00250
00251   template<typename OwnerHandle>
00252   inline void OwnedObject<OwnerHandle>::removeOwner(typename OwnerHandle::ObjectType * obj)
00253   {
00254     NVSG_TRACE();
00255     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00256
00257     // the erase-remove idiom is the best way to get rid of specific elements from a vector
00258     m_owners.erase( remove( m_owners.begin(), m_owners.end(), obj ), m_owners.end() );
00259     //  NOTE: don't remove a ref from the owner here
00260   }
00261
00262   template<typename OwnerHandle>
00263   inline bool OwnedObject<OwnerHandle>::invalidateIncarnation()
00264   {
00265     NVSG_TRACE();
00266
00267     bool ret = Object::invalidateIncarnation();
00268     if ( ret )
00269     {
00270       for ( OwnerIterator i = ownersBegin(); i != ownersEnd(); ++i )
00271       {
00272         // Concrete OwnedObjects might be not defined at this point,
00273         // and the compiler would complain. Therefore, cast to pointer
00274         // to Object, and do the virtual function call.
00275         //
00276         ((Object*)(*i).operator->())->invalidateIncarnation();
00277       }
00278     }
00279     return( ret );
00280   }
00281
00282 } // namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


ParallelCamera.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Camera.h"

Include dependency graph for ParallelCamera.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:06 2008 for NVSGSDK by NVIDIA


ParallelCamera.h Source File

ParallelCamera.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Camera.h"
00017
00018 namespace nvsg
00019 {
00024   class ParallelCamera : public Camera
00025   {
00026     public:
00030       NVSG_API ParallelCamera();
00031
00034       NVSG_API explicit ParallelCamera( const Camera &rhs );
00035
00037       NVSG_API ParallelCamera( const ParallelCamera &rhs );
00038
00040       NVSG_API virtual ~ParallelCamera();
00041
00045       NVSG_API virtual nvmath::Mat44f getProjection() const;
00046
00050       NVSG_API virtual nvmath::Mat44f getInverseProjection()  const;
00051
00065       NVSG_API virtual void getPickRay( int x
00066                                       , int y
00067                                       , int w
00068                                       , int h
00069                                       , nvmath::Vec3f & rayOrigin
00070                                       , nvmath::Vec3f & rayDir ) const;
00071
00076       NVSG_API ParallelCamera & operator=(const ParallelCamera & rhs);
00077
00082       NVSG_API virtual CullCode determineCullCode( const nvmath::Sphere3f &sphere ) const;
00083   };
00084 } // namespace
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Path.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Matnnt.h"
#include "nvsg/CoreTypes.h"
#include "nvutil/RCObject.h"

Include dependency graph for Path.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:07 2008 for NVSGSDK by NVIDIA


Path.h Source File

Path.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Matnnt.h"
00017 #include "nvsg/CoreTypes.h"
00018 #include "nvutil/RCObject.h" // base class definition
00019
00020 namespace nvsg
00021 {
00028   class Path : public nvutil::RCObject
00029   {
00030     public:
00032       NVSG_API Path();
00033
00040       NVSG_API Path(const Path& rhs);
00041
00045       NVSG_API unsigned int getLength() const;
00046
00051       NVSG_API bool isEmpty() const;
00052
00059       NVSG_API ObjectHandle * getHead() const;
00060
00067       NVSG_API ObjectHandle * getTail() const;
00068
00076       NVSG_API ObjectHandle * getFromHead(unsigned int i) const;
00077
00085       NVSG_API ObjectHandle * getFromTail(unsigned int i) const;
00086
00092       NVSG_API void pop();
00093
00100       NVSG_API void push(ObjectHandle * pObject);
00101
00110       NVSG_API void truncate(unsigned int start);
00111
00120       NVSG_API void getModelToWorldMatrix( nvmath::Mat44f & modelToWorld
00121                                          , nvmath::Mat44f & worldToModel) const;
00122
00123     protected:
00125       NVSG_API virtual ~Path();
00126
00127     private:
00128       std::vector<ObjectHandle *> m_path;
00129   };
00130
00131   // - - - - - - - - - - - - - - - - - - -
00132   // inlines
00133   // - - - - - - - - - - - - - - - - - - -
00134
00135   inline ObjectHandle * Path::getHead() const
00136   {
00137     NVSG_TRACE();
00138     return( m_path.empty() ? NULL : m_path.front() );
00139   }
00140
00141   inline ObjectHandle * Path::getTail() const
00142   {
00143     NVSG_TRACE();
00144     return( m_path.empty() ? NULL : m_path.back() );
00145   }
00146
00147   inline ObjectHandle * Path::getFromHead( unsigned int i ) const
00148   {
00149     NVSG_TRACE();
00150     NVSG_ASSERT(0 <= i && i < m_path.size());
00151     return( m_path[i] );
00152   }
00153
00154   inline ObjectHandle * Path::getFromTail( unsigned int i ) const
00155   {
00156     NVSG_TRACE();
00157     NVSG_ASSERT(0 <= i && i < m_path.size());
00158     return( m_path[m_path.size() - i-1] );
00159   }
00160
00161   inline unsigned int Path::getLength() const
00162   {
00163     NVSG_TRACE();
00164     return (unsigned int) m_path.size();
00165   }
00166
00167   inline void Path::pop()
00168   {
00169     NVSG_TRACE();
00170     NVSG_ASSERT(getLength() > 0);
00171     m_path.back()->removeRef();
00172     m_path.pop_back();
00173   }
00174
00175   inline bool Path::isEmpty() const
00176   {
00177     NVSG_TRACE();
00178     return m_path.empty();
00179   }
00180 } //  namspace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PerspectiveCamera.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Camera.h"

Include dependency graph for PerspectiveCamera.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:07 2008 for NVSGSDK by NVIDIA


PerspectiveCamera.h Source File

PerspectiveCamera.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Camera.h"
00017
00018 namespace nvsg
00019 {
00024   class PerspectiveCamera : public Camera
00025   {
00026     public:
00030       NVSG_API PerspectiveCamera();
00031
00034       NVSG_API explicit PerspectiveCamera( const Camera &rhs );
00035
00037       NVSG_API PerspectiveCamera( const PerspectiveCamera &rhs );
00038
00040       NVSG_API virtual ~PerspectiveCamera();
00041
00046       NVSG_API float getFieldOfView() const;
00047
00052       NVSG_API void setFieldOfView( float fov );
00053
00055
00063       NVSG_API virtual void setFocusDistance( float fd );
00064
00068       NVSG_API virtual nvmath::Mat44f getProjection() const;
00069
00073       NVSG_API virtual nvmath::Mat44f getInverseProjection() const;
00074
00087       NVSG_API virtual void getPickRay( int x
00088                                       , int y
00089                                       , int w
00090                                       , int h
00091                                       , nvmath::Vec3f & rayOrigin
00092                                       , nvmath::Vec3f & rayDir ) const;
00093
00098       NVSG_API PerspectiveCamera & operator=(const PerspectiveCamera & rhs);
00099
00104       NVSG_API virtual CullCode determineCullCode( const nvmath::Sphere3f &sphere ) const;
00105   };
00106
00107   inline float PerspectiveCamera::getFieldOfView() const
00108   {
00109     NVSG_TRACE();
00110     return( 2.0f * atanf( 0.5f * getWindowSize()[1] / getFocusDistance() ) );
00111   }
00112 } // namespace
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Planent.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vecnt.h"
#include <float.h>

Include dependency graph for Planent.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvmath

Detailed Description

Generated on Tue Jan 15 10:28:07 2008 for NVSGSDK by NVIDIA


Planent.h Source File

Planent.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Vecnt.h"
00017
00018 #include <float.h>
00019
00020 namespace nvmath
00021 {
00025   template<unsigned int n,typename T> class Planent
00026   {
00027     public:
00030       Planent();
00031
00036       Planent( const Vecnt<n,T> & normal, T offset );
00037
00042       Planent( const Vecnt<n,T> & normal, const Vecnt<n,T> & p );
00043
00049       Planent( const Vecnt<n,T> & p0, const Vecnt<n,T> & p1, const Vecnt<n,T> & p2 );
00050
00051     public:
00055       const Vecnt<n,T> & getNormal() const;
00056
00060       T getOffset() const;
00061
00065       T operator()( const Vecnt<n,T> & p ) const;
00066
00070       void setNormal( const Vecnt<n,T> & normal );
00071
00075       void setOffset( T offset );
00076
00077     private:
00078       Vecnt<n,T>  m_normal;
00079       T           m_offset;
00080   };
00081
00082   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00083   // non-member functions
00084   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00085
00092   template<unsigned int n, typename T>
00093     bool areOnOppositeSides( const Planent<n,T> & pl, const Vecnt<n,T> & p0, const Vecnt<n,T> & p1 );
00094
00101   template<unsigned int n, typename T>
00102     bool areOnSameSide( const Planent<n,T> & pl, const Vecnt<n,T> & p0, const Vecnt<n,T> & p1 );
00103
00109   template<unsigned int n, typename T>
00110     T distance( const Planent<n,T> & pl, const Vecnt<n,T> & p );
00111
00117   template<unsigned int n, typename T>
00118     Vecnt<n,T> nearestPoint( const Planent<n,T> & pl, const Vecnt<n,T> & p );
00119
00126   template<unsigned int n, typename T>
00127     bool operator==( const Planent<n,T> & pl0, const Planent<n,T> & pl1 );
00128
00135   template<unsigned int n, typename T>
00136     bool operator!=( const Planent<n,T> & pl0, const Planent<n,T> & pl1 );
00137
00146   template<unsigned int n, typename T>
00147     T signedDistance( const Planent<n,T> & pl, const Vecnt<n,T> & p );
00148
00149   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00150   // Convenience type definitions
00151   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00152   typedef Planent<3,float>  Plane3f;
00153   typedef Planent<3,double> Plane3d;
00154
00155   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00156   // inlined member functions
00157   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00158   template<unsigned int n, typename T>
00159   inline Planent<n,T>::Planent()
00160   {
00161   }
00162
00163   template<unsigned int n, typename T>
00164   inline Planent<n,T>::Planent( const Vecnt<n,T> & normal, T offset )
00165     : m_normal(normal)
00166     , m_offset(offset)
00167   {
00168     NVSG_PRIVATE_ASSERT( isNormalized( m_normal ) );
00169   }
00170
00171   template<unsigned int n, typename T>
00172   inline Planent<n,T>::Planent( const Vecnt<n,T> & normal, const Vecnt<n,T> & p )
00173     : m_normal(normal)
00174     , m_offset(-p*normal)
00175   {
00176     NVSG_PRIVATE_ASSERT( isNormalized( m_normal ) );
00177   }
00178
00179   template<unsigned int n, typename T>
00180   inline Planent<n,T>::Planent( const Vecnt<n,T> & p0, const Vecnt<n,T> & p1, const Vecnt<n,T> & p2 )
00181   {
00182     NVSG_PRIVATE_ASSERT( ( p0 != p1 ) && ( p0 != p2 ) && ( p1 != p2 ) );
00183     m_normal = ( p1 - p0 ) ^ ( p2 - p0 );
00184     m_normal.normalize();
00185     m_offset = - m_normal * p0;
00186   }
00187
00188   template<unsigned int n, typename T>
00189   inline const Vecnt<n,T> & Planent<n,T>::getNormal() const
00190   {
00191     return( m_normal );
00192   }
00193
00194   template<unsigned int n, typename T>
00195   inline T Planent<n,T>::getOffset() const
00196   {
00197     return( m_offset );
00198   }
00199
00200   template<unsigned int n, typename T>
00201   inline T Planent<n,T>::operator()( const Vecnt<n,T> & p ) const
00202   {
00203     return( m_normal * p + m_offset );
00204   }
00205
00206   template<unsigned int n, typename T>
00207   inline void Planent<n,T>::setNormal( const Vecnt<n,T> & normal )
00208   {
00209     NVSG_PRIVATE_ASSERT( isNormalized( normal ) );
00210     m_normal = normal;
00211   }
00212
00213   template<unsigned int n, typename T>
00214   inline void Planent<n,T>::setOffset( T offset )
00215   {
00216     m_offset = offset;
00217   }
00218
00219   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00220   // inlined non-member functions
00221   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00222
00223   template<unsigned int n, typename T>
00224   bool areOnOppositeSides( const Planent<n,T> & pl, const Vecnt<n,T> & p0, const Vecnt<n,T> & p1 )
00225   {
00226     return( pl( p0 ) * pl( p1 ) < 0 );
00227   }
00228
00229   template<unsigned int n, typename T>
00230   bool areOnSameSide( const Planent<n,T> & pl, const Vecnt<n,T> & p0, const Vecnt<n,T> & p1 )
00231   {
00232     return( 0 < pl( p0 ) * pl( p1 ) );
00233   }
00234
00235   template<unsigned int n, typename T>
00236   T distance( const Planent<n,T> & pl, const Vecnt<n,T> & p )
00237   {
00238     return( abs( pl( p ) ) );
00239   }
00240
00241   template<unsigned int n, typename T>
00242   Vecnt<n,T> nearestPoint( const Planent<n,T> & pl, const Vecnt<n,T> & p )
00243   {
00244     return( p - pl( p ) * pl.getNormal() );
00245   }
00246
00247   template<unsigned int n, typename T>
00248   bool operator==( const Planent<n,T> & pl0, const Planent<n,T> & pl1 )
00249   {
00250     return(   ( pl0.getNormal() == pl1.getNormal() )
00251           &&  ( abs( pl0.getOffset() - pl1.getOffset() ) < FLT_EPSILON ) );
00252   }
00253
00254   template<unsigned int n, typename T>
00255   bool operator!=( const Planent<n,T> & pl0, const Planent<n,T> & pl1 )
00256   {
00257     return( ! ( pl0 == pl1 ) );
00258   }
00259
00260   template<unsigned int n, typename T>
00261   T signedDistance( const Planent<n,T> & pl, const Vecnt<n,T> & p )
00262   {
00263     return( pl( p ) );
00264   }
00265
00266 } // end namespace nvmath
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PlugIn.h File Reference

#include <map>
#include "nvsgcommon.h"
#include <dlfcn.h>
#include "nvutil/PlugInCallback.h"

Include dependency graph for PlugIn.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvutil

Defines

#define | HLIB HMODULE
#define | MapLibrary(name) LoadLibrary(name)
#define | UnMapLibrary FreeLibrary
#define | GetFuncAddress GetProcAddress
#define | LibExtStr "*.nxm"

Detailed Description

Generated on Tue Jan 15 10:28:08 2008 for NVSGSDK by NVIDIA


PlugIn.h Source File

PlugIn.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <map>
00016
00017 #include "nvsgcommon.h"
00018
00019 #if defined(LINUX)
00020  #include <dlfcn.h>
00021 #endif
00022 #include "nvutil/PlugInCallback.h"
00023
00024 namespace nvutil {
00025
00026 #if defined(_WIN32)
00027 # define HLIB                 HMODULE
00028 # define MapLibrary(name)     LoadLibrary(name)
00029 # define UnMapLibrary         FreeLibrary
00030 # define GetFuncAddress       GetProcAddress
00031 # define LibExtStr            "*.nxm"
00032 #elif defined(LINUX)
00033 # define HLIB                 void*
00034 # define MapLibrary(name)     dlopen(name, RTLD_LAZY)
00035 # define UnMapLibrary(handle) dlclose(handle)
00036 # define GetFuncAddress       dlsym
00037 # define LibExtStr            "*.nxm"
00038 #else
00039 # error Undefined Operating System!
00040 #endif
00041
00043
00050 class UPITID
00051 {
00052 public:
00054
00056   UPITID() {}
00058
00060   NVSG_API UPITID( unsigned short pit
00061                  , const char verStr[16]
00062                  );
00064
00066   NVSG_API UPITID(const UPITID& rhs);
00068
00072   friend bool operator<( const UPITID& lhs
00073                        , const UPITID& rhs
00074                        );
00076
00079   friend bool operator==( const UPITID& lhs
00080                         , const UPITID& rhs
00081                         );
00083
00086   friend bool operator!=( const UPITID& lhs
00087                         , const UPITID& rhs
00088                         );
00089
00090 private:
00091   unsigned short data0;      // plug interface type
00092   char           data1[16];  // version control
00093 };
00094
00096
00101 class UPIID // Unique Plug Interface ID
00102 {
00103 public:
00105
00107   UPIID() {};
00109
00112   NVSG_API UPIID( const char idstr[8]
00113                 , UPITID pitid
00114                 );
00116
00119   NVSG_API UPIID& operator=(const UPIID& rhs);
00120
00122
00134   const char * getPlugSpecificIDString() const;
00136
00140   const UPITID& getPlugInterfaceType()  const;
00141
00143
00147   friend bool operator<( const UPIID& lhs
00148                        , const UPIID& rhs
00149                        );
00151
00154   friend bool operator==( const UPIID& lhs
00155                         , const UPIID& rhs
00156                         );
00158
00161   friend bool operator!=( const UPIID& lhs
00162                         , const UPIID& rhs
00163                         );
00164
00165 private:
00166   char           data0[8];   // plug specific identifier string
00167   UPITID         data1;      // plug interface type
00168 };
00169
00170 inline const char * UPIID::getPlugSpecificIDString() const
00171 {
00172   return data0;
00173 }
00174
00175 inline const UPITID& UPIID::getPlugInterfaceType() const
00176 {
00177   return data1;
00178 }
00179
00180 // this 'less' operator is required when storing UPITIDs in STL maps
00181 inline bool operator<(const UPITID& lhs, const UPITID& rhs)
00182 {
00183   return (lhs.data0==rhs.data0) ? stricmp(lhs.data1, rhs.data1)<0 : lhs.data0<rhs.data0;
00184 }
00185
00186 // test if two UPITIDs are equal
00187 inline bool operator==(const UPITID& lhs, const UPITID& rhs)
00188 {
00189   return lhs.data0==rhs.data0 && !stricmp(lhs.data1, rhs.data1);
00190 }
00191
00192 // test if two UPITIDs are unequal
00193 inline bool operator!=(const UPITID& lhs, const UPITID& rhs)
00194 {
00195   return !(lhs==rhs);
00196 }
00197
00198 // this 'less' operator is required when storing UPIIDs in STL maps
00199 inline bool operator<(const UPIID& lhs, const UPIID& rhs)
00200 {
00201   return (lhs.data1==rhs.data1) ? stricmp(lhs.data0, rhs.data0)<0 : lhs.data1<rhs.data1;
00202 }
00203
00204 // test if two UPIIDs are equal
00205 inline bool operator==(const UPIID& lhs, const UPIID& rhs)
00206 {
00207   return !stricmp(lhs.data0, rhs.data0) && lhs.data1==rhs.data1;
00208 }
00209
00210 // test if two UPIIDs are unequal
00211 inline bool operator!=(const UPIID& lhs, const UPIID& rhs)
00212 {
00213   return !(lhs==rhs);
00214 }
00215
00216 // required forward declarations
00217 class PlugIn;
00218
00220 typedef bool (*PFNGETPLUGINTERFACE)(const UPIID& piid, PlugIn *& plugIn);
00222 typedef bool (*PFNQUERYPLUGINTERFACETYPE)(const UPITID& pitid, std::vector<UPIID>& piids);
00223
00225
00227 class PlugIn
00228 {
00230
00233   friend class PlugInServer;
00234
00235 public:
00236   PlugIn();
00237
00239
00240   void setCallback( PlugInCallback *cb
00241                   , bool throwExceptionOnError = true
00242                   );
00243
00244 protected:
00245   virtual ~PlugIn();
00247
00254   virtual void deleteThis(void) = 0;
00255
00257   const PlugInCallback * callback( void ) const;
00258   PlugInCallback * callback( void );  // invoked for non-const PlugIn objects.
00259
00260 private:
00261   PlugInCallback  * m_cb;
00262 };
00263
00264 inline  PlugIn::PlugIn()
00265 : m_cb(NULL)
00266 {
00267 }
00268
00269 inline  void  PlugIn::setCallback( PlugInCallback *cb, bool throwExceptionOnError )
00270 {
00271   if ( m_cb )
00272   {
00273     m_cb->removeRef();
00274   }
00275   m_cb = cb;
00276   if ( m_cb )
00277   {
00278     m_cb->addRef();
00279     m_cb->setThrowExceptionOnError( throwExceptionOnError );
00280   }
00281 }
00282
00283 inline  const PlugInCallback * PlugIn::callback( void ) const
00284 {
00285   return( m_cb );
00286 }
00287
00288 inline  PlugInCallback * PlugIn::callback( void )
00289 {
00290   return( m_cb );
00291 }
00292
00293 inline  PlugIn::~PlugIn()
00294 {
00295   if ( m_cb )
00296   {
00297     m_cb->removeRef();
00298   }
00299 }
00300
00302
00309 class PlugInServer
00310 {
00311 public:
00312
00314
00343   friend NVSG_API bool getInterface(
00344     const std::vector<std::string>& searchPath
00345   , const UPIID& piid
00346   , PlugIn *& plugIn
00347   );
00348
00350
00362   friend NVSG_API bool queryInterfaceType(
00363     const std::vector<std::string>& searchPath
00364   , const UPITID& pitid
00365   , std::vector<UPIID>& piids
00366   );
00367
00369
00371   friend NVSG_API void releaseInterface(
00372     const UPIID& piid
00373   );
00374
00376
00379   friend NVSG_API void setPlugInFileFilter(
00380     const std::string& filter
00381   );
00382
00384
00390   friend NVSG_API void addPlugInSearchPath(
00391     const std::string& path
00392     );
00393
00395
00396   friend NVSG_API const std::vector<std::string>& getPlugInSearchPath();
00397
00398   PlugInServer();
00399   ~PlugInServer();
00400
00401 private:
00402   // hidden interface
00403   bool getInterfaceImpl(const std::vector<std::string>& searchPath, const UPIID& piid, PlugIn *& plugIn);
00404   bool queryInterfaceTypeImpl(const std::vector<std::string>& searchPath, const UPITID& pitid, std::vector<UPIID>& piids);
00405   void releaseInterfaceImpl(const UPIID& piid);
00406   void setFileFilterImpl(const std::string& filter);
00407
00408 private:
00409   // private plug-in administration
00410   class PlugInHolder
00411   {
00412   public:
00413     PlugInHolder(PlugIn * plugIn) : m_plugIn(plugIn), m_refCnt(1) {}
00414     void addRef() { ++m_refCnt; }
00415     unsigned int removeRef() { NVSG_ASSERT(m_refCnt>0); return --m_refCnt; }
00416     PlugIn * getPlugIn() const { return m_plugIn; }
00417   private:
00418     PlugIn * m_plugIn;
00419     unsigned int   m_refCnt;
00420   };
00421   bool findPlugIns(const std::vector<std::string>& searchPath, std::vector<std::string>& plugIns);
00422   bool registerPlugIn(const std::string& fileName, const UPIID& piid, PlugIn *& plugIn);
00423   typedef std::map< UPIID, PlugInHolder*> PlugInMap;
00424   PlugInMap m_plugIns;
00425   std::string m_filter;
00426   std::vector<std::string> m_searchPath;  // the search path for PlugIn DLLs
00427 };
00428
00430 typedef Singleton<PlugInServer> PIS;
00431
00432 } // namespace nvutil
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PlugInCallback.h File Reference

#include "nvsgcommon.h"
#include "nvutil/RCObject.h"

Include dependency graph for PlugInCallback.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:08 2008 for NVSGSDK by NVIDIA


PlugInCallback.h Source File

PlugInCallback.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include  "nvutil/RCObject.h"
00018
00019 namespace nvutil
00020 {
00022
00030   class PlugInCallback : public RCObject
00031   {
00032     public:
00034       typedef enum
00035       {
00036         PICE_UNEXPECTED_EOF,
00037         PICE_UNEXPECTED_TOKEN,
00038         PICE_UNKNOWN_TOKEN,
00039         PICE_FILE_ACCESS_FAILED,
00040         PICE_FILE_MAPPING_FAILED,
00041         PICE_INCOMPATIBLE_FILE,
00042         PICE_INVALID_FILE,
00043         PICE_UNSPECIFIED_ERROR
00044       } PIC_ERROR;
00045
00047       typedef enum
00048       {
00049         PICW_FILE_EMPTY,
00050         PICW_FILE_NOT_FOUND,
00051         PICW_FILES_NOT_FOUND,
00052         PICW_EMPTY_TOKEN,
00053         PICW_INCOMPATIBLE_VALUES,
00054         PICW_INVALID_VALUE,
00055         PICW_UNDEFINED_TOKEN,
00056         PICW_UNSUPPORTED_TOKEN,
00057         PICW_DEGENERATE_GEOMETRY,
00058         PICW_UNSPECIFIED_WARNING
00059       } PIC_WARNING;
00060
00062       typedef enum
00063       {
00064         PICT_INT,
00065         PICT_FLOAT
00066       } PIC_TYPE_ID;
00067
00069       typedef struct
00070       {
00071         unsigned int  position;
00072         std::string  context;
00073         std::string  token;
00074       } EmptyTokenInfo;
00075
00077       typedef struct
00078       {
00079         unsigned int        position;
00080         std::string        context;
00081         PIC_TYPE_ID   valueType;
00082         std::string        value0Name;
00083         const void *  value0;
00084         std::string        value1Name;
00085         const void *  value1;
00086       } IncompatibleValueInfo;
00087
00089       typedef struct
00090       {
00091         unsigned int        position;
00092         std::string        context;
00093         PIC_TYPE_ID   valueType;
00094         std::string        valueName;
00095         const void *  value;
00096       } InvalidValueInfo;
00097
00099       typedef struct
00100       {
00101         unsigned int        position;
00102         std::string        context;
00103         std::string        token;
00104       } UndefinedTokenInfo;
00105
00107       typedef struct
00108       {
00109         unsigned int        position;
00110         std::string        expected;
00111         std::string        encountered;
00112       } UnexpectedTokenInfo;
00113
00115       typedef struct
00116       {
00117         unsigned int        position;
00118         std::string        context;
00119         std::string        token;
00120       } UnknownTokenInfo;
00121
00123       typedef struct
00124       {
00125         unsigned int        position;
00126         std::string        context;
00127         std::string        token;
00128       } UnsupportedTokenInfo;
00129
00131       typedef struct
00132       {
00133         unsigned int        position;
00134         std::string   name;
00135       } DegenerateGeometryInfo;
00136
00138       typedef struct
00139       {
00140         std::string        file;
00141         unsigned int  systemSpecificErrorCode;
00142       } FileAccessFailedInfo;
00143
00145       typedef struct
00146       {
00147         unsigned int  systemSpecificErrorCode;
00148       } FileMappingFailedInfo;
00149
00151       typedef struct
00152       {
00153         std::string        file;
00154         std::string        context;
00155         unsigned int  expectedVersion;
00156
00157         unsigned int  detectedVersion;
00158
00159       } IncompatibleFileInfo;
00160
00162       typedef struct
00163       {
00164         std::string        file;
00165         std::string        context;
00166       } InvalidFileInfo;
00167
00168     public:
00170       PlugInCallback();
00171
00173       void  setThrowExceptionOnError( bool set );
00174
00176
00181       virtual void onError( PIC_ERROR eid
00182                           , const void *info
00183                           ) const;
00184
00186
00192       virtual bool onWarning( PIC_WARNING wid
00193                             , const void *info
00194                             ) const;
00195
00197
00209       virtual bool onUnLocalizedMessage( const std::string & severity,
00210                                          const std::string & message ) const;
00211
00213
00216       virtual void onUnexpectedEndOfFile( unsigned int position
00217                                         ) const;
00218
00220
00224       virtual void onUnexpectedToken( unsigned int position
00225                                     , const std::string &expected
00226                                     , const std::string &encountered
00227                                     ) const;
00228
00230
00234       virtual void onUnknownToken( unsigned int position
00235                                  , const std::string &context
00236                                  , const std::string &token
00237                                  ) const;
00238
00240
00244       virtual bool onEmptyToken( unsigned int position
00245                                , const std::string &context
00246                                , const std::string &token
00247                                ) const;
00248
00250
00253       virtual bool onFileEmpty( const std::string &file
00254                               ) const;
00255
00257
00260       virtual bool onFileNotFound( const std::string &file
00261                                  ) const;
00262
00264
00267       virtual bool onFilesNotFound( const std::vector<std::string> &files
00268                                   ) const;
00269
00271
00275       virtual bool onUndefinedToken( unsigned int position
00276                                    , const std::string &context
00277                                    , const std::string &token
00278                                    ) const;
00279
00281
00285       virtual bool onIncompatibleValues( unsigned int position
00286                                        , const std::string &context
00287                                        , const std::string &value0Name
00288                                        , int value0
00289                                        , const std::string &value1Name
00290                                        , int value1
00291                                        ) const;
00292
00294
00298       virtual bool onIncompatibleValues( unsigned int position
00299                                        , const std::string &context
00300                                        , const std::string &value0Name
00301                                        , float value0
00302                                        , const std::string &value1Name
00303                                        , float value1
00304                                        ) const;
00305
00307
00311       virtual bool onInvalidValue( unsigned int position
00312                                  , const std::string &context
00313                                  , const std::string &valueName
00314                                  , int value
00315                                  ) const;
00316
00318
00322       virtual bool onInvalidValue( unsigned int position
00323                                  , const std::string &context
00324                                  , const std::string &valueName
00325                                  , float value
00326                                  ) const;
00327
00329
00333       virtual bool onUnsupportedToken( unsigned int position
00334                                      , const std::string &context
00335                                      , const std::string &token
00336                                      ) const;
00337
00339
00343       virtual bool onDegenerateGeometry( unsigned int position
00344                                        , const std::string &context
00345                                        ) const;
00346
00348
00352       virtual void onFileAccessFailed( const std::string& file
00353                                      , unsigned int systemSpecificErrorCode
00354                                      ) const;
00355
00357
00361       virtual void onFileMappingFailed( unsigned int systemSpecificErrorCode
00362                                       ) const;
00363
00365
00369       virtual void onIncompatibleFile( const std::string& file
00370                                      , const std::string& context
00371                                      , unsigned int expectedVersion
00372
00373                                      , unsigned int detectedVersion
00374
00375                                      ) const;
00376
00378
00382       virtual void onInvalidFile( const std::string& file
00383                                 , const std::string& context
00384                                 ) const;
00385
00386     protected:
00388       virtual ~PlugInCallback();
00389
00390     private:
00391       bool  m_throwExceptionOnError;
00392   };
00393
00394   inline  PlugInCallback::PlugInCallback()
00395     : m_throwExceptionOnError(true)
00396   {
00397   }
00398
00399   inline  PlugInCallback::~PlugInCallback()
00400   {
00401   }
00402
00403   inline  void  PlugInCallback::setThrowExceptionOnError( bool set )
00404   {
00405     m_throwExceptionOnError = set;
00406   }
00407
00408   inline  void  PlugInCallback::onError( PIC_ERROR eid, const void *info ) const
00409   {
00410     if ( m_throwExceptionOnError )
00411     {
00412       throw( eid );
00413     }
00414   }
00415
00416   inline  bool  PlugInCallback::onWarning( PIC_WARNING wid, const void *info ) const
00417   {
00418     return( true );
00419   }
00420
00421   inline  bool  PlugInCallback::onUnLocalizedMessage(const std::string & severity,
00422                                                      const std::string & message )
00423                                                   const
00424   {
00425     if ( (severity == "ERROR") && m_throwExceptionOnError )
00426     {
00427       throw( PICE_UNSPECIFIED_ERROR );
00428     }
00429     else
00430     {
00431       return( true );
00432     }
00433   }
00434
00435   inline  void  PlugInCallback::onUnexpectedEndOfFile( unsigned int position ) const
00436   {
00437     onError( PICE_UNEXPECTED_EOF, &position );
00438   }
00439
00440   inline  void  PlugInCallback::onUnexpectedToken( unsigned int position, const std::string &expected, const std::string &encountered ) const
00441   {
00442     UnexpectedTokenInfo uti;
00443     uti.position    = position;
00444     uti.expected    = expected;
00445     uti.encountered = encountered;
00446     onError( PICE_UNEXPECTED_TOKEN, &uti );
00447   }
00448
00449   inline  void  PlugInCallback::onUnknownToken( unsigned int position, const std::string &context, const std::string &token ) const
00450   {
00451     UnknownTokenInfo  uti;
00452     uti.position  = position;
00453     uti.context   = context;
00454     uti.token     = token;
00455     onError( PICE_UNKNOWN_TOKEN, &uti );
00456   }
00457
00458
00459   inline  bool  PlugInCallback::onEmptyToken( unsigned int position, const std::string &context, const std::string &token ) const
00460   {
00461     EmptyTokenInfo  uti;
00462     uti.position  = position;
00463     uti.context   = context;
00464     uti.token     = token;
00465     return( onWarning( PICW_EMPTY_TOKEN, &uti ) );
00466   }
00467
00468   inline  bool  PlugInCallback::onDegenerateGeometry( unsigned int position, const std::string &name ) const
00469   {
00470     DegenerateGeometryInfo  dg;
00471     dg.position  = position;
00472     dg.name      = name;
00473     return( onWarning( PICW_DEGENERATE_GEOMETRY, &dg ) );
00474   }
00475
00476   inline  bool  PlugInCallback::onFileEmpty( const std::string &file ) const
00477   {
00478     return( onWarning( PICW_FILE_EMPTY, &file ) );
00479   }
00480
00481   inline  bool  PlugInCallback::onFileNotFound( const std::string &file ) const
00482   {
00483     return( onWarning( PICW_FILE_NOT_FOUND, &file ) );
00484   }
00485
00486   inline  bool  PlugInCallback::onFilesNotFound( const std::vector<std::string> &files ) const
00487   {
00488     return( onWarning( PICW_FILES_NOT_FOUND, &files ) );
00489   }
00490
00491   inline  bool  PlugInCallback::onUndefinedToken( unsigned int position, const std::string &context, const std::string &token ) const
00492   {
00493     EmptyTokenInfo  uti;
00494     uti.position  = position;
00495     uti.context   = context;
00496     uti.token     = token;
00497     return( onWarning( PICW_UNDEFINED_TOKEN, &uti ) );
00498   }
00499
00500   inline  bool  PlugInCallback::onIncompatibleValues( unsigned int position, const std::string &context, const std::string &value0Name,
00501                                                       int value0, const std::string &value1Name, int value1 ) const
00502   {
00503     IncompatibleValueInfo ivi;
00504     ivi.position    = position;
00505     ivi.context     = context;
00506     ivi.valueType   = PICT_INT;
00507     ivi.value0Name  = value0Name;
00508     ivi.value0      = &value0;
00509     ivi.value1Name  = value1Name;
00510     ivi.value1      = &value1;
00511     return( onWarning( PICW_INCOMPATIBLE_VALUES, &ivi ) );
00512   }
00513
00514   inline  bool  PlugInCallback::onIncompatibleValues( unsigned int position, const std::string &context, const std::string &value0Name,
00515                                                       float value0, const std::string &value1Name, float value1 ) const
00516   {
00517     IncompatibleValueInfo ivi;
00518     ivi.position    = position;
00519     ivi.context     = context;
00520     ivi.valueType   = PICT_FLOAT;
00521     ivi.value0Name  = value0Name;
00522     ivi.value0      = &value0;
00523     ivi.value1Name  = value1Name;
00524     ivi.value1      = &value1;
00525     return( onWarning( PICW_INCOMPATIBLE_VALUES, &ivi ) );
00526   }
00527
00528
00529   inline  bool  PlugInCallback::onInvalidValue( unsigned int position, const std::string &context,
00530                                                 const std::string &valueName, int value ) const
00531   {
00532     InvalidValueInfo  ivi;
00533     ivi.position  = position;
00534     ivi.context   = context;
00535     ivi.valueName = valueName;
00536     ivi.valueType = PICT_INT;
00537     ivi.value     = &value;
00538     return( onWarning( PICW_INVALID_VALUE, &ivi ) );
00539   }
00540
00541   inline  bool  PlugInCallback::onInvalidValue( unsigned int position, const std::string &context,
00542                                                 const std::string &valueName, float value ) const
00543   {
00544     InvalidValueInfo  ivi;
00545     ivi.position  = position;
00546     ivi.context   = context;
00547     ivi.valueName = valueName;
00548     ivi.valueType = PICT_FLOAT;
00549     ivi.value     = &value;
00550     return( onWarning( PICW_INVALID_VALUE, &ivi ) );
00551   }
00552
00553   inline  bool  PlugInCallback::onUnsupportedToken( unsigned int position, const std::string &context, const std::string &token ) const
00554   {
00555     UnsupportedTokenInfo  uti;
00556     uti.position  = position;
00557     uti.context   = context;
00558     uti.token     = token;
00559     return( onWarning( PICW_UNSUPPORTED_TOKEN, &uti ) );
00560   }
00561
00562   inline  void  PlugInCallback::onFileAccessFailed( const std::string& file, unsigned int systemSpecificErrorCode ) const
00563   {
00564     FileAccessFailedInfo fafi;
00565     fafi.file = file;
00566     fafi.systemSpecificErrorCode = systemSpecificErrorCode;
00567     onError(PICE_FILE_ACCESS_FAILED, &fafi);
00568   }
00569
00570   inline  void  PlugInCallback::onFileMappingFailed( unsigned int systemSpecificErrorCode ) const
00571   {
00572     FileMappingFailedInfo fmfi;
00573     fmfi.systemSpecificErrorCode = systemSpecificErrorCode;
00574     onError(PICE_FILE_MAPPING_FAILED, &fmfi);
00575   }
00576
00577   inline  void  PlugInCallback::onIncompatibleFile( const std::string& file, const std::string& context
00578                                                   , unsigned int expectedVersion, unsigned int detectedVersion) const
00579   {
00580     IncompatibleFileInfo ifi;
00581     ifi.file = file;
00582     ifi.context = context;
00583     ifi.expectedVersion = expectedVersion;
00584     ifi.detectedVersion = detectedVersion;
00585     onError(PICE_INCOMPATIBLE_FILE, &ifi);
00586   }
00587
00588   inline  void  PlugInCallback::onInvalidFile( const std::string& file, const std::string& context ) const
00589   {
00590     InvalidFileInfo ifi;
00591     ifi.file = file;
00592     ifi.context = context;
00593     onError(PICE_INVALID_FILE, &ifi);
00594   }
00595 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PlugInterface.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CoreTypes.h"
#include "nvutil/PlugIn.h"

Include dependency graph for PlugInterface.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:08 2008 for NVSGSDK by NVIDIA


PlugInterface.h Source File

PlugInterface.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/CoreTypes.h"
00017 #include "nvutil/PlugIn.h" // general PlugIn class definition
00018
00019 namespace nvsg
00020 {
00022
00088   // SceneLoader interface
00089   class SceneLoader : public nvutil::PlugIn
00090   {
00091     public:
00093
00100       NVSG_API virtual SceneHandle * load( const std::string& filename
00101                                          , const std::vector<std::string> &searchPaths
00102                                          , ViewStateHandle *& viewState
00104                                          ) = 0;
00105
00106     protected:
00108
00119       NVSG_API virtual ~SceneLoader();
00120   };
00121
00123
00125   class SceneSaver : public nvutil::PlugIn
00126   {
00127     public:
00129
00132       NVSG_API virtual bool save( nvsg::SceneHandle *scene
00133                                 , nvsg::ViewStateHandle *viewState
00134                                 , const std::string& filename ) = 0;
00135
00136     protected:
00138
00149       NVSG_API virtual ~SceneSaver();
00150   };
00151
00153
00154   class TextureLoader : public nvutil::PlugIn
00155   {
00156     public:
00168       NVSG_API TextureImageHandle * load( const std::string& filename
00169                                         , const std::vector<std::string>& searchPaths
00170                                           = std::vector<std::string>()
00171                                         , const unsigned int& creationFlags = 0 );
00172
00182       NVSG_API bool reload( TextureImageHandle * tih
00183                           , const std::vector<std::string>& searchPaths
00184                             = std::vector<std::string>() );
00185
00186     protected:
00188
00199       NVSG_API virtual ~TextureLoader();
00200
00207       NVSG_API virtual TextureImageHandle * createTextureImageHandle();
00208
00220       NVSG_API virtual bool onLoad( const std::string & filename
00221                                   , nvsg::TextureImage * texImg
00222                                   , const std::vector<std::string> & searchPaths ) = 0;
00223   };
00224
00226
00227   class TextureSaver : public nvutil::PlugIn
00228   {
00229     public:
00231
00234       NVSG_API virtual bool save( TextureImageHandle * image
00235                                 , const std::string & fileName ) = 0;
00236
00237     protected:
00239
00250       NVSG_API virtual ~TextureSaver();
00251   };
00252
00253 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PlugInterfaceID.h File Reference

#include "nvsg/NVSGVersion.h"

Include dependency graph for PlugInterfaceID.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Defines

#define | UPITID_VERSION NVSG_VER_MAJOR_STR "." NVSG_VER_MINOR_STR
A string define serving for version safty.

#define | UPITID_SCENE_LOADER 0x0001
Unique Plug-In Type ID for Scene loaders.

#define | UPITID_SCENE_SAVER 0x0002
Unique Plug-In Type ID for Scene savers.

#define | UPITID_TEXTURE_LOADER 0x0004
Unique Plug-In Type ID for texture loaders (not yet implemented).

#define | UPITID_TEXTURE_SAVER 0x0008
Unique Plug-In Type ID for texture savers.

Detailed Description

Define Documentation

#define UPITID_VERSION NVSG_VER_MAJOR_STR "." NVSG_VER_MINOR_STR

A string define serving for version safty.

#define UPITID_SCENE_LOADER 0x0001

Unique Plug-In Type ID for Scene loaders.

#define UPITID_SCENE_SAVER 0x0002

Unique Plug-In Type ID for Scene savers.

#define UPITID_TEXTURE_LOADER 0x0004

Unique Plug-In Type ID for texture loaders (not yet implemented).

#define UPITID_TEXTURE_SAVER 0x0008

Unique Plug-In Type ID for texture savers.

Generated on Tue Jan 15 10:28:08 2008 for NVSGSDK by NVIDIA


PlugInterfaceID.h Source File

PlugInterfaceID.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/NVSGVersion.h"
00016
00018 #define UPITID_VERSION        NVSG_VER_MAJOR_STR "." NVSG_VER_MINOR_STR
00019
00020 #define UPITID_SCENE_LOADER   0x0001
00021 #define UPITID_SCENE_SAVER    0x0002
00022 #define UPITID_TEXTURE_LOADER 0x0004
00023 #define UPITID_TEXTURE_SAVER  0x0008
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PLYLoader.h File Reference

#include <fstream>
#include <string>
#include "nvsg/nvsgapi.h"
#include "nvsg/CoreTypes.h"
#include "nvsg/PlugInterface.h"
#include "nvutil/PlugInCallback.h"
#include "nvutil/Tools.h"
#include "nvutil/FileMapping.h"
#include "nvutil/RCObject.h"

Include dependency graph for PLYLoader.h:

Include dependency graph

Go to the source code of this file.

Classes

class | PLYProperty
class | PLYElement
class | PLYLoader
A Scene Loader for PLY files. More...

class | PLYLoader::Offset_AutoPtr
An auxiliary helper template class which provides exception safe mapping and unmapping of file offsets.

Defines

#define | ATTRIBUTE_MASK_VERTEX ((1 << PLY_VERTEX_X) | (1 << PLY_VERTEX_Y) | (1 << PLY_VERTEX_Z))
#define | ATTRIBUTE_MASK_NORMAL ((1 << PLY_NORMAL_X) | (1 << PLY_NORMAL_Y) | (1 << PLY_NORMAL_Z))
#define | ATTRIBUTE_MASK_COLOR ((1 << PLY_COLOR_R) | (1 << PLY_COLOR_G) | (1 << PLY_COLOR_B))

Typedefs

typedef char | byte_t
Specifies an 8-bit signed type.

typedef unsigned char | ubyte_t
Specifies an 8-bit unsigned type.

typedef int | int_t
Specifies a 32-bit signed integer type.

typedef unsigned int | uint_t
Specifies a 32-bit unsigned integer type.

typedef unsigned long long | uint64_t
Specifies a 64-bit unsigned integer type.

typedef unsigned int | DWORD
typedef bool | BOOL
typedef void(PLYLoader::* | PFN_READ )(void *dst)
typedef void(PLYLoader::* | PFN_READ_ATTRIBUTE )(float *dst)

Enumerations

enum PLY_TOKEN {
PLY_TOKEN_CHAR = 0, PLY_TOKEN_UCHAR, PLY_TOKEN_SHORT, PLY_TOKEN_USHORT,
PLY_TOKEN_INT, PLY_TOKEN_UINT, PLY_TOKEN_FLOAT, PLY_TOKEN_DOUBLE,
PLY_TOKEN_PLY, PLY_TOKEN_FORMAT, PLY_TOKEN_ASCII, PLY_TOKEN_BINARYLITTLEENDIAN,
PLY_TOKEN_BINARYBIGENDIAN, PLY_TOKEN_ONEPOINTZERO, PLY_TOKEN_COMMENT, PLY_TOKEN_OBJINFO,
PLY_TOKEN_ELEMENT, PLY_TOKEN_PROPERTY, PLY_TOKEN_LIST, PLY_TOKEN_ENDHEADER,
PLY_TOKEN_UNKNOWN
}
enum PLY_PARSER_STATE {
PLY_STATE_PLY, PLY_STATE_FORMAT, PLY_STATE_FORMAT_TYPE, PLY_STATE_FORMAT_VERSION,
PLY_STATE_ELEMENT, PLY_STATE_ELEMENT_IDENTIFIER, PLY_STATE_ELEMENT_COUNT, PLY_STATE_PROPERTY,
PLY_STATE_PROPERTY_TYPE, PLY_STATE_PROPERTY_LIST_COUNT_TYPE, PLY_STATE_PROPERTY_LIST_DATA_TYPE, PLY_STATE_PROPERTY_NAME,
PLY_STATE_END
}
enum PLY_ATTRIBUTE_COMPONENT {
PLY_VERTEX_X = 0, PLY_VERTEX_Y, PLY_VERTEX_Z, PLY_NORMAL_X,
PLY_NORMAL_Y, PLY_NORMAL_Z, PLY_COLOR_R, PLY_COLOR_G,
PLY_COLOR_B, PLY_USER_DEFINED_COMPONENT
}

Functions

void | lib_init () __attribute__((constructor))
PLYLOADER_API bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

PLYLOADER_API bool | queryPlugInterfaceType (const nvutil::UPITID &pitid, std::vector< nvutil::UPIID > &piids)
Query the supported types of PlugIn Interfaces.

Detailed Description

Typedef Documentation

typedef char byte_t

Specifies an 8-bit signed type.

typedef unsigned char ubyte_t

Specifies an 8-bit unsigned type.

typedef int int_t

Specifies a 32-bit signed integer type.

typedef unsigned int uint_t

Specifies a 32-bit unsigned integer type.

typedef unsigned long long uint64_t

Specifies a 64-bit unsigned integer type.

Function Documentation

PLYLOADER_API bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) |

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a PLYLoader. If the PlugIn ID piid equals PIID_PLY_SCENE_LOADER, a PLYLoader is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

PLYLOADER_API bool queryPlugInterfaceType | ( | const nvutil::UPITID & | pitid,
 |  | std::vector< nvutil::UPIID > & | piids
 | ) |

Query the supported types of PlugIn Interfaces.

Every PlugIn has to resolve this function. It is used to query the supported Interface types of this PlugIn. If the Plug In Type ID pitid equals PITID_SCENE_LOADER, the vector piids is filled with one element PIID_PLY_SCENE_LOADER.

Returns:
true, if a PITID_SCENE_LOADER is requested, otherwise false

Generated on Tue Jan 15 10:28:09 2008 for NVSGSDK by NVIDIA


PLYLoader.h Source File

PLYLoader.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <fstream>
00016 #include <string>
00017
00018 #include "nvsg/nvsgapi.h"
00019 #include "nvsg/CoreTypes.h"
00020 #include "nvsg/PlugInterface.h"
00021 #include "nvutil/PlugInCallback.h"
00022 #include "nvutil/Tools.h"
00023 #include "nvutil/FileMapping.h"
00024 #include "nvutil/RCObject.h"  // RCObject_AutoPtr
00025
00026
00027 // convenient aliases for used built-in types
00028 typedef char                    byte_t;
00029 typedef unsigned char           ubyte_t;
00030 typedef int                     int_t;
00031 typedef unsigned int            uint_t;
00032 #ifdef LINUX
00033 # if __WORDSIZE == 64           // defined indirectly through stdint.h
00034 // avoid a conflict with GNU stdint.h on Linux64
00035 // note: long is a 64-bit type on Linux64, while it is 32bit on Win64
00036 // Linux64
00037 typedef unsigned long           uint64_t;
00038 # else
00039 // Linux32
00040 typedef unsigned long long      uint64_t;
00041 # endif
00042 #else
00043 // Win32 and Win64
00044 typedef unsigned long long      uint64_t;
00045 #endif
00046
00047
00048
00049
00050 // storage-class defines
00051 #if ! defined( DOXYGEN_IGNORE )
00052 # if defined(_WIN32)
00053 #  ifdef PLYLOADER_EXPORTS
00054 #   define PLYLOADER_API __declspec(dllexport)
00055 #  else
00056 #   define PLYLOADER_API __declspec(dllimport)
00057 #  endif
00058 # else
00059 #   define PLYLOADER_API
00060 # endif
00061 #endif
00062
00063 #if defined(LINUX)
00064 typedef unsigned int DWORD;
00065 typedef bool BOOL;
00066 void lib_init() __attribute__ ((constructor));   // will be called before dlopen() returns
00067 #endif
00068
00069
00070 // exports required for a scene loader plug-in
00071 #if defined(LINUX)
00072 extern "C"
00073 {
00074 #endif
00075
00077
00081 PLYLOADER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00082
00084
00089 PLYLOADER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00090
00091 #if defined(LINUX)
00092 }
00093 #endif
00094
00095
00096 // PLY Datatypes:
00097 // name        type        number of bytes   alias added in this loader:
00098 //                                           (Often found in older files!)
00099 // ---------------------------------------   -----------------------------
00100 // int8       character                 1    char
00101 // uint8      unsigned character        1    uchar
00102 // int16      short integer             2    short
00103 // uint16     unsigned short integer    2    ushort
00104 // int32      integer                   4    int
00105 // uint32     unsigned integer          4    uint
00106 // float32    single-precision float    4    float
00107 // float64    double-precision float    8    double
00108
00109
00110 // These enums encode the predefined keywords inside standard PLY files.
00111 typedef enum
00112 {
00113   PLY_TOKEN_CHAR = 0,   // These data type tokens are zero based and used to index read function tables.
00114   PLY_TOKEN_UCHAR,
00115   PLY_TOKEN_SHORT,
00116   PLY_TOKEN_USHORT,
00117   PLY_TOKEN_INT,
00118   PLY_TOKEN_UINT,
00119   PLY_TOKEN_FLOAT,
00120   PLY_TOKEN_DOUBLE,
00121
00122   PLY_TOKEN_PLY,
00123   PLY_TOKEN_FORMAT,
00124
00125   PLY_TOKEN_ASCII,                // These three enums must be consecutive in this order to be used for function table lookup.
00126   PLY_TOKEN_BINARYLITTLEENDIAN,   // "-"
00127   PLY_TOKEN_BINARYBIGENDIAN,      // "-"
00128
00129   PLY_TOKEN_ONEPOINTZERO,
00130   PLY_TOKEN_COMMENT,
00131   PLY_TOKEN_OBJINFO,
00132   PLY_TOKEN_ELEMENT,
00133   PLY_TOKEN_PROPERTY,
00134   PLY_TOKEN_LIST,
00135   PLY_TOKEN_ENDHEADER,
00136
00137   PLY_TOKEN_UNKNOWN
00138
00139 } PLY_TOKEN;
00140
00141
00142 // These enums define the states of a simple state machine used during parsing of the PLY header.
00143 typedef enum
00144 {
00145   PLY_STATE_PLY,
00146   PLY_STATE_FORMAT,
00147   PLY_STATE_FORMAT_TYPE,
00148   PLY_STATE_FORMAT_VERSION,
00149   PLY_STATE_ELEMENT,
00150   PLY_STATE_ELEMENT_IDENTIFIER,
00151   PLY_STATE_ELEMENT_COUNT,
00152   PLY_STATE_PROPERTY,
00153   PLY_STATE_PROPERTY_TYPE,
00154   PLY_STATE_PROPERTY_LIST_COUNT_TYPE,
00155   PLY_STATE_PROPERTY_LIST_DATA_TYPE,
00156   PLY_STATE_PROPERTY_NAME,
00157   PLY_STATE_END
00158 } PLY_PARSER_STATE;
00159
00160
00161 typedef enum
00162 {
00163   PLY_VERTEX_X = 0, // Zero based, used as indices and attribute bit flag location.
00164   PLY_VERTEX_Y,
00165   PLY_VERTEX_Z,
00166   PLY_NORMAL_X,
00167   PLY_NORMAL_Y,
00168   PLY_NORMAL_Z,
00169   PLY_COLOR_R,
00170   PLY_COLOR_G,
00171   PLY_COLOR_B,
00172   PLY_USER_DEFINED_COMPONENT // Will be ignored.
00173 } PLY_ATTRIBUTE_COMPONENT;
00174
00175
00176 #define ATTRIBUTE_MASK_VERTEX  ((1 << PLY_VERTEX_X) | (1 << PLY_VERTEX_Y) | (1 << PLY_VERTEX_Z))
00177 #define ATTRIBUTE_MASK_NORMAL  ((1 << PLY_NORMAL_X) | (1 << PLY_NORMAL_Y) | (1 << PLY_NORMAL_Z))
00178 #define ATTRIBUTE_MASK_COLOR   ((1 << PLY_COLOR_R)  | (1 << PLY_COLOR_G)  | (1 << PLY_COLOR_B))
00179
00180
00181 class PLYLoader;
00182
00183 // Generic function pointer to write data from binary input data starting at m_pcCurrent to dst address.
00184 typedef void (PLYLoader::*PFN_READ)(void *dst);
00185 // Similar to above but data conversion to float based on OpenGL component conversion rules (OpenGL 2.1 specs Table 2.9)
00186 typedef void (PLYLoader::*PFN_READ_ATTRIBUTE)(float *dst);
00187
00188
00189 class PLYProperty
00190 {
00191 public:
00192     PLYProperty();
00193     ~PLYProperty();
00194
00195     std::string name;      // Name of this poperty inside this element. Required to identify attributes (so far x, y, z, nx, ny, nz).
00196     PLY_TOKEN countType;   // Scalar integer count for list properties. TOKEN_UNKNOWN indicates non-list property.
00197     PLY_TOKEN dataType;    // Scalar data type for any property.
00198     PFN_READ pfnReadCount; // Read function for this property count, set if it's a list.
00199     PFN_READ pfnReadData;  // Read function for this property data, set if it's a list.
00200     PFN_READ_ATTRIBUTE pfnReadAttribute;  // Read function for this property data, set if it's an attribute. (Automatic conversion!)
00201     unsigned int index;    // Index inside attribute float array, the last element outside the supported attribute components is used to ignore unknown attribute data.
00202 };
00203
00204
00205 class PLYElement
00206 {
00207 public:
00208   PLYElement();
00209   ~PLYElement();
00210
00211   std::string name;                           // Name of this element.
00212   unsigned int count;                         // Number of elements of this type in the file.
00213   std::vector<PLYProperty *> m_pProperties;   // Variable number of property fields per element.
00214 };
00215
00216
00218
00222 class PLYLoader : public nvsg::SceneLoader
00223 {
00224   public :
00225     //  Default constructor.
00226     PLYLoader();
00227     ~PLYLoader();
00228
00229   protected:
00230
00232
00234     ubyte_t * mapOffset( uint_t offset
00235                        , size_t numBytes
00236                        );
00237
00239
00240     void unmapOffset(ubyte_t * offsetPtr
00241                     );
00242
00243   public :
00245
00246     void  deleteThis( void );
00247
00249
00254     nvsg::SceneHandle * load( const std::string& filename
00255                             , const std::vector<std::string> &searchPaths
00256                             , nvsg::ViewStateHandle *& viewState
00258                             );
00259
00260   private :
00261
00263
00265     template<typename T>
00266     class Offset_AutoPtr
00267     {
00268       public:
00270
00272         Offset_AutoPtr( nvutil::ReadMapping * fm, const nvutil::PlugInCallback * pic,
00273                         uint_t offset, size_t count = 1 );
00274
00276         ~Offset_AutoPtr();
00277
00279         T* operator->() const;
00280
00282         T& operator*() const;
00283
00285         operator const T*() const;
00286
00288
00290         void reset( uint_t offset, size_t count = 1 );
00291
00292       private:
00293         T * m_ptr;
00294         const nvutil::PlugInCallback  * m_pic;
00295         nvutil::ReadMapping           * m_fm;
00296     };
00297
00298     // Parsing a binary filemapping.
00299     nvutil::ReadMapping * m_fm;
00300
00301     std::map<std::string, PLY_TOKEN>               m_mapStringToToken;
00302     std::map<std::string, PLY_ATTRIBUTE_COMPONENT> m_mapStringToAttributeComponent;
00303
00304     char *m_pcCurrent;
00305     char *m_pcEOF;
00306     char m_token[256];
00307     int m_plyFormat;
00308     std::vector<PLYElement *> m_pElements;
00309
00310
00311     void cleanup(void);
00312     void initializeMapStringToToken(void);
00313     int lookAheadToken(void);
00314     int skipLine(void);
00315
00316     void readAttributeAscii_CHAR(float *dst);
00317     void readAttributeAnyEndian_CHAR(float *dst);
00318     void readAttributeAscii_UCHAR(float *dst);
00319     void readAttributeAnyEndian_UCHAR(float *dst);
00320     void readAttributeAscii_SHORT(float *dst);
00321     void readAttributeLittleEndian_SHORT(float *dst);
00322     void readAttributeBigEndian_SHORT(float *dst);
00323     void readAttributeAscii_USHORT(float *dst);
00324     void readAttributeLittleEndian_USHORT(float *dst);
00325     void readAttributeBigEndian_USHORT(float *dst);
00326     void readAttributeAscii_INT(float *dst);
00327     void readAttributeLittleEndian_INT(float *dst);
00328     void readAttributeBigEndian_INT(float *dst);
00329     void readAttributeAscii_UINT(float *dst);
00330     void readAttributeLittleEndian_UINT(float *dst);
00331     void readAttributeBigEndian_UINT(float *dst);
00332     void readAttributeAscii_FLOAT(float *dst);
00333     void readAttributeLittleEndian_FLOAT(float *dst);
00334     void readAttributeBigEndian_FLOAT(float *dst);
00335     void readAttributeLittleEndian_DOUBLE(float *dst);
00336     void readAttributeBigEndian_DOUBLE(float *dst);
00337
00338     void readAscii_CHAR(void *dst);
00339     void readAnyEndian_CHAR(void *dst);
00340     void readAscii_UCHAR(void *dst);
00341     void readAnyEndian_UCHAR(void *dst);
00342     void readAscii_SHORT(void *dst);
00343     void readLittleEndian_SHORT(void *dst);
00344     void readBigEndian_SHORT(void *dst);
00345     void readAscii_USHORT(void *dst);
00346     void readLittleEndian_USHORT(void *dst);
00347     void readBigEndian_USHORT(void *dst);
00348     void readAscii_INT(void *dst);
00349     void readLittleEndian_INT(void *dst);
00350     void readBigEndian_INT(void *dst);
00351     void readAscii_UINT(void *dst);
00352     void readLittleEndian_UINT(void *dst);
00353     void readBigEndian_UINT(void *dst);
00354     void readAscii_FLOAT(void *dst);
00355     void readLittleEndian_FLOAT(void *dst);
00356     void readBigEndian_FLOAT(void *dst);
00357     void readAscii_DOUBLE(void *dst);
00358     void readLittleEndian_DOUBLE(void *dst);
00359     void readBigEndian_DOUBLE(void *dst);
00360
00361     unsigned int readListCounterOrIndex(PFN_READ pfn, PLY_TOKEN type);
00362     void ignoreProperty(PLYProperty *p);
00363
00364     // Tables of read functions.
00365     PFN_READ_ATTRIBUTE m_apfnReadAttribute[8][3]; // Special in that it converts integer data to float according to the OpenGL specs.
00366     PFN_READ           m_apfnRead[8][3];          // Read data as it is. Caller needs to figure out what it was.
00367
00368
00369     nvsg::SceneHandle  * import( const std::string &filename, nvsg::ViewStateHandle *& viewState );
00370
00371     void                       onError(const std::string &message) const;
00372     bool                       onIncompatibleValues( int value0, int value1, const std::string &node, const std::string &field0, const std::string &field1 ) const;
00373     template<typename T> bool  onInvalidValue( T value, const std::string &node, const std::string &field ) const;
00374     bool                       onEmptyToken( const std::string &tokenType, const std::string &token ) const;
00375     bool                       onFileNotFound( const std::string &file ) const;
00376     bool                       onFilesNotFound( bool found, const std::vector<std::string> &files ) const;
00377     void                       onUnexpectedEndOfFile( bool error ) const;
00378     void                       onUnexpectedToken( const std::string &expected, const std::string &token ) const;
00379     void                       onUnknownToken( const std::string &context, const std::string &token ) const;
00380     bool                       onUndefinedToken( const std::string &context, const std::string &token ) const;
00381     bool                       onUnsupportedToken( const std::string &context, const std::string &token ) const;
00382
00383   private :
00384
00385     unsigned int                       m_line;
00386     nvsg::SceneHandle                 *m_scene;
00387     std::vector<std::string>           m_searchPaths;
00388 };
00389
00390 inline void PLYLoader::deleteThis( void )
00391 {
00392   delete this;
00393 }
00394
00395
00396
00397 inline ubyte_t * PLYLoader::mapOffset( uint_t offset, size_t numBytes )
00398 {
00399   NVSG_TRACE();
00400   NVSG_ASSERT( m_fm );
00401   return( (ubyte_t*) m_fm->mapIn( offset, numBytes ) );
00402 }
00403
00404 inline void PLYLoader::unmapOffset( ubyte_t * offsetPtr )
00405 {
00406   NVSG_TRACE();
00407   NVSG_ASSERT( m_fm );
00408   m_fm->mapOut( offsetPtr );
00409 }
00410
00411 template<typename T>
00412 inline PLYLoader::Offset_AutoPtr<T>::Offset_AutoPtr( nvutil::ReadMapping * fm
00413                                                    , const nvutil::PlugInCallback * pic
00414                                                    , uint_t offset, size_t count )
00415 : m_ptr(NULL)
00416 , m_fm(fm)
00417 , m_pic(pic)
00418 {
00419   if ( count )
00420   {
00421     m_ptr = (T*)m_fm->mapIn(offset, count*sizeof(T));
00422     if ( ! m_ptr && m_pic )
00423     {
00424       m_pic->onFileMappingFailed(m_fm->getLastError());
00425     }
00426   }
00427  }
00428
00429 template<typename T>
00430 inline PLYLoader::Offset_AutoPtr<T>::~Offset_AutoPtr()
00431 {
00432   if ( m_ptr )
00433   {
00434     m_fm->mapOut((ubyte_t*)m_ptr);
00435   }
00436 }
00437
00438 template<typename T>
00439 inline T* PLYLoader::Offset_AutoPtr<T>::operator->() const
00440 {
00441   return m_ptr;
00442 }
00443
00444 template<typename T>
00445 inline T& PLYLoader::Offset_AutoPtr<T>::operator*() const
00446 {
00447   return *m_ptr;
00448 }
00449
00450 template<typename T>
00451 inline PLYLoader::Offset_AutoPtr<T>::operator const T*() const
00452 {
00453   return m_ptr;
00454 }
00455
00456 template<typename T>
00457 inline void PLYLoader::Offset_AutoPtr<T>::reset( uint_t offset, size_t count )
00458 {
00459   if ( m_ptr )
00460   {
00461     m_fm->mapOut((ubyte_t*)m_ptr);
00462     m_ptr=NULL;
00463   }
00464   if ( count )
00465   {
00466     m_ptr = (T*)m_fm->mapIn(offset, count*sizeof(T));
00467     if ( ! m_ptr && m_pic )
00468     {
00469       m_pic->onFileMappingFailed(m_fm->getLastError());
00470     }
00471   }
00472 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PointAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/PrimitiveAttribute.h"
#include <float.h>

Include dependency graph for PointAttribute.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:09 2008 for NVSGSDK by NVIDIA


PointAttribute.h Source File

PointAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/PrimitiveAttribute.h"
00017 #include <float.h>
00018
00019 namespace nvsg
00020 {
00026   class PointAttribute : public PrimitiveAttribute
00027   {
00028     public:
00032       NVSG_API PointAttribute();
00033
00038        NVSG_API explicit PointAttribute( const PrimitiveAttribute &rhs );
00039
00041       NVSG_API PointAttribute( const PointAttribute &rhs );
00042
00044       NVSG_API virtual ~PointAttribute();
00045
00052       NVSG_API bool isAntiAliased() const;
00053
00060       NVSG_API void setAntiAliasing( bool aa );
00061
00066       NVSG_API float getSize() const;
00067
00072       NVSG_API void setSize( float size );
00073
00080       NVSG_API PointAttribute & operator=(const PointAttribute & rhs);
00081
00091       NVSG_API virtual bool isEquivalent( const Object * p
00092                                         , bool ignoreNames
00093                                         , bool deepCompare ) const;
00094
00095     private:
00096       bool  m_antiAliasing;
00097       float m_size;
00098   };
00099
00100   inline float PointAttribute::getSize() const
00101   {
00102     NVSG_TRACE();
00103     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00104     return( m_size );
00105   }
00106
00107   inline bool PointAttribute::isAntiAliased() const
00108   {
00109     NVSG_TRACE();
00110     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00111     return( m_antiAliasing );
00112   }
00113
00114   inline void PointAttribute::setAntiAliasing( bool aa )
00115   {
00116     NVSG_TRACE();
00117     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00118     if ( m_antiAliasing != aa )
00119     {
00120       m_antiAliasing = aa;
00121       invalidateIncarnation();
00122     }
00123   }
00124
00125   inline void PointAttribute::setSize( float size )
00126   {
00127     NVSG_TRACE();
00128     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00129     NVSG_ASSERT( FLT_EPSILON < size );
00130     if ( m_size != size )
00131     {
00132       m_size = size;
00133       invalidateIncarnation();
00134     }
00135   }
00136
00137 } // namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PointLight.h File Reference

#include "nvsgcommon.h"
#include "nvsg/LightSource.h"

Include dependency graph for PointLight.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:09 2008 for NVSGSDK by NVIDIA


PointLight.h Source File

PointLight.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include  "nvsg/LightSource.h"
00017
00018 namespace nvsg
00019 {
00033   class PointLight : public LightSource
00034   {
00035     public:
00038       NVSG_API PointLight();
00039
00047       NVSG_API explicit PointLight( const LightSource &rhs );
00048
00051       NVSG_API PointLight( const PointLight &rhs );
00052
00055       NVSG_API virtual ~PointLight();
00056
00061       NVSG_API const nvmath::Vec3f & getPosition() const;
00062
00067       NVSG_API void setPosition( const nvmath::Vec3f & position );
00068
00075       NVSG_API bool isAttenuated() const;
00076
00087       NVSG_API void getAttenuation( float &c
00088                                   , float &l
00089                                   , float &q ) const;
00090
00100       NVSG_API const nvmath::Vec3f& getAttenuation() const;
00101
00112       NVSG_API void setAttenuation( float c
00113                                   , float l
00114                                   , float q );
00115
00125       NVSG_API void setAttenuation( const nvmath::Vec3f &attenuation );
00126
00133       NVSG_API PointLight & operator=( const PointLight & rhs );
00134
00145       NVSG_API virtual bool isEquivalent( const Object * p
00146                                         , bool ignoreNames
00147                                         , bool deepCompare ) const;
00148
00149     private:
00150       nvmath::Vec3f m_attenuation;
00151   };
00152
00153   inline void PointLight::getAttenuation( float &c, float &l, float &q ) const
00154   {
00155     NVSG_TRACE();
00156     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00157     c = m_attenuation[0];
00158     l = m_attenuation[1];
00159     q = m_attenuation[2];
00160   }
00161
00162   inline const nvmath::Vec3f& PointLight::getAttenuation() const
00163   {
00164     NVSG_TRACE();
00165     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00166     return m_attenuation;
00167   }
00168
00169   inline bool PointLight::isAttenuated() const
00170   {
00171     NVSG_TRACE();
00172     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00173     return(   ( m_attenuation[0] != 1.0f )
00174           ||  ( m_attenuation[1] != 0.0f )
00175           ||  ( m_attenuation[2] != 0.0f )
00176           );
00177   }
00178
00179   inline void PointLight::setAttenuation( float c, float l, float q )
00180   {
00181     NVSG_TRACE();
00182     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00183     if ( ( m_attenuation[0] != c ) || ( m_attenuation[1] != l ) || ( m_attenuation[2] != q ) )
00184     {
00185       m_attenuation[0] = c;
00186       m_attenuation[1] = l;
00187       m_attenuation[2] = q;
00188       invalidateIncarnation();
00189     }
00190   }
00191
00192   inline void PointLight::setAttenuation( const nvmath::Vec3f & attenuation )
00193   {
00194     NVSG_TRACE();
00195     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00196     if ( m_attenuation != attenuation )
00197     {
00198       m_attenuation = attenuation;
00199       invalidateIncarnation();
00200     }
00201   }
00202
00203   inline const nvmath::Vec3f & PointLight::getPosition() const
00204   {
00205     NVSG_TRACE();
00206     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00207     return m_trafo.getTranslation();
00208   }
00209
00210 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Points.h File Reference

#include "nvsgcommon.h"
#include "nvsg/IndependentPrimitiveSet.h"

Include dependency graph for Points.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:10 2008 for NVSGSDK by NVIDIA


Points.h Source File

Points.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/IndependentPrimitiveSet.h" // base class definition
00017
00018 namespace nvsg
00019 {
00026   class Points : public IndependentPrimitiveSet
00027   {
00028     public:
00030       NVSG_API Points();
00031
00033       NVSG_API explicit Points( const IndependentPrimitiveSet &rhs );
00034
00036       NVSG_API explicit Points( const PrimitiveSet &rhs );
00037
00039       NVSG_API Points( const Points &rhs );
00040
00042       NVSG_API virtual ~Points();
00043
00049       NVSG_API Points & operator=(const Points & rhs);
00050
00051   };
00052
00053 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PrimitiveAttribute.h File Reference

#include "nvsg/StateAttribute.h"

Include dependency graph for PrimitiveAttribute.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:10 2008 for NVSGSDK by NVIDIA


PrimitiveAttribute.h Source File

PrimitiveAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/StateAttribute.h"
00016
00017 namespace nvsg
00018 {
00025   class PrimitiveAttribute : public StateAttribute
00026   {
00027     public:
00029       NVSG_API virtual ~PrimitiveAttribute();
00030
00031     protected:
00034       NVSG_API PrimitiveAttribute();
00035
00039       NVSG_API PrimitiveAttribute( const PrimitiveAttribute& rhs );
00040
00046       NVSG_API PrimitiveAttribute & operator=(const PrimitiveAttribute & rhs);
00047   };
00048 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PrimitiveSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Drawable.h"

Include dependency graph for PrimitiveSet.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:10 2008 for NVSGSDK by NVIDIA


PrimitiveSet.h Source File

PrimitiveSet.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Drawable.h" // base class definition
00017
00018 namespace nvsg
00019 {
00025   class PrimitiveSet : public Drawable
00026   {
00027     public:
00029       NVSG_API virtual ~PrimitiveSet();
00030
00034       NVSG_API VertexAttributeSetHandle * getVertexAttributeSet() const;
00035
00041       NVSG_API void setVertexAttributeSet( VertexAttributeSetHandle * vash );
00042
00048       NVSG_API SkinHandle * getSkin() const;
00049
00055       NVSG_API void setSkin( SkinHandle * skin );
00056
00063       NVSG_API bool isCompatible( const PrimitiveSet *p ) const;
00064
00077       NVSG_API virtual bool isEquivalent( const Object * p
00078                                         , bool ignoreNames
00079                                         , bool deepCompare ) const;
00080
00086       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00087
00090       NVSG_API void invalidateAnimationContainment();
00091
00094       NVSG_API virtual bool containsAnimation() const;
00095
00096   protected:
00100       NVSG_API PrimitiveSet();
00101
00106       NVSG_API PrimitiveSet( const PrimitiveSet& rhs );
00107
00113       NVSG_API PrimitiveSet & operator=( const PrimitiveSet & rhs );
00114
00115     private:
00116       SkinHandle                * m_skin;
00117       VertexAttributeSetHandle  * m_vertexAttributeSet;
00118   };
00119
00120   inline VertexAttributeSetHandle * PrimitiveSet::getVertexAttributeSet() const
00121   {
00122     NVSG_TRACE();
00123     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00124     return( m_vertexAttributeSet );
00125   }
00126
00127   inline SkinHandle * PrimitiveSet::getSkin() const
00128   {
00129     NVSG_TRACE();
00130     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00131     return( m_skin );
00132   }
00133
00134 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


ProblemLog.h File Reference

#include "nvsg/nvsgapi.h"
#include <string>
#include <list>

Include dependency graph for ProblemLog.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:10 2008 for NVSGSDK by NVIDIA


ProblemLog.h Source File

ProblemLog.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/nvsgapi.h"  // storage-class defines
00016 #include <string>
00017 #include <list>
00018
00019 namespace nvutil
00020 {
00022
00024   class ProblemInfo
00025   {
00026   public:
00028     ProblemInfo( const char * problem
00029                , bool isCritical
00030                , const char * missingFeatures
00031                )
00032       : m_problem(problem), m_isCritical(isCritical), m_missingFeatures(missingFeatures) {}
00033     ~ProblemInfo() {}
00034
00035     std::string m_problem;
00036     bool        m_isCritical;
00037     std::string m_missingFeatures;
00038   };
00039
00040   class LogListCompare
00041   {
00042   public:
00043     LogListCompare() {}
00044     ~LogListCompare() {}
00045
00046     bool operator()( const ProblemInfo & infoA, const ProblemInfo & infoB ) const;
00047   };
00048
00050   typedef std::list<ProblemInfo> ProblemLogList;
00051
00053   class ProblemLog
00054   {
00055   public:
00056     ProblemLog() {}
00057     ~ProblemLog() {}
00058
00060     void addProblem( const ProblemInfo & info
00061                    );
00062
00064
00066     const ProblemLogList & getLogList();
00067
00068   private:
00069     ProblemLogList m_log;
00070   };
00071
00073
00074   inline void ProblemLog::addProblem(const ProblemInfo & info)
00075   {
00076     m_log.push_back(info);
00077   }
00078
00079   inline const ProblemLogList & ProblemLog::getLogList()
00080   {
00081     m_log.sort(LogListCompare());
00082     return m_log;
00083   }
00084
00085   inline bool LogListCompare::operator()( const ProblemInfo & infoA, const ProblemInfo & infoB ) const
00086   {
00087       return(infoA.m_problem < infoB.m_problem);
00088   }
00089
00090
00091   inline void reportError(ProblemLog& log, const char * problem, const char * missingFeature)
00092   {
00093     log.addProblem(ProblemInfo(problem, true, missingFeature));
00094   }
00095
00096   inline void reportWarning(ProblemLog& log, const char * problem, const char * missingFeature)
00097   {
00098     log.addProblem(ProblemInfo(problem, false, missingFeature));
00099   }
00100 }
00101
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


QuadMeshes.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/MeshedPrimitiveSet.h"

Include dependency graph for QuadMeshes.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:11 2008 for NVSGSDK by NVIDIA


QuadMeshes.h Source File

QuadMeshes.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2004
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/nvsg.h"
00017 #include "nvsg/MeshedPrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00026   class QuadMeshes : public MeshedPrimitiveSet
00027   {
00028     public:
00031       NVSG_API QuadMeshes();
00032
00036       NVSG_API QuadMeshes( const MeshedPrimitiveSet &rhs );
00037
00040       NVSG_API QuadMeshes( const QuadMeshes &rhs );
00041
00043       NVSG_API virtual ~QuadMeshes();
00044
00049       NVSG_API QuadMeshes & operator=( const QuadMeshes & rhs );
00050   };
00051
00062   NVSG_API void calculateTangentSpace( QuadMeshes * qm
00063                                      , unsigned int tu = 0
00064                                      , unsigned int tg = 1
00065                                      , unsigned int bn = 2 );
00066
00071   NVSG_API void generateNormals( QuadMeshes * qm );
00072
00073 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Quads.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Face.h"
#include "nvsg/IndependentPrimitiveSet.h"

Include dependency graph for Quads.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:11 2008 for NVSGSDK by NVIDIA


Quads.h Source File

Quads.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Face.h"
00017 #include "nvsg/IndependentPrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00027   class Quads : public IndependentPrimitiveSet
00028   {
00029     public:
00031       NVSG_API Quads();
00032
00034       NVSG_API Quads( const PrimitiveSet &rhs );
00035
00037       NVSG_API Quads( const IndependentPrimitiveSet &rhs );
00038
00040       NVSG_API Quads( const Quads &rhs );
00041
00043       NVSG_API virtual ~Quads();
00044
00049       NVSG_API bool hasFaces() const;
00050
00055       NVSG_API unsigned int getNumberOfFaces() const;
00056
00061       NVSG_API const Face4 * getFaces() const;
00062
00071       NVSG_API void setFaces( const Face4 * faces, unsigned int numFaces );
00072
00088       NVSG_API void setFaces( unsigned int pos, const Face4 * faces, unsigned int numFaces );
00089
00095       NVSG_API Quads & operator=( const Quads & rhs );
00096   };
00097
00107   NVSG_API void calculateTangentSpace( Quads * q
00108                                      , unsigned int tu = 0
00109                                      , unsigned int tg = 1
00110                                      , unsigned int bn = 2 );
00111
00116   NVSG_API void generateNormals( Quads * q );
00117
00118   // - - - - - - - - - - - - - - - - - - - - - - - - -
00119   // inlines
00120   // - - - - - - - - - - - - - - - - - - - - - - - - -
00121
00122   inline bool Quads::hasFaces() const
00123   {
00124     NVSG_TRACE();
00125     return( 4 <= getNumberOfIndices() );
00126   }
00127
00128   inline unsigned int Quads::getNumberOfFaces() const
00129   {
00130     NVSG_TRACE();
00131     return( getNumberOfIndices() / 4 );
00132   }
00133
00134   inline const Face4 * Quads::getFaces() const
00135   {
00136     NVSG_TRACE();
00137     return( (const Face4 *) getIndices() );
00138   }
00139
00140   inline void Quads::setFaces( const Face4 * pFaces, unsigned int numFaces )
00141   {
00142     NVSG_TRACE();
00143     setIndices( (const unsigned int *) pFaces, 4 * numFaces );
00144   }
00145
00146   inline void Quads::setFaces( unsigned int pos, const Face4* pFaces, unsigned int numFaces )
00147   {
00148     NVSG_TRACE();
00149     if ( pos != ~0 )
00150     {
00151       pos *= 4;
00152     }
00153     setIndices( pos, (const unsigned int *) pFaces, 4 * numFaces );
00154   }
00155 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


QuadStrips.h File Reference

#include "nvsgcommon.h"
#include "nvsg/StrippedPrimitiveSet.h"
#include "nvsg/nvsg.h"

Include dependency graph for QuadStrips.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:11 2008 for NVSGSDK by NVIDIA


QuadStrips.h Source File

QuadStrips.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/StrippedPrimitiveSet.h"
00017 #include "nvsg/nvsg.h"
00018
00019 namespace nvsg
00020 {
00038   class QuadStrips : public StrippedPrimitiveSet
00039   {
00040     public:
00042       NVSG_API QuadStrips();
00043
00045       NVSG_API explicit QuadStrips( const StrippedPrimitiveSet &rhs );
00046
00048       NVSG_API explicit QuadStrips( const QuadStrips &rhs );
00049
00051       NVSG_API virtual ~QuadStrips();
00052
00057       NVSG_API QuadStrips & operator=(const QuadStrips & rhs);
00058   };
00059
00069   NVSG_API void calculateTangentSpace( QuadStrips * qs
00070                                      , unsigned int tu = 0
00071                                      , unsigned int tg = 1
00072                                      , unsigned int bn = 2 );
00073
00078   NVSG_API void generateNormals( QuadStrips * q );
00079
00080 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Quatt.h File Reference

#include "nvsgcommon.h"
#include "nvmath/nvmath.h"
#include "nvmath/Matnnt.h"
#include "nvmath/Vecnt.h"

Include dependency graph for Quatt.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvmath

Detailed Description

Generated on Tue Jan 15 10:28:12 2008 for NVSGSDK by NVIDIA


Quatt.h Source File

Quatt.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/nvmath.h"
00017 #include "nvmath/Matnnt.h"
00018 #include "nvmath/Vecnt.h"
00019
00020 namespace nvmath
00021 {
00022   template<unsigned int n, typename T> class Matnnt;
00023
00030   template<typename T> class Quatt
00031   {
00032     public:
00035       Quatt();
00036
00045       Quatt( T x, T y, T z, T w );
00046
00051       explicit Quatt( const Vecnt<4,T> & v );
00052
00055       template<typename S>
00056         explicit Quatt( const Quatt<S> & q );
00057
00063       Quatt( const Vecnt<3,T> & axis, T angle );
00064
00069       Quatt( const Vecnt<3,T> & v0, const Vecnt<3,T> & v1 );
00070
00074       explicit Quatt( const Matnnt<3,T> & rot );
00075
00081       Quatt<T> & normalize();
00082
00086       template<typename S>
00087         T & operator[]( S i );
00088
00092       template<typename S>
00093         const T & operator[]( S i ) const;
00094
00098       template<typename S>
00099         Quatt<T> & operator=( const Quatt<S> & q );
00100
00106       Quatt<T> & operator*=( const Quatt<T> & q );
00107
00114       Quatt<T> & operator/=( const Quatt<T> & q );
00115
00116     private:
00117       T m_quat[4];
00118   };
00119
00120
00121   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00122   // non-member functions
00123   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00124
00129   template<typename T>
00130     void decompose( const Quatt<T> & q, Vecnt<3,T> & axis, T & angle );
00131
00136   template<typename T>
00137     T distance( const Quatt<T> & q0, const Quatt<T> & q1 );
00138
00145   template<typename T>
00146     bool isNormalized( const Quatt<T> & q, T eps = std::numeric_limits<T>::epsilon() )
00147   {
00148     return( abs( magnitude( q ) - 1 ) <= eps );
00149   }
00150
00157   template<typename T>
00158     bool isNull( const Quatt<T> & q, T eps = std::numeric_limits<T>::epsilon() )
00159   {
00160     return( magnitude( q ) <= eps );
00161   }
00162
00167   template<typename T>
00168     T magnitude( const Quatt<T> & q );
00169
00176   template<typename T>
00177     bool operator==( const Quatt<T> & q0, const Quatt<T> & q1 );
00178
00185   template<typename T>
00186     bool operator!=( const Quatt<T> & q0, const Quatt<T> & q1 );
00187
00193   template<typename T>
00194     Quatt<T> operator~( const Quatt<T> & q );
00195
00200   template<typename T>
00201     Quatt<T> operator-( const Quatt<T> & q );
00202
00213   template<typename T>
00214     Quatt<T> operator*( const Quatt<T> & q0, const Quatt<T> & q1 );
00215
00222   template<typename T>
00223     Vecnt<3,T> operator*( const Quatt<T> & q, const Vecnt<3,T> & v );
00224
00231   template<typename T>
00232     Vecnt<3,T> operator*( const Vecnt<3,T> & v, const Quatt<T> & q );
00233
00241   template<typename T>
00242     Quatt<T> operator/( const Quatt<T> & q0, const Quatt<T> & q1 );
00243
00244
00245   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00246   // non-member functions, specialized for T == float
00247   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00248
00255   NVSG_API Quatt<float> lerp( float alpha, const Quatt<float> & q0, const Quatt<float> & q1 );
00256
00257
00258   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00259   // Convenience type definitions
00260   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00261   typedef Quatt<float>  Quatf;
00262   typedef Quatt<double> Quatd;
00263
00264
00265   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00266   // inlined member functions
00267   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00268   template<typename T>
00269   inline Quatt<T>::Quatt()
00270   {
00271   }
00272
00273   template<typename T>
00274   inline Quatt<T>::Quatt( T x, T y, T z, T w )
00275   {
00276     m_quat[0] = x;
00277     m_quat[1] = y;
00278     m_quat[2] = z;
00279     m_quat[3] = w;
00280   }
00281
00282   template<typename T>
00283   inline Quatt<T>::Quatt( const Vecnt<4,T> & v )
00284   {
00285     m_quat[0] = v[0];
00286     m_quat[1] = v[1];
00287     m_quat[2] = v[2];
00288     m_quat[3] = v[3];
00289     NVSG_PRIVATE_ASSERT( isNormalized( *this ) );
00290   }
00291
00292   template<typename T>
00293   template<typename S>
00294   inline Quatt<T>::Quatt( const Quatt<S> & q )
00295   {
00296     *this = q;
00297   }
00298
00299   template<typename T>
00300   inline Quatt<T>::Quatt( const Vecnt<3,T> & axis, T angle )
00301   {
00302     NVSG_PRIVATE_ASSERT( isNormalized( axis ) );
00303     T dummy = sin( T(0.5) * angle );
00304     m_quat[0] = axis[0] * dummy;
00305     m_quat[1] = axis[1] * dummy;
00306     m_quat[2] = axis[2] * dummy;
00307     m_quat[3] = cos( T(0.5) * angle );
00308     NVSG_PRIVATE_ASSERT( isNormalized( *this ) );
00309   }
00310
00311   template<typename T>
00312   inline Quatt<T>::Quatt( const Vecnt<3,T> & v0, const Vecnt<3,T> & v1 )
00313   {
00314     NVSG_PRIVATE_ASSERT( isNormalized( v0 ) && isNormalized( v1 ) && ( v0 != - v1 ) );
00315     Vecnt<3,T> axis = v0 ^ v1;
00316     axis.normalize();
00317     T cosAngle = v0 * v1;
00318     T s = sqrt( T(0.5) * ( 1 - cosAngle ) );
00319     m_quat[0] = axis[0] * s;
00320     m_quat[1] = axis[1] * s;
00321     m_quat[2] = axis[2] * s;
00322     m_quat[3] = sqrt( T(0.5) * ( 1 + cosAngle ) );
00323     NVSG_PRIVATE_ASSERT( isNormalized( *this ) );
00324   }
00325
00326   template<typename T>
00327   inline Quatt<T>::Quatt( const Matnnt<3,T> & rot )
00328   {
00329     NVSG_PRIVATE_ASSERT( isRotation( rot ) );
00330
00331     T tr = rot[0][0] + rot[1][1] + rot[2][2] + 1;
00332     if ( std::numeric_limits<T>::epsilon() < tr )
00333     {
00334       T s = sqrt( tr );
00335       m_quat[3] = T(0.5) * s;
00336       s = T(0.5) / s;
00337       m_quat[0] = ( rot[1][2] - rot[2][1] ) * s;
00338       m_quat[1] = ( rot[2][0] - rot[0][2] ) * s;
00339       m_quat[2] = ( rot[0][1] - rot[1][0] ) * s;
00340     }
00341     else
00342     {
00343       unsigned int i = 0;
00344       if ( rot[i][i] < rot[1][1] )
00345       {
00346         i = 1;
00347       }
00348       if ( rot[i][i] < rot[2][2] )
00349       {
00350         i = 2;
00351       }
00352       unsigned int j = ( i + 1 ) % 3;
00353       unsigned int k = ( j + 1 ) % 3;
00354       T s = sqrt( rot[i][i] - rot[j][j] - rot[k][k] + 1 );
00355       m_quat[i] = T(0.5) * s;
00356       s = T(0.5) / s;
00357       m_quat[j] = ( rot[i][j] + rot[j][i] ) * s;
00358       m_quat[k] = ( rot[i][k] + rot[k][i] ) * s;
00359       m_quat[3] = ( rot[k][j] - rot[j][k] ) * s;
00360     }
00361     normalize();
00362   }
00363
00364   template<typename T>
00365   inline Quatt<T> & Quatt<T>::normalize()
00366   {
00367     T mag = sqrt( square(m_quat[0]) + square(m_quat[1]) + square(m_quat[2]) + square(m_quat[3]) );
00368     NVSG_PRIVATE_ASSERT( std::numeric_limits<T>::epsilon() < mag );
00369     T invMag = T(1) / mag;
00370     for ( int i=0 ; i<4 ; i++ )
00371     {
00372       m_quat[i] = m_quat[i] * invMag;
00373     }
00374     //  NVSG_PRIVATE_ASSERT( isNormalized( *this ) ); // due to rounding errors this assertion might fail !
00375     return( *this );
00376   }
00377
00378   template<>
00379   inline Quatt<float> & Quatt<float>::normalize()
00380   {
00381     *this = (Quatt<double>(*this)).normalize();
00382     NVSG_PRIVATE_ASSERT( isNormalized( *this ) );
00383     return( *this );
00384   }
00385
00386   template<typename T>
00387   template<typename S>
00388   inline T & Quatt<T>::operator[]( S i )
00389   {
00390     NVSG_CTASSERT( std::numeric_limits<S>::is_integer );
00391     NVSG_ASSERT( 0 <= i && i <= 3 );
00392     return( m_quat[i] );
00393   }
00394
00395   template<typename T>
00396   template<typename S>
00397   inline const T & Quatt<T>::operator[]( S i ) const
00398   {
00399     NVSG_CTASSERT( std::numeric_limits<S>::is_integer );
00400     NVSG_ASSERT( 0 <= i && i <= 3 );
00401     return( m_quat[i] );
00402   }
00403
00404   template<typename T>
00405   template<typename S>
00406   inline Quatt<T> & Quatt<T>::operator=( const Quatt<S> & q )
00407   {
00408     m_quat[0] = T(q[0]);
00409     m_quat[1] = T(q[1]);
00410     m_quat[2] = T(q[2]);
00411     m_quat[3] = T(q[3]);
00412     return( *this );
00413   }
00414
00415   template<typename T>
00416   inline Quatt<T> & Quatt<T>::operator*=( const Quatt<T> & q )
00417   {
00418     *this = *this * q;
00419     return( *this );
00420   }
00421
00422   template<typename T>
00423   inline Quatt<T> & Quatt<T>::operator/=( const Quatt<T> & q )
00424   {
00425     *this = *this / q;
00426     return( *this );
00427   }
00428
00429
00430   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00431   // inlined non-member functions
00432   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00433   template<typename T>
00434   inline void decompose( const Quatt<T> & q, Vecnt<3,T> & axis, T & angle )
00435   {
00436     angle = 2 * acos( q[3] );
00437     if ( angle < std::numeric_limits<T>::epsilon() )
00438     {
00439       //  no angle to rotate about => take just any one
00440       axis[0] = 0.0f;
00441       axis[1] = 0.0f;
00442       axis[2] = 1.0f;
00443     }
00444     else
00445     {
00446       T dummy = 1 / sin( T(0.5) * angle );
00447       axis[0] = q[0] * dummy;
00448       axis[1] = q[1] * dummy;
00449       axis[2] = q[2] * dummy;
00450       axis.normalize();
00451     }
00452   }
00453
00454   template<typename T>
00455   inline T distance( const Quatt<T> & q0, const Quatt<T> & q1 )
00456   {
00457     return( sqrt( square( q0[0] - q1[0] )
00458                 + square( q0[1] - q1[1] )
00459                 + square( q0[2] - q1[2] )
00460                 + square( q0[3] - q1[3] ) ) );
00461   }
00462
00463   template<typename T>
00464   inline T magnitude( const Quatt<T> & q )
00465   {
00466     return( sqrt( q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3] ) );
00467   }
00468
00469   template<typename T>
00470   inline bool operator==( const Quatt<T> & q0, const Quatt<T> & q1 )
00471   {
00472     return(   ( abs( q0[0] - q1[0] ) < std::numeric_limits<T>::epsilon() )
00473           &&  ( abs( q0[1] - q1[1] ) < std::numeric_limits<T>::epsilon() )
00474           &&  ( abs( q0[2] - q1[2] ) < std::numeric_limits<T>::epsilon() )
00475           &&  ( abs( q0[3] - q1[3] ) < std::numeric_limits<T>::epsilon() ) );
00476   }
00477
00478   template<typename T>
00479   inline bool operator!=( const Quatt<T> & q0, const Quatt<T> & q1 )
00480   {
00481     return( ! ( q0 == q1 ) );
00482   }
00483
00484   template<typename T>
00485   inline Quatt<T> operator~( const Quatt<T> & q )
00486   {
00487     return( Quatt<T>( -q[0], -q[1], -q[2], q[3] ) );
00488   }
00489
00490   template<typename T>
00491   inline Quatt<T> operator-( const Quatt<T> & q )
00492   {
00493     return( Quatt<T>( q[0], q[1], q[2], -q[3] ) );
00494   }
00495
00496   template<typename T>
00497   inline Quatt<T> operator*( const Quatt<T> & q0, const Quatt<T> & q1 )
00498   {
00499     NVSG_PRIVATE_ASSERT( isNormalized( q0 ) && isNormalized( q1 ) );
00500     Quatt<T> q( q0[3]*q1[0] + q0[0]*q1[3] - q0[1]*q1[2] + q0[2]*q1[1]
00501               , q0[3]*q1[1] + q0[0]*q1[2] + q0[1]*q1[3] - q0[2]*q1[0]
00502               , q0[3]*q1[2] - q0[0]*q1[1] + q0[1]*q1[0] + q0[2]*q1[3]
00503               , q0[3]*q1[3] - q0[0]*q1[0] - q0[1]*q1[1] - q0[2]*q1[2] );
00504     q.normalize();
00505     return( q );
00506   }
00507
00508   template<typename T>
00509   inline Vecnt<3,T> operator*( const Quatt<T> & q, const Vecnt<3,T> & v )
00510   {
00511     return( Matnnt<3,T>(q) * v );
00512   }
00513
00514   template<typename T>
00515   inline Vecnt<3,T> operator*( const Vecnt<3,T> & v, const Quatt<T> & q )
00516   {
00517     return( v * Matnnt<3,T>(q) );
00518   }
00519
00520   template<typename T>
00521   inline Quatt<T> operator/( const Quatt<T> & q0, const Quatt<T> & q1 )
00522   {
00523     return( q0 * ~q1 /*/ magnitude( q1 )*/ );
00524   }
00525 } // namespace nvmath
00526
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


RayIntersectTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Drawable.h"
#include "nvsg/Path.h"
#include "nvtraverser/ModelViewTraverser.h"

Include dependency graph for RayIntersectTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:12 2008 for NVSGSDK by NVIDIA


RayIntersectTraverser.h Source File

RayIntersectTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Drawable.h"
00017 #include "nvsg/Path.h"
00018 #include "nvtraverser/ModelViewTraverser.h"
00019
00020 namespace nvsg
00021 {
00022   class Camera;
00023 }
00024
00025 namespace nvtraverser
00026 {
00028
00032   class Intersection
00033   {
00034     public:
00036       Intersection(void);
00037
00039
00041       NVSG_API Intersection( const nvsg::Path * pPath
00042                            , nvsg::DrawableHandle * pDrawable
00043                            , const nvmath::Vec3f & isp
00044                            , float dist
00045                            , unsigned int primitiveIndex
00046                            , const std::vector<unsigned int> & vertexIndices
00047                            );
00048
00050
00051       NVSG_API Intersection( const Intersection & rhs
00052                            );
00053
00055       NVSG_API virtual ~Intersection(void);
00056
00058       NVSG_API Intersection & operator = (const Intersection & rhs);
00059
00061
00062       NVSG_API const nvsg::Path * getPath() const;
00063
00065
00066       NVSG_API nvsg::DrawableHandle * getDrawable() const;
00067
00069
00070       NVSG_API const nvmath::Vec3f & getIsp() const;
00071
00073
00074       NVSG_API float getDist() const;
00075
00081       NVSG_API unsigned int getPrimitiveIndex() const;
00082
00105       NVSG_API const std::vector<unsigned int> & getVertexIndices() const;
00106
00107     protected:
00109
00110       NVSG_API void clone( const Intersection & rhs
00111                          );
00112
00113       nvsg::DrawableHandle        * m_pDrawable;
00114       const nvsg::Path            * m_pPath;
00115       nvmath::Vec3f                 m_isp;
00116       float                         m_dist;
00117       unsigned int                  m_primitiveIndex;
00118       std::vector<unsigned int>     m_vertexIndices;
00119
00120   };
00121
00122   inline Intersection::~Intersection()
00123   {
00124     if (m_pDrawable)
00125     {
00126       m_pDrawable->removeRef();
00127       m_pDrawable = NULL;
00128     }
00129
00130     if (m_pPath)
00131     {
00132       m_pPath->removeRef();
00133       m_pPath = NULL;
00134     }
00135   }
00136
00137   inline Intersection::Intersection()
00138   : m_pDrawable(NULL)
00139   , m_pPath(NULL)
00140   , m_isp(nvmath::Vec3f())
00141   , m_dist(0.0f)
00142   , m_primitiveIndex (0xffffffff)
00143   {
00144   }
00145
00146    inline Intersection::Intersection ( const nvsg::Path * pPath
00147                                      , nvsg::DrawableHandle * pDrawable
00148                                      , const nvmath::Vec3f & isp
00149                                      , float dist
00150                                      , unsigned int primitiveIndex
00151                                      , const std::vector<unsigned int> & vertexIndices)
00152
00153   {
00154     NVSG_ASSERT(pDrawable);
00155     NVSG_ASSERT(pPath);
00156
00157     m_isp       = isp;
00158     m_dist      = dist;
00159
00160     m_pDrawable = pDrawable;
00161     m_pDrawable->addRef();
00162
00163     m_pPath     = pPath;
00164     m_pPath->addRef();
00165
00166     m_primitiveIndex = primitiveIndex;
00167
00168     m_vertexIndices = vertexIndices;
00169   }
00170
00171   inline Intersection::Intersection (const Intersection & rhs)
00172   {
00173     clone(rhs);
00174   }
00175
00176   inline Intersection & Intersection::operator = (const Intersection & rhs)
00177   {
00178     clone(rhs);
00179     return (*this);
00180   }
00181
00182   inline void Intersection::clone(const Intersection & rhs)
00183   {
00184     m_isp       = rhs.m_isp;
00185     m_dist      = rhs.m_dist;
00186
00187     m_pDrawable = rhs.m_pDrawable;
00188     m_pDrawable->addRef();
00189
00190     m_pPath     = rhs.m_pPath;
00191     m_pPath->addRef();
00192
00193     m_primitiveIndex = rhs.m_primitiveIndex;
00194
00195     m_vertexIndices = rhs.m_vertexIndices;
00196   }
00197
00198   inline const nvmath::Vec3f & Intersection::getIsp() const
00199   {
00200   return m_isp;
00201   }
00202
00203   inline float Intersection::getDist() const
00204   {
00205     return m_dist;
00206   }
00207
00208   inline nvsg::DrawableHandle * Intersection::getDrawable() const
00209   {
00210     return m_pDrawable;
00211   }
00212
00213   inline const nvsg::Path * Intersection::getPath() const
00214   {
00215     return m_pPath;
00216   }
00217
00218   inline unsigned int Intersection::getPrimitiveIndex() const
00219   {
00220     return m_primitiveIndex;
00221   }
00222
00223   inline const std::vector<unsigned int> & Intersection::getVertexIndices() const
00224   {
00225     return m_vertexIndices;
00226   }
00227
00229
00236   class RayIntersectTraverser : public SharedModelViewTraverser
00237   {
00238     public:
00240       NVSG_API RayIntersectTraverser(void);
00241
00243
00245       NVSG_API void release();
00246
00248
00250       NVSG_API void setRay( const nvmath::Vec3f &origin
00251                           , const nvmath::Vec3f &dir
00252                           );
00253
00255
00257       NVSG_API void setCamClipping( bool b
00258                                   );
00259
00261
00262       NVSG_API const Intersection & getNearest( void ) const;
00263
00265
00266       NVSG_API const Intersection * getIntersections( void ) const;
00267
00269
00270       NVSG_API unsigned int getNumberOfIntersections( void ) const;
00271
00273
00274       NVSG_API void setViewportSize( unsigned int width, unsigned int height );
00275
00276
00277     protected:
00279       NVSG_API virtual ~RayIntersectTraverser(void);
00280
00282
00284       NVSG_API virtual void  doApply( nvsg::NodeHandle * root );
00285
00286       // Nodes in the tree:
00287       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode *gnode );
00288       NVSG_API virtual void handleVolumeNode( const nvsg::VolumeNode *vnode );
00289
00290       // Groups in the tree:
00291       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p );
00292       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p);
00293       NVSG_API virtual void handleGroup( const nvsg::Group * group);
00294       NVSG_API virtual void handleLOD( const nvsg::LOD * lod);
00295       NVSG_API virtual void handleSwitch( const nvsg::Switch * swtch);
00296       NVSG_API virtual void handleTransform( const nvsg::Transform * p);
00297
00298       // Other operators:
00299       NVSG_API virtual void handleLines( const nvsg::Lines *lines );
00300       NVSG_API virtual void handleLineStrips( const nvsg::LineStrips *strips );
00301       NVSG_API virtual void handlePoints( const nvsg::Points *points );
00302       NVSG_API virtual void handleQuadMeshes( const nvsg::QuadMeshes *meshes );
00303       NVSG_API virtual void handleQuads( const nvsg::Quads *quads );
00304       NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips *strips );
00305       NVSG_API virtual void handleSkinnedTriangles( const nvsg::SkinnedTriangles *triangles );
00306       NVSG_API virtual void handleTriangles( const nvsg::Triangles *triangles );
00307       NVSG_API virtual void handleTriFans( const nvsg::TriFans *fans );
00308       NVSG_API virtual void handleTriStrips( const nvsg::TriStrips *strips );
00309
00310       // Specialized state handling
00311       // handleFaceAttribute lets us evaluate backface culling for subsequent geometry.
00312       // Note, that we consider backface culling for picking!
00313       NVSG_API virtual void handleCgFx( const nvsg::CgFx * p );
00314       NVSG_API virtual void handleFaceAttribute( const nvsg::FaceAttribute *faceAttrib );
00315       NVSG_API virtual void handleStateSet( const nvsg::StateSet *stateSet );
00316
00321       NVSG_API virtual bool preTraverseGroup( const nvsg::Group *p );
00322
00327       NVSG_API virtual void postTraverseGroup( const nvsg::Group *p );
00328
00330
00332       NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00333                                                 );
00334
00336
00337       NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00338                                                  );
00339
00343       NVSG_API bool checkClipPlanes( const nvmath::Vec3f & p );
00344
00349       NVSG_API bool checkClipPlanes( const nvmath::Sphere3f & p );
00350
00352
00357       enum ISType { _NONE = 0
00358                   , _BSTANGENT
00359                   , _BSNEAR
00360                   , _BSFAR
00361                   , _BSNEARFAR
00362                   };
00363
00365
00366       NVSG_API bool checkIntersection( const nvmath::Sphere3f &sphere );
00367
00369
00370       NVSG_API bool getWorldIntersection( nvmath::Vec3f &isp
00371                                                                , float &dist
00372                                                                );
00373
00375
00379       NVSG_API bool intersectBox( const nvmath::Vec3f &p0
00380                                 , const nvmath::Vec3f &p1
00381                                 , nvmath::Vec3f &isp
00382                                 , float &dist
00383                                 );
00384
00386
00390       NVSG_API bool intersectLine( const nvmath::Vec3f & v0
00391                                  , const nvmath::Vec3f & v1
00392                                  , nvmath::Vec3f & isp
00393                                  , float & dist
00394                                  );
00395
00397
00401       NVSG_API bool intersectPoint( const nvmath::Vec3f & v0
00402                                   , nvmath::Vec3f & isp
00403                                   , float & dist
00404                                   );
00405
00407
00411       NVSG_API bool intersectTriangle( const nvmath::Vec3f & v0
00412                                      , const nvmath::Vec3f & v1
00413                                      , const nvmath::Vec3f & v2
00414                                      , nvmath::Vec3f & isp
00415                                      , float & dist
00416                                      );
00417
00419
00420       NVSG_API void storeIntersection( const nvsg::Drawable *p
00421                                      , const nvmath::Vec3f &isp
00422                                      , float dist
00423                                      , unsigned int primitiveIndex
00424                                      , const std::vector<unsigned int> & vertexIndices
00425                                      );
00426
00427 #if !defined(NDEBUG)
00428
00429       NVSG_API void dumpIntersectionList();
00430 #endif
00431
00432     private:
00433       bool equal( nvmath::Vec3f v0, nvmath::Vec3f v1 ) const;
00434       bool lookForLineAttribute( const nvsg::StateSet *ss );
00435       bool lookForPointAttribute( const nvsg::StateSet *ss );
00436
00437       static const nvmath::Vec3f _RAY_ORIGIN_DEFAULT;
00438       static const nvmath::Vec3f _RAY_DIRECTION_DEFAULT;
00439
00440       bool                        m_backFaceCulling;
00441       bool                        m_camClipping;
00442
00443       std::stack<std::vector<nvmath::Plane3f> > m_clipPlanes;
00444       nvsg::Path                * m_curPath;
00445       const nvsg::Camera        * m_lockedCamera;
00446       std::vector<Intersection>   m_intersectionList;
00447       float                       m_lineWidth;
00448       float                       m_lineWidthDefault;
00449       std::stack<nvmath::Vec3f>   m_msRayOrigin;
00450       std::stack<nvmath::Vec3f>   m_msRayDir;
00451       std::stack<nvmath::Vec3f>   m_msCamDir;
00452       unsigned int                m_nearestIntIdx;
00453       float                       m_pointSize;
00454       float                       m_pointSizeDefault;
00455       nvmath::Vec3f               m_rayOrigin;
00456       nvmath::Vec3f               m_rayDir;
00457       std::stack<float>           m_scaleFactors;
00458       unsigned int                m_viewportHeight;
00459       unsigned int                m_viewportWidth;
00460   };
00461
00462   inline void RayIntersectTraverser::setCamClipping(bool flag)
00463   {
00464     m_camClipping = flag;
00465   }
00466
00467   inline unsigned int RayIntersectTraverser::getNumberOfIntersections() const
00468   {
00469     NVSG_ASSERT( m_intersectionList.size() <= UINT_MAX );
00470     return( static_cast<unsigned int>(m_intersectionList.size()) );
00471   }
00472
00473   inline const Intersection & RayIntersectTraverser::getNearest() const
00474   {
00475     NVSG_ASSERT(!m_intersectionList.empty());
00476     return m_intersectionList[m_nearestIntIdx];
00477   }
00478
00479   inline const Intersection * RayIntersectTraverser::getIntersections() const
00480   {
00481     NVSG_ASSERT(!m_intersectionList.empty());
00482     return &m_intersectionList[0];
00483   }
00484 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


RCObject.h File Reference

#include "nvsgcommon.h"
#include "nvutil/Allocator.h"
#include "nvutil/SWMRSync.h"

Include dependency graph for RCObject.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvutil

Defines

#define | new new(__FILE__, __LINE__)
#define | _DEFINED_DBGNEW

Detailed Description

Generated on Tue Jan 15 10:28:12 2008 for NVSGSDK by NVIDIA


RCObject.h Source File

RCObject.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 // rcobject.h
00013 //
00014 // Support for reference counted object
00015 //
00016 #pragma once
00017
00019 #include "nvsgcommon.h"
00020
00021 #include "nvutil/Allocator.h" // for IAllocator interface
00022 #include "nvutil/SWMRSync.h"
00023
00024 // memory leak detection
00025 #if !defined(NDEBUG)
00026 # ifndef new
00027 #  define new new(__FILE__, __LINE__)
00028 #  define _DEFINED_DBGNEW // restrict the 'new' macro to this header file only
00029 # endif
00030 #endif
00031
00032 namespace nvutil
00033 {
00034   class RCObject;
00035
00036 #if !defined(DOXYGEN_IGNORE)
00037   // RefCount abstracts a reference counter and provides mutual exclusive access to the internal counter.
00038   template <typename T>
00039   class RefCount
00040   {
00041   public:
00042     // initializes the internal counter with the value of the passed 'initialValue' parameter.
00043     // initializes the internal counter with 0, if the parameter is omitted.
00044     // the mutex object will always be default constructed (see SWMRSync::SWMRSync)
00045     RefCount(T initialValue = 0) : m_cnt(initialValue) {}
00046
00047     // increments (increases by one) the internal counter.
00048     // this operator prevents more than one thread from accessing the internal counter simultaneously.
00049     T operator++()
00050     {
00051       m_mutex.lockExclusive();
00052       T res = ++m_cnt;
00053       m_mutex.unlockExclusive();
00054       return res;
00055     }
00056
00057     // decrements (decreases by one) the internal counter.
00058     // this operator prevents more than one thread from accessing the internal counter simultaneously.
00059     T operator--()
00060     {
00061       m_mutex.lockExclusive();
00062       NVSG_ASSERT(m_cnt>0); // must never turn negative
00063       T res = --m_cnt;
00064       m_mutex.unlockExclusive();
00065       return res;
00066     }
00067
00068     // 'greater than' comparison of the internal counter.
00069     // this operator prevents more than one thread from accessing the internal counter simultaneously.
00070     bool operator>(const T& rhs) const
00071     {
00072       m_mutex.lockExclusive();
00073       bool res = m_cnt > rhs;
00074       m_mutex.unlockExclusive();
00075       return res;
00076     }
00077
00078     // hide the built-in assignment operator!
00079     // the built-in assignment operator would assign the mutex, which is not allowed!
00080     // this operator prevents more than one thread from accessing the internal counter simultaneously.
00081     RefCount& operator=(const RefCount &rhs)
00082     {
00083       if ( this != &rhs )
00084       {
00085         // never copy a mutex! keep the original one instead!
00086         m_mutex.lockExclusive();
00087         m_cnt = rhs.m_cnt;
00088         m_mutex.unlockExclusive();
00089       }
00090       return *this;
00091     }
00092
00093   private:
00094     SWMRSync m_mutex; // to realize mutual exclusive access to m_cnt
00095     T m_cnt; // holds the counter value
00096   };
00097 #endif
00098
00106   typedef void DestroyCallback( const RCObject * rcObject, void * data );
00107
00127   class RCObject : public IAllocator
00128   {
00129     public:
00139       NVSG_API void addRef()            const;
00140
00147       NVSG_API void removeRef()         const;
00148
00160       NVSG_API void markUnshareable();
00161
00171       NVSG_API bool isShareable()       const;
00172
00179       NVSG_API bool isShared()          const;
00180
00193       NVSG_API void addOnDestroyCallback( DestroyCallback *dcb, void * data );
00194
00208       NVSG_API void removeOnDestroyCallback( DestroyCallback * dcb, void * data );
00209
00210     protected:
00211
00222       RCObject() : m_shareable(true) {};
00223
00235       RCObject(const RCObject& rhs) : m_shareable(true) {}
00236
00243       RCObject& operator=(const RCObject& rhs) { return *this; }
00244
00251       virtual ~RCObject() {}
00252
00253     private:
00254
00256       mutable RefCount<int>                             m_refcnt;
00257       bool                                              m_shareable;
00258       std::vector<std::pair<DestroyCallback *,void *> > m_destroyCallbacks;
00259   };
00260
00267   template<typename T>
00268   class RCVector : public std::vector<T>, public RCObject
00269   {
00270     public:
00273       RCVector() {}
00282       explicit RCVector(unsigned int n) : std::vector<T>(n) {}
00283   };
00284
00294   template <typename T>
00295   class RCPtr
00296   {
00315     template <typename U>
00316     friend void writeAccess(RCPtr<U> &rcPtr);
00317
00318     public:
00325       explicit RCPtr(T* pRCObj=0);
00326
00329       RCPtr(const RCPtr& rhs);
00330
00333       ~RCPtr();
00334
00345       RCPtr<T>& operator=(const RCPtr<T>& rhs);
00346
00354       T* operator->();
00355
00363       const T* operator->() const;
00364
00372       T& operator*();
00373
00381       const T& operator*() const;
00382
00383     private:
00384       void init();                              // initialize a RCPtr<T> object
00385       void clone();                             // deep-copy the embedded object
00386
00387       // the dump pointer
00388       T * m_ptr;
00389   };
00390
00397   template <typename T>
00398   class RCIPtr
00399   {
00418     template <typename U>
00419     friend void writeAccess(RCIPtr<U> &rcPtr);
00420
00421     public:
00428       explicit RCIPtr(T* pRCObj=0);
00429
00432       RCIPtr(const RCIPtr& rhs);
00433
00436       ~RCIPtr();
00437
00448       RCIPtr<T>& operator=(const RCIPtr<T>& rhs);
00449
00457       T* operator->();
00458
00466       const T* operator->() const;
00467
00475       T& operator*();
00476
00484       const T& operator*() const;
00485
00486     private:
00487       // CountHolder acts as an additional indirection and holds
00488       // a dump pointer to the object being reference counted
00489       struct CountHolder : public RCObject
00490       {
00491         // destructor only gets called when the objects
00492         // reference count reaches zero
00493         ~CountHolder() { delete m_ptr; }
00494         T * m_ptr;
00495       };
00496
00497       CountHolder * m_cntHolder;
00498
00499       void init();
00500       void clone(); // copy on write
00501   };
00502
00510   template <typename T>
00511   class RCObject_AutoPtr
00512   {
00513     template<typename U>
00514     friend class RCObject_AutoPtr;
00515
00516     public:
00523       explicit RCObject_AutoPtr(T * ptr=0);
00524
00527       template <typename U>
00528       RCObject_AutoPtr(const RCObject_AutoPtr<U>& rhs);
00529
00536       ~RCObject_AutoPtr();
00537
00544       template <typename U>
00545       RCObject_AutoPtr<T>& operator=(const RCObject_AutoPtr<U>& rhs);
00546
00552       T * get() const;
00553
00561       T * operator->() const;
00562
00570       T&  operator*() const;
00571
00580       T * release();
00581
00589       void reset(T * ptr);
00590
00591     private:
00592       void deletePointer();
00593       T * m_ptr;
00594   };
00595
00596   //----------------------------------------------------------------------------
00597   // inline implementations following
00598   //----------------------------------------------------------------------------
00599
00600   inline void RCObject::addRef() const
00601   {
00602     ++m_refcnt;
00603   }
00604
00605   inline void RCObject::removeRef() const
00606   {
00607     if ( !--m_refcnt )
00608     {
00609       for ( size_t i=0 ; i<m_destroyCallbacks.size() ; i++ )
00610       {
00611         (*m_destroyCallbacks[i].first)( this, m_destroyCallbacks[i].second );
00612       }
00613       delete this;
00614     }
00615   }
00616
00617   inline void RCObject::markUnshareable()
00618   {
00619     m_shareable=false;
00620   }
00621
00622   inline bool RCObject::isShareable() const
00623   {
00624     return m_shareable==true;
00625   }
00626
00627   inline bool RCObject::isShared() const
00628   {
00629     return m_refcnt>1;
00630   }
00631
00632   inline void RCObject::addOnDestroyCallback( DestroyCallback * dcb, void * data )
00633   {
00634     NVSG_ASSERT( std::find( m_destroyCallbacks.begin(), m_destroyCallbacks.end()
00635                      , std::make_pair( dcb, data ) )
00636                == m_destroyCallbacks.end() );
00637     m_destroyCallbacks.push_back( std::make_pair( dcb, data ) );
00638   }
00639
00640   inline void RCObject::removeOnDestroyCallback( DestroyCallback * dcb, void * data )
00641   {
00642     std::vector<std::pair<DestroyCallback*,void*> >::iterator it;
00643     it = std::find( m_destroyCallbacks.begin(), m_destroyCallbacks.end(), std::make_pair( dcb, data ) );
00644     NVSG_ASSERT( it != m_destroyCallbacks.end() );
00645     m_destroyCallbacks.erase( it );
00646   }
00647
00648   //>>
00649   template <typename T>
00650   inline RCPtr<T>::RCPtr(T* pRCObj)
00651   : m_ptr(pRCObj)
00652   {
00653     init();
00654   }
00655
00656   template <typename T>
00657   inline RCPtr<T>::RCPtr(const RCPtr& rhs)
00658   : m_ptr(rhs.m_ptr)
00659   {
00660     init();
00661   }
00662
00663   template <typename T>
00664   inline RCPtr<T>::~RCPtr()
00665   {
00666     if ( m_ptr )
00667     {
00668       m_ptr->removeRef();
00669     }
00670   }
00671
00672   template <typename T>
00673   inline RCPtr<T>& RCPtr<T>::operator=(const RCPtr<T>& rhs)
00674   {
00675     if ( m_ptr != rhs.m_ptr )
00676     {
00677       // remove reference to former value first
00678       m_ptr->removeRef();
00679       m_ptr = rhs.m_ptr;
00680       init();
00681     }
00682     return *this;
00683   }
00684
00685   template <typename T>
00686   inline T* RCPtr<T>::operator->()
00687   {
00688     return m_ptr;
00689   }
00690
00691   template <typename T>
00692   inline const T* RCPtr<T>::operator->() const
00693   {
00694     return m_ptr;
00695   }
00696
00697   template <typename T>
00698   inline T& RCPtr<T>::operator*()
00699   {
00700     return *m_ptr;
00701   }
00702
00703   template <typename T>
00704   inline const T& RCPtr<T>::operator*() const
00705   {
00706     return *m_ptr;
00707   }
00708
00709   template <typename T>
00710   inline void RCPtr<T>::init()
00711   {
00712     if ( !m_ptr ) return;
00713
00714     if ( !m_ptr->isShareable() )
00715     {
00716       // deep copy required!
00717       m_ptr = new T(*m_ptr);
00718     }
00719     m_ptr->addRef();
00720   }
00721
00722   template <typename T>
00723   inline void RCPtr<T>::clone()
00724   {
00725     if ( m_ptr->isShared() )
00726     {
00727       // need to wedge off an own copy if original data is shared
00728       T * pOldVal = m_ptr; // remember the old object pointer for deep copying below
00729       m_ptr->removeRef(); // unreference the object before beeing new assigned
00730       m_ptr = new T(*pOldVal); // deep copy -> T(const T&) required!
00731       m_ptr->addRef();
00732     }
00733   }
00734   //>>
00735   template <typename T>
00736   inline RCIPtr<T>::RCIPtr(T * pObj)
00737   : m_cntHolder(new CountHolder)
00738   {
00739     m_cntHolder->m_ptr = pObj;
00740     init();
00741   }
00742
00743   template <typename T>
00744   inline RCIPtr<T>::RCIPtr(const RCIPtr<T>& rhs)
00745   : m_cntHolder(rhs.m_cntHolder)
00746   {
00747     init();
00748   }
00749
00750   template <typename T>
00751   inline RCIPtr<T>::~RCIPtr()
00752   {
00753     m_cntHolder->removeRef();
00754   }
00755
00756   template <typename T>
00757   inline RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr<T>& rhs)
00758   {
00759     if ( m_cntHolder != rhs.m_cntHolder )
00760     {
00761       m_cntHolder->removeRef(); // unreference the object before beeing new assigned
00762       m_cntHolder = rhs.m_cntHolder;
00763       init();
00764     }
00765     return *this;
00766   }
00767
00768   template <typename T>
00769   inline const T* RCIPtr<T>::operator->() const
00770   {
00771     // const access, no need for copy on write here
00772     return m_cntHolder->m_ptr;
00773   }
00774
00775   template <typename T>
00776   inline T* RCIPtr<T>::operator->()
00777   {
00778     // perform copy on write with every non-const access to the pointed-to object
00779     // clone();
00780     return m_cntHolder->m_ptr;
00781   }
00782
00783   template <typename T>
00784   inline const T& RCIPtr<T>::operator*() const
00785   {
00786     // const access, no need for copy on write here
00787     return *(m_cntHolder->m_ptr);
00788   }
00789
00790   template <typename T>
00791   inline T& RCIPtr<T>::operator*()
00792   {
00793     // perform copy on write with every non-const access to the pointed-to object
00794     // clone();
00795     return *(m_cntHolder->m_ptr);
00796   }
00797
00798   template <typename T>
00799   inline void RCIPtr<T>::init()
00800   {
00801     if ( !m_cntHolder->isShareable() )
00802     {
00803       // non-shareables must not be shared (refcnt==1)
00804       _ASSERTE(!m_cntHolder->isShared());
00805       // must not unreference unshared objects because this
00806       // would delete the pointed-to object immediately!
00807       T * pOldVal = m_cntHolder->m_ptr;
00808       m_cntHolder = new CountHolder;
00809       m_cntHolder->m_ptr = new T(*pOldVal);
00810     }
00811     m_cntHolder->addRef();
00812   }
00813
00814   template <typename T>
00815   inline void RCIPtr<T>::clone()
00816   {
00817     if ( m_cntHolder->isShared() )
00818     {
00819       T * pOldVal = m_cntHolder->m_ptr; // remember the old object pointer for deep copying below
00820       m_cntHolder->removeRef(); // unreference the object before beeing new assigned
00821       m_cntHolder = new CountHolder;
00822       m_cntHolder->m_ptr = new T(*pOldVal); // deep copy
00823       m_cntHolder->addRef();
00824     }
00825   }
00826   //>>
00827
00828   template <typename T>
00829   inline RCObject_AutoPtr<T>::RCObject_AutoPtr(T * ptr)
00830   : m_ptr(ptr)
00831   {
00832   }
00833
00834   template <typename T>
00835   template <typename U>
00836   inline RCObject_AutoPtr<T>::RCObject_AutoPtr(const RCObject_AutoPtr<U>& rhs)
00837   : m_ptr(rhs.release())
00838   {
00839     // !! don't add reference here !!
00840   }
00841
00842   template <typename T>
00843   inline RCObject_AutoPtr<T>::~RCObject_AutoPtr()
00844   {
00845     deletePointer();
00846   }
00847
00848   template <typename T>
00849   template <typename U>
00850   inline RCObject_AutoPtr<T>& RCObject_AutoPtr<T>::operator=(const RCObject_AutoPtr<U>& rhs)
00851   {
00852     if ( this != &rhs )
00853     {
00854       reset(rhs.release());
00855     }
00856     return *this;
00857   }
00858
00859   template <typename T>
00860   inline T * RCObject_AutoPtr<T>::get() const
00861   {
00862     return m_ptr;
00863   }
00864
00865   template <typename T>
00866   inline T * RCObject_AutoPtr<T>::operator->() const
00867   {
00868     return m_ptr;
00869   }
00870
00871   template <typename T>
00872   inline T&  RCObject_AutoPtr<T>::operator*() const
00873   {
00874     return *m_ptr;
00875   }
00876
00877   template <typename T>
00878   inline T * RCObject_AutoPtr<T>::release()
00879   {
00880     T * ptr = m_ptr;
00881     m_ptr = 0;
00882     return ptr;
00883   }
00884
00885   template <typename T>
00886   void RCObject_AutoPtr<T>::reset(T * ptr)
00887   {
00888     if ( m_ptr != ptr )
00889     {
00890       deletePointer();
00891       m_ptr = ptr;
00892       // !! don't ad reference here !!
00893     }
00894   }
00895
00896   template <typename T>
00897   void RCObject_AutoPtr<T>::deletePointer()
00898   {
00899     if ( m_ptr )
00900     {
00901       m_ptr->addRef();
00902       m_ptr->removeRef();
00903     }
00904   }
00905
00906   //>>
00907   template <typename T>
00908   inline void writeAccess( RCPtr<T> &rcPtr )
00909   {
00910     // perform a deep copy of the embedded object if shared
00911     rcPtr.clone();
00912   }
00913
00914   //>>
00915   template <typename T>
00916   inline void writeAccess( RCIPtr<T> &rcPtr )
00917   {
00918     // perform a deep copy of the embedded object if shared
00919     rcPtr.clone();
00920   }
00921
00922 //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
00924
00939   struct addReference
00940   {
00942
00944     template <typename RCOBJPTR>
00945     RCOBJPTR operator()( RCOBJPTR pRCObject
00946                       );
00947
00949
00951     template <typename AnyType, typename RCOBJPTR>
00952       const std::pair<AnyType, RCOBJPTR>& operator()( std::pair<AnyType,RCOBJPTR>& p
00953                                             );
00954   };
00955
00956   template <typename RCOBJPTR>
00957   RCOBJPTR addReference::operator()( RCOBJPTR pRCObject )
00958   {
00959     pRCObject->addRef();
00960     return pRCObject;
00961   }
00962
00963   template <typename AnyType, typename RCOBJPTR>
00964   const std::pair<AnyType, RCOBJPTR>& addReference::operator()( std::pair<AnyType,RCOBJPTR>& p )
00965   {
00966     p.second->addRef();
00967     return p;
00968   }
00969 //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
00970
00972   struct removeReference
00973   {
00975     template <typename RCOBJPTR>
00976     RCOBJPTR operator()(RCOBJPTR pRCObject)
00977       { pRCObject->removeRef(); return pRCObject; }
00978
00980     template <typename AnyType, typename RCOBJPTR>
00981     const std::pair<AnyType, RCOBJPTR>& operator() (std::pair<AnyType,RCOBJPTR>& p)
00982       { p.second->removeRef(); return p; }
00983   };
00984
00985 } // namespace nvutil
00986
00987 #ifdef _DEFINED_DBGNEW
00988 # undef new
00989 #endif
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Registry.h File Reference

#include "nvsg/nvsgapi.h"
#include <string>
#include "nvutil/Assert.h"

Include dependency graph for Registry.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:13 2008 for NVSGSDK by NVIDIA


Registry.h Source File

Registry.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/nvsgapi.h"  // storage-class defines
00016
00017 #ifndef LINUX
00018 # include "nvsgwindefs.h"
00019 # ifndef NOMINMAX
00020 #  define NOMINMAX // avoid problems with Microsoft definitions in windef.h and min/max from stl
00021 # endif
00022 # include <windows.h>
00023 # undef NOMINMAX
00024 #endif
00025
00026 #include <string>
00027 #include "nvutil/Assert.h"
00028
00029 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00030 namespace nvutil {
00031
00032 typedef std::basic_string <TCHAR> tstring;
00033
00034 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00036 template <typename T> class RegVal
00037 {
00038 public:
00039   enum
00040   {
00041     DIRTY  = 1
00042   };
00043
00045   RegVal( const TCHAR * value_name , const TCHAR * subkey, DWORD type, HKEY root=HKEY_CURRENT_USER
00046         , const T& def=T() ); // T() provides initialization for fundamental types
00048   ~RegVal() {}
00050   RegVal<T>& operator=(const T& rhs);
00052   operator const T&();
00053
00054 private:
00055   // not allowed
00056   RegVal(const RegVal<T>&) {}   // copying
00057   RegVal<T>& operator=(const RegVal<T>&) {} // assignment
00058   // for private use only
00059   DWORD create();
00060   DWORD read(T& out, DWORD nbytes);
00061   DWORD write(const T& in, DWORD nbytes);
00062
00063 private:
00064   tstring  m_name;
00065   tstring  m_subkey;
00066   DWORD   m_type;
00067   HKEY    m_root;
00068   HKEY    m_hkey;
00069   DWORD   m_flags;
00070   T       m_default;
00071   T       m_data;
00072 };
00073
00074 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00075 template <class T>
00076 inline RegVal<T>::RegVal( const TCHAR * value_name
00077                         , const TCHAR * subkey
00078                         , DWORD type
00079                         , HKEY root
00080                         , const T& def )
00081 : m_name(value_name)
00082 , m_subkey(subkey)
00083 , m_type(type)
00084 , m_root(root)
00085 , m_flags(DIRTY)
00086 , m_default(def)
00087 {
00088   if ( ERROR_SUCCESS==create() )
00089   {
00090     if ( ERROR_FILE_NOT_FOUND==read(m_data, sizeof(T)) )
00091     {
00092       if ( ERROR_SUCCESS==write(m_default, sizeof(T)) )
00093       {
00094         m_data = m_default; // update internal cache
00095         m_flags &= ~DIRTY; // no need to walk the registry with the very next read
00096       }
00097     }
00098   }
00099 }
00100
00101 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00102 template <class T>
00103 inline RegVal<T>& RegVal<T>::operator=(const T& rhs)
00104 {
00105   write(rhs, sizeof(T)); // write the registry
00106   m_data = rhs; // update internal data cache according
00107   m_flags &= ~DIRTY; // no need to walk the registry with the very next read
00108   return *this;
00109 }
00110
00111 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00112 template <class T>
00113 inline RegVal<T>::operator const T&()
00114 {
00115   if ( m_flags & DIRTY ) {
00116     // need to read the registry for valid data
00117     if ( !(ERROR_SUCCESS==read(m_data, sizeof(T))) )
00118     {
00119       // reading failed, set to default
00120       m_data = m_default;
00121     }
00122     m_flags &= ~DIRTY; // assign data cache valid, no need to walk the
00123                         // registry with the very next read
00124   }
00125   return m_data;
00126 }
00127
00128 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00129 template <class T>
00130 inline DWORD RegVal<T>::create()
00131 {
00132   DWORD err;
00133   DWORD dwDisposition;
00134
00135   // create the key if not already exists
00136   if ( ERROR_SUCCESS == (err = RegCreateKeyEx( m_root
00137                                              , m_subkey.c_str()
00138                                              , 0
00139                                              , NULL
00140                                              , REG_OPTION_NON_VOLATILE
00141                                              , KEY_ALL_ACCESS
00142                                              , NULL
00143                                              , &m_hkey
00144                                              , &dwDisposition ))
00145      )
00146   {
00147     // close key
00148     RegCloseKey(m_hkey);
00149   }
00150
00151   return err;
00152 }
00153
00154 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00155 template <class T>
00156 inline DWORD RegVal<T>::read(T& out, DWORD nbytes)
00157 {
00158   DWORD err;
00159   DWORD type;
00160
00161   if ( ERROR_SUCCESS == (err = RegOpenKeyEx(m_root, m_subkey.c_str(), NULL, KEY_READ, &m_hkey)) ) {
00162     err = RegQueryValueEx(m_hkey, m_name.c_str(), NULL, &type, (LPBYTE)&out, &nbytes);
00163     NVSG_ASSERT((err==ERROR_SUCCESS)==(m_type==type)); // type mismatch!
00164     RegCloseKey(m_hkey);
00165   }
00166   return err;
00167 }
00168
00169 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00170 template<class T>
00171 inline DWORD RegVal<T>::write(const T& in, DWORD nbytes)
00172 {
00173   DWORD err;
00174
00175   if ( ERROR_SUCCESS == (err = RegOpenKeyEx(m_root, m_subkey.c_str(), NULL, KEY_ALL_ACCESS, &m_hkey)) ) {
00176     err = RegSetValueEx(m_hkey, m_name.c_str(), NULL, m_type, (const LPBYTE)&in, nbytes);
00177     RegCloseKey(m_hkey);
00178   }
00179   return err;
00180 }
00181
00182 //  DOXYGEN can't handle template specializations (warns about no matching class member found)
00183 #if ! defined( DOXYGEN_IGNORE )
00184 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00185 // string type needs some specialization with read and write
00186 template<>
00187 inline DWORD RegVal<tstring>::read(tstring& out, DWORD nbytes)
00188 {
00189   DWORD err;
00190   DWORD type;
00191
00192   if ( ERROR_SUCCESS == (err = RegOpenKeyEx(m_root, m_subkey.c_str(), NULL, KEY_READ, &m_hkey)) ) {
00193     // (1) call RegQueryValueEx with output data set to NULL to get the exact byte count required
00194     if ( ERROR_SUCCESS == (err = RegQueryValueEx(m_hkey, m_name.c_str(), NULL, &type, NULL, &nbytes)) ) {
00195       // create a temporary tstring and resize its controlled sequence according
00196       // to the byte count received with the previous call to RegQueryValueEx()
00197       tstring tmp;
00198       tmp.resize(nbytes);
00199       // (2) call RegQueryValueEx with valid output buffer now to receive the requested data
00200       if ( ERROR_SUCCESS == (err = RegQueryValueEx(m_hkey, m_name.c_str(), NULL, &type, (LPBYTE)tmp.data(), &nbytes)) ) {
00201         NVSG_ASSERT((err==ERROR_SUCCESS)==(m_type==type)); // type mismatch!
00202         // assign the c-string of the temporary string object rather than the string object itself to
00203         // ensure that the length of the output string's controlled sequence matches exactly that
00204         // of the enclosed c-string
00205         out = tmp.c_str();
00206       }
00207     }
00208     RegCloseKey(m_hkey);
00209   }
00210   return err;
00211 }
00212
00213 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00214 template<>
00215 inline DWORD RegVal<tstring>::write(const tstring& in, DWORD nbytes)
00216 {
00217   DWORD err;
00218
00219   if ( ERROR_SUCCESS == (err = RegOpenKeyEx(m_root, m_subkey.c_str(), NULL, KEY_ALL_ACCESS, &m_hkey)) ) {
00220     err = RegSetValueEx(m_hkey, m_name.c_str(), NULL, m_type, (const LPBYTE)in.c_str(), nbytes);
00221     RegCloseKey(m_hkey);
00222   }
00223   return err;
00224 }
00225
00226 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00227 template<>
00228 inline RegVal<tstring>& RegVal<tstring>::operator=(const tstring& rhs)
00229 {
00230   // determine required byte count
00231   DWORD nbytes = (DWORD)rhs.length()+1; // including terminating 0
00232   nbytes *= sizeof(TCHAR);
00233
00234   // write to registry now
00235   write(rhs, nbytes);
00236
00237   m_data = rhs; // update internal data cache according
00238   m_flags &= ~DIRTY; // no need to walk the registry with the very next read
00239
00240   return *this;
00241 }
00242 #endif  //  DOXYGEN_IGNORE
00243
00244 } // namespace nvutil
00245
00246 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00247 // avoid tedious, repeated qualification of namespace scope
00248 //using nvutil::RegVal;
00249
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


RenderArea.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Scene.h"
#include "nvsg/ViewState.h"
#include "nvtraverser/AppTraverser.h"
#include "nvtraverser/CullTraverser.h"
#include "nvtraverser/RenderTraverser.h"
#include "nvutil/BitMask.h"
#include "nvutil/ProblemLog.h"
#include <vector>

Include dependency graph for RenderArea.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvtraverser
namespace | nvui

Detailed Description

Generated on Tue Jan 15 10:28:13 2008 for NVSGSDK by NVIDIA


RenderArea.h Source File

RenderArea.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include "nvsg/Scene.h"
00018 #include "nvsg/ViewState.h"
00019 #include "nvtraverser/AppTraverser.h"
00020 #include "nvtraverser/CullTraverser.h"
00021 #include "nvtraverser/RenderTraverser.h"
00022 #include "nvutil/BitMask.h"
00023 #include "nvutil/ProblemLog.h"
00024
00025 #include <vector>
00026
00027 namespace nvtraverser
00028 {
00029   class DefaultCullTraverser;
00030 }
00031
00032 namespace nvui
00033 {
00043   class RenderArea
00044   {
00045     public:
00046
00048       enum
00049       {
00050         NVSG_STEREO       = BIT0,
00051         NVSG_MULTISAMPLE  = BIT1
00052       };
00053
00054     public:
00058       NVSG_API virtual ~RenderArea();
00059
00071       NVSG_API virtual bool init( RenderArea * shareArea = NULL );
00072
00078       NVSG_API virtual void destroy( void );
00079
00095       NVSG_API virtual void renderScene();
00096
00103       NVSG_API void interruptRender();
00104
00112       NVSG_API bool wasRenderInterrupted() const;
00113
00120       NVSG_API virtual void setViewportSize( unsigned int width, unsigned int height );
00121
00125       NVSG_API unsigned int getViewportHeight() const;
00126
00130       NVSG_API unsigned int getViewportWidth() const;
00131
00140       NVSG_API nvtraverser::RenderTraverser * getRenderTraverser() const;
00141
00155       NVSG_API void setRenderTraverser( nvtraverser::RenderTraverser * tr );
00156
00169       NVSG_API void setAppTraverser( nvtraverser::AppTraverser * tr );
00170
00181       NVSG_API nvtraverser::AppTraverser * getAppTraverser() const;
00182
00193       NVSG_API void pushCullTraverser( nvtraverser::CullTraverser * tr );
00194
00200       NVSG_API void popCullTraverser();
00201
00205       NVSG_API unsigned int getNumberOfCullTraverser() const;
00206
00215       NVSG_API nvtraverser::CullTraverser * getCullTraverser(unsigned int position) const;
00216
00224       NVSG_API float getAspectRatio() const;
00225
00232       NVSG_API bool isStereoAvailable();
00233
00247       NVSG_API void requestStereoSupport( bool stereo );
00248
00257       NVSG_API bool isHWFSAAAvailable();
00258
00272       NVSG_API void requestHWFSAA( bool on, unsigned int numBuffers );
00273
00284       NVSG_API void setSceneData( nvsg::SceneHandle * scene
00285                                 , nvsg::ViewStateHandle * viewState );
00286
00292       NVSG_API nvsg::ViewStateHandle * getViewState() const;
00293
00302       NVSG_API virtual void setViewState( nvsg::ViewStateHandle * viewState );
00303
00309       NVSG_API nvsg::SceneHandle * getScene() const;
00310
00318       NVSG_API virtual void setScene( nvsg::SceneHandle * scene );
00319
00333       NVSG_API static unsigned int createNewRenderAreaID();
00334
00342       NVSG_API virtual void triggerRedraw( void );
00343
00350       NVSG_API const nvutil::ProblemLogList & getProblems();
00351
00352     protected:
00355       NVSG_API RenderArea();
00356
00357       std::vector<nvtraverser::CullTraverser *>  m_cullTraverser;
00359       nvtraverser::RenderTraverser             * m_renderTraverser;
00361       nvtraverser::AppTraverser                * m_appTraverser;
00364       nvsg::SceneHandle * m_scene;
00365       nvsg::ViewStateHandle * m_viewState;
00368       UINT                m_features;
00370       UINT                m_numMSBuffers;
00371       bool                m_raCreated;
00372       unsigned int              m_raHeight;
00373       unsigned int              m_raWidth;
00375       static unsigned int       m_idRenderArea;
00381       nvutil::ProblemLog m_problemLog;
00384     private:
00385       bool m_frameInterrupted; // will be evaluated inside renderScene
00386
00387       // the DefaultCullTraverser will be invoked if no other CullTraverser is available.
00388       // this is necessary to detect if possible LOD switches occured
00389       nvtraverser::DefaultCullTraverser * m_defaultCullTraverser;
00390
00391   };
00392
00393   // - - - - - - - - - - - - - - - - - - - - - - - - - - -
00394   // inlines
00395   // - - - - - - - - - - - - - - - - - - - - - - - - - - -
00396
00397   inline float RenderArea::getAspectRatio() const
00398   {
00399     NVSG_ASSERT( m_raHeight > 0 && m_raWidth > 0 );
00400
00401     if (m_raHeight > 0 && m_raWidth > 0)
00402     {
00403       return( (float) m_raWidth / m_raHeight );
00404     }
00405
00406     return 0.f; // error
00407   }
00408
00409   inline nvsg::ViewStateHandle * RenderArea::getViewState() const
00410   {
00411     return( m_viewState );
00412   }
00413
00414   inline nvsg::SceneHandle * RenderArea::getScene() const
00415   {
00416     return( m_scene );
00417   }
00418
00419   inline nvtraverser::RenderTraverser * RenderArea::getRenderTraverser() const
00420   {
00421     return( m_renderTraverser );
00422   }
00423
00424   inline void RenderArea::setRenderTraverser( nvtraverser::RenderTraverser * tr )
00425   {
00426     if (m_renderTraverser)
00427     {
00428       m_renderTraverser->removeRef();
00429     }
00430
00431     m_renderTraverser = tr;
00432
00433     if (m_renderTraverser)
00434     {
00435       m_renderTraverser->addRef();
00436     }
00437   }
00438
00439   inline void RenderArea::setAppTraverser(nvtraverser::AppTraverser * tr)
00440   {
00441     if (m_appTraverser)
00442     {
00443       m_appTraverser->removeRef();
00444     }
00445
00446     m_appTraverser = tr;
00447
00448     if (m_appTraverser)
00449     {
00450       m_appTraverser->addRef();
00451     }
00452   }
00453
00454   inline nvtraverser::AppTraverser * RenderArea::getAppTraverser() const
00455   {
00456     return m_appTraverser;
00457   }
00458
00459   inline void RenderArea::pushCullTraverser(nvtraverser::CullTraverser * tr)
00460   {
00461     NVSG_ASSERT(tr);
00462
00463     m_cullTraverser.push_back(tr);
00464     tr->addRef();
00465   }
00466
00467   inline void RenderArea::popCullTraverser()
00468   {
00469     NVSG_ASSERT(!m_cullTraverser.empty());
00470
00471     m_cullTraverser.back()->removeRef();
00472     m_cullTraverser.pop_back();
00473   }
00474
00475   inline unsigned int RenderArea::getNumberOfCullTraverser() const
00476   {
00477     NVSG_ASSERT(m_cullTraverser.size() <= UINT_MAX );
00478     return( static_cast<unsigned int>(m_cullTraverser.size()) );
00479   }
00480
00481   inline nvtraverser::CullTraverser * RenderArea::getCullTraverser(unsigned int position) const
00482   {
00483     NVSG_ASSERT(m_cullTraverser.size() > position);
00484
00485     return m_cullTraverser[position];
00486   }
00487
00488   inline unsigned int RenderArea::createNewRenderAreaID()
00489   {
00490     return (++m_idRenderArea);
00491   }
00492
00493   inline unsigned int RenderArea::getViewportHeight() const
00494   {
00495     return m_raHeight;
00496   }
00497
00498   inline unsigned int RenderArea::getViewportWidth() const
00499   {
00500     return m_raWidth;
00501   }
00502
00503   inline const nvutil::ProblemLogList & RenderArea::getProblems()
00504   {
00505     return m_problemLog.getLogList();
00506   }
00507
00508   inline bool RenderArea::wasRenderInterrupted() const
00509   {
00510     return m_frameInterrupted;
00511   }
00512 } //  namespace nvui
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


RenderTraverser.h File Reference

#include <algorithm>
#include <list>
#include "nvsgcommon.h"
#include "nvsg/CgFx.h"
#include "nvsg/DAL.h"
#include "nvsg/FaceAttribute.h"
#include "nvsg/LightSource.h"
#include "nvsg/PrimitiveSet.h"
#include "nvsg/StateAttribute.h"
#include "nvsg/StateSet.h"
#include "nvsg/ViewState.h"
#include "nvtraverser/ModelViewTraverser.h"
#include "nvutil/Incarnation.h"

Include dependency graph for RenderTraverser.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:14 2008 for NVSGSDK by NVIDIA


RenderTraverser.h Source File

RenderTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <algorithm>
00016 #include <list>
00017 #include "nvsgcommon.h"
00018 #include "nvsg/CgFx.h"
00019 #include "nvsg/DAL.h"
00020 #include "nvsg/FaceAttribute.h"
00021 #include "nvsg/LightSource.h"
00022 #include "nvsg/PrimitiveSet.h"
00023 #include "nvsg/StateAttribute.h"
00024 #include "nvsg/StateSet.h"
00025 #include "nvsg/ViewState.h"
00026 #include "nvtraverser/ModelViewTraverser.h"
00027 #include "nvutil/Incarnation.h"
00028
00029 namespace nvsg
00030 {
00031   class AlphaTestAttribute;
00032   class LightingAttribute;
00033 };
00034
00035
00036 namespace nvtraverser
00037 {
00038   // forward declaration of some helper classes used internally only
00039   class RenderElementPool;
00040   class ClipPlanesElement;
00041   class LightsElement;
00042   class TransformElement;
00043   class RenderElement;
00044   class HighlightElement;
00045
00046   // renderer type IDs
00047   enum
00048   {
00049     RT_GL  = 0x00010000
00050   };
00051
00052
00054
00065   class RenderTraverser : public SharedModelViewTraverser
00066   {
00067     public:
00068
00069       enum GeometryCacheTechnique
00070       {
00071         GCT_NONE,
00072         GCT_DL,
00073         GCT_VBO
00074       };
00075
00076       enum JitterTechnique
00077       {
00078         JT_NONE,
00079         JT_READ_PIXELS,
00080         JT_ACCUM,
00081         JT_PBUFFER,
00082         JT_FBO
00083       };
00084
00085       enum RenderTechnique
00086       {
00087         RT_UNLIT,
00088         RT_SHADED,
00089         RT_TEXTURED,
00090         RT_EFFECTED,
00091       };
00092
00094       enum ShadowTechnique
00095       {
00096         ST_NONE,
00097         ST_SHADOW_MAP
00098       };
00099
00101       enum SortingPolicy
00102       {
00103         SP_NONE,
00104         SP_DEPTH,
00105         SP_STATE
00106       };
00107
00108       enum TransparencyTechnique
00109       {
00110         TT_NONE,
00111         TT_STIPPLED,
00112         TT_BLENDED,
00113         TT_SORTED_BLENDED,
00114         TT_ORDER_INDEPENDENT,
00115         TT_MULTISAMPLE
00116       };
00117
00118       enum OITTechnique
00119       {
00120         OT_TEXTURE,
00121         OT_PBUFFER,
00122         OT_FBO
00123       };
00124
00126       //** \return The currently used geometry caching technique. */
00127       NVSG_API GeometryCacheTechnique getGeometryCacheTechnique( void ) const;
00128
00130
00132       NVSG_API virtual bool isGeometryCacheTechniqueSupported( GeometryCacheTechnique gct
00133                                                               ) const;
00134
00136       NVSG_API virtual void setGeometryCacheTechnique( GeometryCacheTechnique gct
00137                                                       );
00138
00142       NVSG_API JitterTechnique getJitterTechnique( void ) const;
00143
00150       NVSG_API virtual bool isJitterTechniqueSupported( JitterTechnique jt ) const;
00151
00153
00157       NVSG_API void setJitterTechnique( JitterTechnique jt );
00158
00160
00162       NVSG_API bool isFrontFaceCulling() const;
00163
00165
00167       NVSG_API bool isBackFaceCulling() const;
00168
00170
00172       NVSG_API void setFaceCulling( bool front, bool back );
00173
00175       NVSG_API bool isFaceCullingOverwrite() const;
00176
00178       NVSG_API void setFaceCullingOverwrite( bool overwrite );
00179
00181
00182       NVSG_API nvsg::FaceMode getFaceMode( void ) const;
00183
00185
00186       NVSG_API void setFaceMode( nvsg::FaceMode mode );
00187
00189       NVSG_API bool isFaceModeOverwrite() const;
00190
00192       NVSG_API void setFaceModeOverwrite( bool overwrite );
00193
00195
00196       NVSG_API bool isTwoSidedLighting() const;
00197
00199
00200       NVSG_API void setTwoSidedLighting( bool enable );
00201
00203       NVSG_API bool isTwoSidedLightingOverwrite() const;
00204
00206       NVSG_API void setTwoSidedLightingOverwrite( bool overwrite );
00207
00209       //** \return The currently used render technique. */
00210       NVSG_API RenderTechnique getRenderTechnique( void ) const;
00211
00213
00215       NVSG_API virtual bool isRenderTechniqueSupported( RenderTechnique rt
00216                                                       ) const;
00217
00219       NVSG_API void setRenderTechnique( RenderTechnique rt
00220                                       );
00221
00223
00224       NVSG_API ShadowTechnique getShadowTechnique( void ) const;
00225
00227
00229       NVSG_API virtual bool isShadowTechniqueSupported( ShadowTechnique st
00230                                                       ) const;
00231
00233
00234       NVSG_API virtual void setShadowTechnique( ShadowTechnique st
00235                                               );
00236
00238
00239       NVSG_API unsigned int getShadowMapSize( void ) const;
00240
00242
00243       NVSG_API virtual void setShadowMapSize( unsigned int size
00244                                             );
00245
00247
00250       NVSG_API float getShadowMapIntensity( void ) const;
00251
00253
00256       NVSG_API void setShadowMapIntensity( float intensity );
00257
00259
00261       NVSG_API unsigned int getTextureSizeLimit( void ) const;
00262
00264
00266       NVSG_API virtual void setTextureSizeLimit( unsigned int size
00267                                               );
00268
00270       //** \return The currently used transparency technique. */
00271       NVSG_API TransparencyTechnique getTransparencyTechnique( void ) const;
00272
00274
00276       NVSG_API virtual bool isTransparencyTechniqueSupported( TransparencyTechnique tt
00277                                                             ) const;
00278
00280       NVSG_API virtual void setTransparencyTechnique( TransparencyTechnique tt
00281                                                     );
00282
00284       //** \return The currently used OIT technique. */
00285       NVSG_API OITTechnique getOITTechnique( void ) const;
00286
00288
00290       NVSG_API virtual bool isOITTechniqueSupported( OITTechnique ot
00291                                                     ) const;
00292
00294
00295       NVSG_API virtual void setOITTechnique( OITTechnique ot
00296                                             );
00297
00299
00300       NVSG_API unsigned int getOITMaxPasses( void ) const;
00301
00303       NVSG_API virtual void setOITMaxPasses( unsigned int maxPasses
00304
00305                                             );
00306
00308
00309       NVSG_API float getOITThreshold( void ) const;
00310
00312
00317       NVSG_API void setOITThreshold( float threshold
00318                                             );
00319
00321       NVSG_API void setLineAntiAliasing( bool onOff
00322                                        );
00323
00325
00326       NVSG_API bool isLineAntiAliasingEnabled( void ) const;
00327
00328
00330
00331       NVSG_API float getLineWidth( void ) const;
00332
00334       NVSG_API void setLineWidth( float width
00335                                 );
00336
00338       NVSG_API void setPointAntiAliasing( bool onOff
00339                                         );
00340
00342
00343       NVSG_API bool isPointAntiAliasingEnabled( void ) const;
00344
00346
00347       NVSG_API float getPointSize( void ) const;
00348
00350       NVSG_API void setPointSize( float size
00351                                 );
00352
00354
00358       NVSG_API void setSortingPolicy( SortingPolicy sp
00359                                     );
00360
00362
00363       NVSG_API SortingPolicy getSortingPolicy( void ) const;
00364
00366
00368       NVSG_API virtual bool isOcclusionCullingSupported( void ) const;
00369
00371       NVSG_API virtual void setOcclusionCulling( bool onOff
00372                                                );
00373
00375
00376       NVSG_API bool isOcclusionCulling( void ) const;
00377
00378     protected:
00380       NVSG_API RenderTraverser(void);
00382       NVSG_API virtual ~RenderTraverser(void);
00383
00385
00390       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00391
00393       NVSG_API virtual void doRender( nvsg::NodeHandle * root ) = 0;
00394
00396       NVSG_API virtual void handleAnimatedVertexAttributeSet( const nvsg::AnimatedVertexAttributeSet * p );
00397
00399
00401       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p );
00402
00404
00406       NVSG_API virtual void handleStateVariant( const nvsg::StateVariant * p
00407                                               );
00408
00410
00412       NVSG_API virtual void handleTransform( const nvsg::Transform * p );
00413
00415
00418       NVSG_API virtual void handleVolumeNode( const nvsg::VolumeNode * p );
00419
00421       NVSG_API virtual bool preTraverseDrawables( const nvsg::GeoNode *p
00422                                                 , unsigned int i
00423                                                 );
00424
00426       NVSG_API virtual void postTraverseDrawables( const nvsg::GeoNode *p
00427                                                  , unsigned int i
00428                                                  );
00430
00432       NVSG_API virtual bool preTraverseGroup( const nvsg::Group *p
00433         );
00434
00436
00438       NVSG_API virtual void postTraverseGroup( const nvsg::Group *p
00439                                              );
00440
00442
00444       NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00445                                                 );
00446
00448
00450       NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00451                                                  );
00452
00454
00456       NVSG_API virtual void traverseLight( const nvsg::LightSource * p
00457                                          );
00458
00460
00463       NVSG_API virtual void traversePrimitiveSet( const nvsg::PrimitiveSet * p
00464                                                 );
00465
00467
00469       NVSG_API bool isHighlightPass( void ) const;
00470
00472
00473       NVSG_API bool isOverlayPass( void ) const;
00474
00476
00477       NVSG_API bool isTransparentPass( void ) const;
00478
00484       NVSG_API virtual void render( const nvsg::Camera * cam );
00485
00487
00488       NVSG_API virtual void renderBegin( void );
00489
00491
00492       NVSG_API virtual void renderEnd( void );
00493
00495
00499       void renderObject( nvsg::ObjectHandle * oh );
00500
00502
00518       template<typename RendererType>
00519         void addObjectRenderer( unsigned int objectCode
00520         , RendererType renderer
00521         );
00522
00524
00529       template <typename T>
00530         void renderObject( nvsg::ObjectHandle * oh, T arg );
00531
00539       NVSG_API virtual void renderBillboard( const nvsg::Billboard * p );
00540
00542
00543       NVSG_API virtual void renderBlendAttribute( const nvsg::BlendAttribute *p
00544                                                 , bool enable
00545                                                 );
00546
00548
00549       NVSG_API virtual void renderAlphaTestAttribute( const nvsg::AlphaTestAttribute *p
00550                                                 , bool enable
00551                                                 );
00552
00554
00555       NVSG_API virtual void renderCgFx( const nvsg::CgFx *p
00556                                       , bool enable
00557                                       );
00558
00560
00561       NVSG_API virtual void renderDepthAttribute( const nvsg::DepthAttribute *p
00562                                                 , bool enable
00563                                                 );
00564
00566
00567       NVSG_API virtual void renderDirectedLight( const nvsg::DirectedLight *p
00568                                                , bool enable
00569                                                );
00570
00572
00573       NVSG_API virtual void renderFaceAttribute( const nvsg::FaceAttribute *p
00574                                                , bool enable
00575                                                );
00576
00578
00579       NVSG_API virtual void renderHighlightBox( const nvsg::HighlightBox * p
00580                                               );
00581
00583
00584       NVSG_API virtual void renderHighlightEdges( const nvsg::HighlightEdges * p
00585                                                 );
00586
00588
00589       NVSG_API virtual void renderLightingAttribute( const nvsg::LightingAttribute *p
00590                                                , bool enable
00591                                                );
00592
00594
00595       NVSG_API virtual void renderLineAttribute( const nvsg::LineAttribute *p
00596                                                , bool enable
00597                                                );
00598
00600
00601       NVSG_API virtual void renderLines( const nvsg::Lines *p
00602                                        );
00603
00605
00606       NVSG_API virtual void renderLineStrips( const nvsg::LineStrips *p
00607                                             );
00608
00610
00611       NVSG_API virtual void renderPointAttribute( const nvsg::PointAttribute *p
00612                                                 , bool enable
00613                                                 );
00614
00616
00617       NVSG_API virtual void renderPoints( const nvsg::Points *p
00618                                         );
00619
00621
00622       NVSG_API virtual void renderMaterial( const nvsg::Material *p
00623                                           , bool enable
00624                                           );
00625
00627
00628       NVSG_API virtual void renderParallelCamera( const nvsg::ParallelCamera *p
00629                                                 );
00630
00632
00633       NVSG_API virtual void renderPerspectiveCamera( const nvsg::PerspectiveCamera *p
00634                                                    );
00635
00637
00638       NVSG_API virtual void renderPointLight( const nvsg::PointLight *p
00639                                             , bool enable
00640                                             );
00641
00643
00644       NVSG_API virtual void renderQuads( const nvsg::Quads *p
00645                                        );
00646
00648
00649       NVSG_API virtual void renderQuadMeshes( const nvsg::QuadMeshes *p
00650                                             );
00651
00653
00654       NVSG_API virtual void renderQuadStrips( const nvsg::QuadStrips *p
00655                                             );
00656
00658
00659       NVSG_API virtual void renderSkinnedTriangles( const nvsg::SkinnedTriangles *p
00660                                                   );
00661
00663
00664       NVSG_API virtual void renderSpotLight( const nvsg::SpotLight *p
00665                                            , bool enable
00666                                            );
00667
00669
00671       NVSG_API virtual void renderStatePass( const nvsg::StatePass *p
00672                                            );
00673
00675
00677       NVSG_API virtual void renderTextureAttribute( const nvsg::TextureAttribute *p
00678                                                   , bool enable
00679                                                   );
00680
00682
00683       NVSG_API virtual void renderTextureAttributeItem( const nvsg::TextureAttributeItem *p
00684                                                       , unsigned int tu
00685                                                       );
00686
00694       NVSG_API virtual void renderTransform( const nvsg::Transform * p );
00695
00697
00698       NVSG_API virtual void renderTriangles( const nvsg::Triangles *p
00699                                            );
00700
00702
00703       NVSG_API virtual void renderTriFans( const nvsg::TriFans *p
00704                                          );
00705
00707
00708       NVSG_API virtual void renderTriStrips( const nvsg::TriStrips *p
00709                                            );
00710
00712
00713       NVSG_API virtual void renderUnlitColorAttribute( const nvsg::UnlitColorAttribute *p
00714                                                      , bool enable
00715                                                      );
00716
00718
00719       NVSG_API virtual void setClipPlane( unsigned int index
00720                                         , const nvmath::Plane3f & plane
00721                                         , bool enable
00722                                         );
00723
00725
00726       NVSG_API virtual void setTransforms( const nvmath::Mat44f &modelToWorld
00727                                          , const nvmath::Mat44f &worldToModel
00728                                          , bool needsNormalize
00729                                          , bool needsMirror
00730                                          );
00731
00733       NVSG_API virtual void overlayBegin( void );
00734
00736       NVSG_API virtual void overlayEnd( void );
00737
00739       NVSG_API virtual void transparentBegin( void );
00740
00742       NVSG_API virtual void transparentEnd( void );
00743
00745       NVSG_API virtual void highlightBegin( void );
00746
00748       NVSG_API virtual void highlightEnd( void );
00749
00751       NVSG_API virtual void primitiveSetsBegin();
00752
00754
00755       NVSG_API virtual bool primitiveSetsEnd();
00756
00758
00760       NVSG_API nvsg::CgFxHandle * getCurrentCgFx( void ) const;
00761
00763
00777       NVSG_API virtual void assignDirectedLightToEffectLight( nvsg::CgFxEffect * effect
00778                                                             , nvsg::CgFxParameter lightParam
00779                                                             , const nvsg::DirectedLight * directedLight
00780                                                             , const nvmath::Mat44f& modelToWorld
00781                                                             );
00782
00784
00798       NVSG_API virtual void assignPointLightToEffectLight( nvsg::CgFxEffect * effect
00799                                                          , nvsg::CgFxParameter lightParam
00800                                                          , const nvsg::PointLight * pointLight
00801                                                          , const nvmath::Mat44f& modelToWorld
00802                                                          );
00803
00805
00819       NVSG_API virtual void assignSpotLightToEffectLight( nvsg::CgFxEffect * effect
00820                                                         , nvsg::CgFxParameter lightParam
00821                                                         , const nvsg::SpotLight * spotLight
00822                                                         , const nvmath::Mat44f& modelToWorld
00823                                                         );
00824
00826
00840       NVSG_API virtual void assignCustomLightToEffectLight( nvsg::CgFxEffect * effect
00841                                                           , nvsg::CgFxParameter lightParam
00842                                                           , const nvsg::LightSource * customLight
00843                                                           , const nvmath::Mat44f& modelToWorld
00844                                                           );
00845
00846
00848
00852       NVSG_API virtual unsigned int createOcclusionCullID( void );
00853
00855
00858       NVSG_API virtual void destroyOcclusionCullID( unsigned int id
00859                                                   );
00860
00862
00866       NVSG_API virtual void beginOcclusionCullQuery( unsigned int id
00867                                                    );
00868
00870
00874       NVSG_API virtual void endOcclusionCullQuery( unsigned int id
00875                                                  );
00876
00878
00885       NVSG_API virtual unsigned int getOcclusionCullResult( unsigned int id
00886                                                     );
00887
00889
00891       NVSG_API virtual void hiddenBegin( void );
00892
00894
00896       NVSG_API virtual void hiddenEnd( void );
00897
00899       NVSG_API void clearRenderLists( void );
00900
00910       NVSG_API unsigned int getRasterOffsetX() const;
00911
00921       NVSG_API unsigned int getRasterOffsetY() const;
00922
00924       NVSG_API void setCollectRenderElements( bool value );
00925
00927       NVSG_API bool getCollectRenderElements( void ) const;
00928
00930       NVSG_API void occlusionTest( std::list<RenderElement*> &visibleList, std::list<RenderElement*> &hiddenList );
00931
00932     protected:
00933
00934       std::list<RenderElement *>        m_visibleOpaqueList;
00935       std::list<RenderElement *>        m_hiddenOpaqueList;
00936       std::list<RenderElement *>        m_visibleTransparentList;
00937       std::list<RenderElement *>        m_hiddenTransparentList;
00938
00939       bool                              m_collectRenderElements;
00940       RenderElement                   * m_currentRenderElement;
00941       RenderElement                   * m_lastRenderElement;
00942
00943     private:
00944       void renderList( std::list<RenderElement*> &rlist );
00945       void renderHiddenList( std::list<RenderElement*> &hlist );
00946       void renderHighlightList( std::list<HighlightElement*> &hlist );
00947       void renderElement( RenderElement * re );
00948       void renderPrimitiveSets(RenderElement* re);
00949       void renderHighlightObjects(HighlightElement* he);
00950       void renderStateAttributes(std::list<nvsg::StateAttributeHandle*>& alist, bool enable);
00951       void setClipPlanesElement(ClipPlanesElement *p);
00952       void setLightsElement(LightsElement *p);
00953       void setTransformElement(TransformElement *p);
00954       void traverseHeadLight( const nvsg::LightSource * p );
00955
00956       // gathers all available effect lights in a plain vector
00957       unsigned int getEffectLights( nvsg::CgFxEffect * effect
00958                                   , std::vector<nvsg::CgFxParameter>& lights) const;
00959
00960       // reset lights[first] to lights[last-1]
00961       void resetEffectLights( nvsg::CgFxEffect * effect
00962                             , const std::vector<nvsg::CgFxParameter>& lights
00963                             , unsigned int first
00964                             , unsigned int last );
00965
00966       // sets effect light values
00967       void setEffectLights( nvsg::CgFxEffect * effect
00968                           , const std::vector<nvsg::CgFxParameter>& lights
00969                           , LightsElement * headLights
00970                           , LightsElement * currLights );
00971
00972       // returns an object code to lookup the right render function for the given object.
00973       // returns OC_INVALID if no appropriate render function could be found for the object.
00974       unsigned int getObjectRenderCode(const nvsg::Object * obj);
00975
00976       void clearRenderList( std::list<RenderElement*> &rlist );
00977       template <typename REType>
00978        void clearRenderList( std::list<REType*>& rlist );
00979       template <typename REType>
00980        void clearRenderVector( std::vector<REType*>& rlist );
00981       void updateTransformElement( TransformElement * te );
00982
00983     private:
00984
00985       enum
00986       {
00987         // dirty bits - render list requires rebuild if one of these set
00988         // in addition the m_traverserBits needs to be evaluated for NVSG_TREE_DIRTY_MASK
00989         NVSG_GEOMETRY_CACHE_TECHNIQUE_CHANGED = BIT0
00990       , NVSG_TRANSPARENCY_TECHNIQUE_CHANGED   = BIT1
00991       , NVSG_RENDERLIST_INCOMPLETE            = BIT2
00992         // mask to check if at least one dirty bit is set
00993       , NVSG_RENDERLIST_DIRTY_MASK            = NVSG_GEOMETRY_CACHE_TECHNIQUE_CHANGED
00994                                               | NVSG_TRANSPARENCY_TECHNIQUE_CHANGED
00995                                               | NVSG_RENDERLIST_INCOMPLETE
00996
00997
00998         // render enable states and overwrites
00999         // face culling
01000       , NVSG_FACE_CULLING_BACK                = BIT3
01001       , NVSG_FACE_CULLING_FRONT               = BIT4
01002       , NVSG_FACE_CULLING_MASK                = NVSG_FACE_CULLING_BACK | NVSG_FACE_CULLING_FRONT
01003       , NVSG_FACE_CULLING_OVERWRITE           = BIT5
01004         // face mode
01005       , NVSG_FACE_MODE_OVERWRITE              = BIT6
01006         // two-sided lighting
01007       , NVSG_TWO_SIDED_LIGHTING               = BIT7
01008       , NVSG_TWO_SIDED_LIGHTING_OVERWRITE     = BIT8
01009         // anti aliasing
01010       , NVSG_LINE_ANTI_ALIASING               = BIT9
01011       , NVSG_POINT_ANTI_ALIASING              = BIT10
01012
01013         // render pass flavours
01014       , NVSG_HIGHLIGHT_PASS                   = BIT11
01015       , NVSG_OVERLAY_PASS                     = BIT12 // set if in overlay render pass
01016       , NVSG_TRANSPARENT_PASS                 = BIT13 // set if in transparent render pass
01017
01018         // per-drawable appearance
01019       , NVSG_TRANSPARENT_DRAWABLE             = BIT14 // set if current drawable rendered
01020                                                       // has transparent appearance
01021
01022         // extended rendering
01023       , NVSG_OCCLUSION_CULLING                = BIT15 // occlusion culling enabled if set
01024       };
01025       unsigned int m_renderTraverserBits;
01026
01027       nvsg::FaceMode  m_faceMode;
01028       float           m_lineWidth;
01029       float           m_pointSize;
01030       SortingPolicy   m_sortingPolicy;
01031
01032       // used with state handling during rendering
01033       std::list<nvsg::StateAttributeHandle *> m_currentStateAttribs;
01034
01035       std::stack<ClipPlanesElement *>   m_clipPlanesStack;
01036       ClipPlanesElement               * m_currentClipPlanes;
01037       nvsg::CgFxHandle                * m_currentCgFx;
01038       LightsElement                   * m_currentLights;
01039       nvsg::GroupHandle               * m_currentTransform;
01040       TransformElement                * m_currentTransformElement;
01041       bool                              m_currentTransformIsFixed;
01042       LightsElement                   * m_headLights;
01043       HighlightElement                * m_currentHighlightElement;
01044       ClipPlanesElement               * m_lastClipPlanesElement;
01045       LightsElement                   * m_lastLightsElement;
01046       TransformElement                * m_lastTransformElement;
01047       std::stack<nvmath::Vec3f>         m_currentScaling;
01048       const nvsg::StatePass           * m_currentStatePass;
01049       nvmath::Trafo                     m_currentTrafo;
01050       nvsg::StatePassHandle           * m_nullStatePass;
01051       nvsg::StateSetHandle            * m_nullStateSet;
01052       nvsg::StateVariantHandle        * m_currentStateVariant;
01053       nvsg::StateVariantHandle        * m_lastStateVariant;
01054       std::stack<const nvsg::Group*>    m_groupStack;
01055       RenderElementPool               * m_renderElementPool;
01056       std::stack<LightsElement *>       m_renderLightsStack;
01057       std::list<HighlightElement *>     m_highlightList;
01058       std::list<RenderElement *>        m_overlayOpaqueList;
01059       std::list<RenderElement *>        m_overlayTransparentList;
01060       std::stack<bool>                  m_currentOverlay;
01061       std::stack<bool>                  m_currentCullingPrevented;
01062       bool                              m_lastCullingPrevented;
01063       std::stack<TransformElement *>    m_renderTransformStack;
01064       std::vector<TransformElement *>   m_dynamicTransformElements;
01065       GeometryCacheTechnique            m_geometryCacheTechnique;
01066       JitterTechnique                   m_jitterTechnique;
01067       RenderTechnique                   m_renderTechnique;
01068       ShadowTechnique                   m_shadowTechnique;
01069       unsigned int                      m_shadowMapSize;
01070       float                             m_shadowMapIntensity;
01071       unsigned int                      m_textureSizeLimit;
01072       TransparencyTechnique             m_transparencyTechnique;
01073       OITTechnique                      m_oitTechnique;
01074       unsigned int                      m_oitMaxPasses;
01075       float                             m_oitThreshold;
01076
01077       // light tracking
01078       unsigned int                      m_currentNumLights;
01079       unsigned int                      m_lastNumLights;
01080
01081       unsigned int                      m_rasterOffsetX;
01082       unsigned int                      m_rasterOffsetY;
01083
01084   #if !defined(NDEBUG)
01085       bool                              m_isRendering;
01086       bool                              m_isTraversing;
01087   #endif
01088
01089       nvutil::MemFunTbl<RenderTraverser> * m_mrftbl; // member render function table
01090   };
01091
01092   template<typename RendererType>
01093     inline void RenderTraverser::addObjectRenderer( unsigned int objectCode, RendererType renderer )
01094   {
01095     m_mrftbl->addEntry( objectCode, renderer );
01096   }
01097
01098   inline unsigned int RenderTraverser::getObjectRenderCode(const nvsg::Object * obj)
01099   {
01100     NVSG_TRACE();
01101
01102     unsigned int oc = obj->getObjectCode();
01103     NVSG_ASSERT(oc!=nvsg::OC_INVALID);
01104
01105     if ( !m_mrftbl->testEntry(oc) )
01106     {
01107       unsigned int orgOC = oc;
01108       do
01109       { // came across an unknown object
01110         // move up the object's hierarchy to find an appropriate handler
01111         oc = obj->getHigherLevelObjectCode(oc);
01112         if ( nvsg::OC_INVALID==oc )
01113         { // proceed immediately without handling the object
01114           return oc;
01115         }
01116       }
01117       while ( !m_mrftbl->testEntry(oc) );
01118
01119       // found an appropriate renderer if we get here
01120
01121       // don't loop again for this object - register the handler
01122       addObjectRenderer(orgOC, (*m_mrftbl)[oc]);
01123     }
01124     return oc;
01125   }
01126
01127   inline void RenderTraverser::renderObject( nvsg::ObjectHandle * oh )
01128   {
01129     NVSG_TRACE();
01130
01131     if ( m_interrupt )
01132     {
01133       // there was an interrupt request.
01134       // immediately quit rendering
01135       m_traverserBits |= NVSG_TRAVERSAL_INTERRUPTED;
01136       return;
01137     }
01138
01139     // share-lock the object while being rendered
01140     const nvsg::Object * obj = oh->beginRead();
01141
01142     unsigned int oc = getObjectRenderCode( obj );
01143     if ( nvsg::OC_INVALID != oc )
01144     {
01145
01146 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01147       void * __esp__0;
01148       void * __esp__1;
01149       __asm mov __esp__0, esp
01150 #endif
01151       (this->*(void (RenderTraverser::*)(const nvsg::Object*))(*m_mrftbl)[oc])(obj);
01152 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01153       __asm mov __esp__1, esp
01154         NVSG_ASSERT(__esp__1==__esp__0);
01155 #endif
01156     }
01157
01158     oh->endRead();
01159   }
01160
01161   template <typename T>
01162     inline void RenderTraverser::renderObject( nvsg::ObjectHandle * oh, T arg )
01163   {
01164     NVSG_TRACE();
01165
01166     if ( m_interrupt )
01167     {
01168       // there was an interrupt request.
01169       // immediately quit rendering
01170       m_traverserBits |= NVSG_TRAVERSAL_INTERRUPTED;
01171       return;
01172   }
01173
01174     // share-lock the object while being rendered
01175     const nvsg::Object * obj = oh->beginRead();
01176
01177     unsigned int oc = getObjectRenderCode( obj );
01178     if ( nvsg::OC_INVALID != oc )
01179     {
01180 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01181       void * __esp__0;
01182       void * __esp__1;
01183       __asm mov __esp__0, esp
01184 #endif
01185       (this->*(void (RenderTraverser::*)(const nvsg::Object*, T))(*m_mrftbl)[oc])(obj, arg);
01186 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01187       __asm mov __esp__1, esp
01188         NVSG_ASSERT(__esp__1==__esp__0);
01189 #endif
01190     }
01191
01192     oh->endRead();
01193   }
01194
01195   inline bool RenderTraverser::isHighlightPass( void ) const
01196   {
01197     return !!(m_renderTraverserBits  & NVSG_HIGHLIGHT_PASS);
01198   }
01199
01200   inline bool RenderTraverser::isOverlayPass( void ) const
01201   {
01202     return !!(m_renderTraverserBits  & NVSG_OVERLAY_PASS);
01203   }
01204
01205   inline bool RenderTraverser::isTransparentPass( void ) const
01206   {
01207     return !!(m_renderTraverserBits  & NVSG_TRANSPARENT_PASS);
01208   }
01209
01210   inline RenderTraverser::GeometryCacheTechnique RenderTraverser::getGeometryCacheTechnique( void ) const
01211   {
01212     return( m_geometryCacheTechnique );
01213   }
01214
01215   inline RenderTraverser::JitterTechnique RenderTraverser::getJitterTechnique( void ) const
01216   {
01217     return( m_jitterTechnique );
01218   }
01219
01220   inline void RenderTraverser::setJitterTechnique( RenderTraverser::JitterTechnique jt )
01221   {
01222     NVSG_ASSERT( isJitterTechniqueSupported( jt ) );
01223     m_jitterTechnique = jt;
01224   }
01225
01226   inline bool RenderTraverser::isBackFaceCulling() const
01227   {
01228     return !!(m_renderTraverserBits & NVSG_FACE_CULLING_BACK);
01229   }
01230
01231   inline bool RenderTraverser::isFrontFaceCulling() const
01232   {
01233     return !!(m_renderTraverserBits & NVSG_FACE_CULLING_FRONT);
01234   }
01235
01236   inline void RenderTraverser::setFaceCulling( bool front, bool back )
01237   {
01238     // reset both
01239     m_renderTraverserBits &= ~(NVSG_FACE_CULLING_MASK);
01240     // conditional set
01241     if ( front )
01242     {
01243       m_renderTraverserBits |= NVSG_FACE_CULLING_FRONT;
01244     }
01245     if ( back )
01246     {
01247       m_renderTraverserBits |= NVSG_FACE_CULLING_BACK;
01248     }
01249   }
01250
01251   inline bool RenderTraverser::isFaceCullingOverwrite() const
01252   {
01253     return !!(m_renderTraverserBits & NVSG_FACE_CULLING_OVERWRITE);
01254   }
01255
01256   inline void RenderTraverser::setFaceCullingOverwrite( bool overwrite )
01257   {
01258     // reset
01259     m_renderTraverserBits &= ~NVSG_FACE_CULLING_OVERWRITE;
01260     // conditional set
01261     if ( overwrite )
01262     {
01263       m_renderTraverserBits |= NVSG_FACE_CULLING_OVERWRITE;
01264     }
01265   }
01266
01267   inline nvsg::FaceMode RenderTraverser::getFaceMode( void ) const
01268   {
01269     return( m_faceMode );
01270   }
01271
01272   inline void RenderTraverser::setFaceMode( nvsg::FaceMode mode )
01273   {
01274     m_faceMode = mode;
01275   }
01276
01277   inline bool RenderTraverser::isFaceModeOverwrite() const
01278   {
01279     return !!(m_renderTraverserBits & NVSG_FACE_MODE_OVERWRITE);
01280   }
01281
01282   inline void RenderTraverser::setFaceModeOverwrite( bool overwrite )
01283   {
01284     // reset
01285     m_renderTraverserBits &= ~NVSG_FACE_MODE_OVERWRITE;
01286     // conditional set
01287     if ( overwrite )
01288     {
01289       m_renderTraverserBits |= NVSG_FACE_MODE_OVERWRITE;
01290     }
01291   }
01292
01293   inline bool RenderTraverser::isTwoSidedLighting() const
01294   {
01295     return !!(m_renderTraverserBits & NVSG_TWO_SIDED_LIGHTING);
01296   }
01297
01298   inline void RenderTraverser::setTwoSidedLighting( bool enable )
01299   {
01300     // reset
01301     m_renderTraverserBits &= ~NVSG_TWO_SIDED_LIGHTING;
01302     // conditional set
01303     if ( enable )
01304     {
01305       m_renderTraverserBits |= NVSG_TWO_SIDED_LIGHTING;
01306     }
01307   }
01308
01309   inline bool RenderTraverser::isTwoSidedLightingOverwrite() const
01310   {
01311     return !!(m_renderTraverserBits & NVSG_TWO_SIDED_LIGHTING_OVERWRITE);
01312   }
01313
01314   inline void RenderTraverser::setTwoSidedLightingOverwrite( bool overwrite )
01315   {
01316     // reset
01317     m_renderTraverserBits &= ~NVSG_TWO_SIDED_LIGHTING_OVERWRITE;
01318     // conditional set
01319     if ( overwrite )
01320     {
01321       m_renderTraverserBits |= NVSG_TWO_SIDED_LIGHTING_OVERWRITE;
01322     }
01323   }
01324
01325   inline RenderTraverser::RenderTechnique RenderTraverser::getRenderTechnique( void ) const
01326   {
01327     return( m_renderTechnique );
01328   }
01329
01330   inline RenderTraverser::ShadowTechnique RenderTraverser::getShadowTechnique( void ) const
01331   {
01332     return( m_shadowTechnique );
01333   }
01334
01335   inline unsigned int RenderTraverser::getShadowMapSize( void ) const
01336   {
01337     return( m_shadowMapSize );
01338   }
01339
01340   inline float RenderTraverser::getShadowMapIntensity( void ) const
01341   {
01342     return( m_shadowMapIntensity );
01343   }
01344
01345   inline void RenderTraverser::setShadowMapIntensity( float intensity )
01346   {
01347     NVSG_ASSERT( ( 0.0f <= intensity ) && ( intensity <= 1.0f ) );
01348     m_shadowMapIntensity = intensity;
01349   }
01350
01351   inline unsigned int RenderTraverser::getTextureSizeLimit( void ) const
01352   {
01353     return( m_textureSizeLimit );
01354   }
01355
01356   inline RenderTraverser::TransparencyTechnique RenderTraverser::getTransparencyTechnique( void ) const
01357   {
01358     return( m_transparencyTechnique );
01359   }
01360
01361   inline RenderTraverser::OITTechnique RenderTraverser::getOITTechnique( void ) const
01362   {
01363     return( m_oitTechnique );
01364   }
01365
01366   inline unsigned int RenderTraverser::getOITMaxPasses( void ) const
01367   {
01368     return( m_oitMaxPasses );
01369   }
01370
01371   inline float RenderTraverser::getOITThreshold( void ) const
01372   {
01373     return( m_oitThreshold );
01374   }
01375
01376   inline void RenderTraverser::setOITThreshold( float threshold )
01377   {
01378     NVSG_ASSERT( ( 0.0f <= threshold ) && ( threshold <= 1.0f ) );
01379     m_oitThreshold = threshold;
01380   }
01381
01382   inline nvsg::CgFxHandle * RenderTraverser::getCurrentCgFx( void ) const
01383   {
01384     NVSG_ASSERT( m_isRendering );
01385     return( m_currentCgFx );
01386   }
01387
01388   inline void RenderTraverser::setLineAntiAliasing( bool onOff )
01389   {
01390     // reset
01391     m_renderTraverserBits &= ~NVSG_LINE_ANTI_ALIASING;
01392     if ( onOff )
01393     {
01394       m_renderTraverserBits |= NVSG_LINE_ANTI_ALIASING;
01395     }
01396   }
01397
01398   inline bool RenderTraverser::isLineAntiAliasingEnabled() const
01399   {
01400     return !!(m_renderTraverserBits & NVSG_LINE_ANTI_ALIASING);
01401   }
01402
01403   inline float RenderTraverser::getLineWidth( void ) const
01404   {
01405     return( m_lineWidth );
01406   }
01407
01408   inline void RenderTraverser::setLineWidth( float width )
01409   {
01410     m_lineWidth = width;
01411   }
01412
01413   inline void RenderTraverser::setPointAntiAliasing( bool onOff )
01414   {
01415     // reset
01416     m_renderTraverserBits &= ~NVSG_POINT_ANTI_ALIASING;
01417     if ( onOff )
01418     {
01419       m_renderTraverserBits |= NVSG_POINT_ANTI_ALIASING;
01420     }
01421   }
01422
01423   inline bool RenderTraverser::isPointAntiAliasingEnabled() const
01424   {
01425     return !!(m_renderTraverserBits & NVSG_POINT_ANTI_ALIASING);
01426   }
01427
01428   inline float RenderTraverser::getPointSize( void ) const
01429   {
01430     return( m_pointSize );
01431   }
01432
01433   inline void RenderTraverser::setPointSize( float size )
01434   {
01435     m_pointSize = size;
01436   }
01437
01438   inline void RenderTraverser::setSortingPolicy( SortingPolicy sp )
01439   {
01440     m_sortingPolicy = sp;
01441   }
01442
01443   inline RenderTraverser::SortingPolicy RenderTraverser::getSortingPolicy( void ) const
01444   {
01445     return( m_sortingPolicy );
01446   }
01447
01448   inline bool RenderTraverser::isOcclusionCulling( void ) const
01449   {
01450     return !!(m_renderTraverserBits & NVSG_OCCLUSION_CULLING);
01451   }
01452
01453   inline unsigned int RenderTraverser::getRasterOffsetX() const
01454   {
01455     return( m_rasterOffsetX );
01456   }
01457
01458   inline unsigned int RenderTraverser::getRasterOffsetY() const
01459   {
01460     return( m_rasterOffsetY );
01461   }
01462 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Scene.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CoreTypes.h"
#include "nvsg/Group.h"
#include "nvsg/Node.h"
#include "nvmath/Vecnt.h"

Include dependency graph for Scene.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:14 2008 for NVSGSDK by NVIDIA


Scene.h Source File

Scene.h

Go to the documentation of this file.
00001  // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/CoreTypes.h"
00017 #include "nvsg/Group.h"
00018 #include "nvsg/Node.h"
00019 #include "nvmath/Vecnt.h"
00020
00021 namespace nvsg
00022 {
00031   class Scene : public nvutil::HandledObject
00032   {
00033     public:
00038       NVSG_API Scene();
00039
00041       NVSG_API virtual ~Scene();
00042
00048       NVSG_API const nvmath::Vec3f & getAmbientColor() const;
00049
00055       NVSG_API void setAmbientColor( const nvmath::Vec3f & color );
00056
00067       NVSG_API int getFrameNumber() const;
00068
00080       NVSG_API void setFrameNumber( int frameNumber );
00081
00087       NVSG_API const nvmath::Vec4f & getBackColor()  const;
00088
00094       NVSG_API void setBackColor( const nvmath::Vec4f & color );
00095
00099       NVSG_API nvsg::TextureImageHandle* getBackImage() const;
00100
00105       NVSG_API void setBackImage(nvsg::TextureImageHandle* image );
00106
00112       NVSG_API unsigned int getNumberOfCameras() const;
00113
00120       NVSG_API CameraHandle * getCamera( unsigned int index = 0 ) const;
00121
00126       NVSG_API void addCamera( CameraHandle * camera );
00127
00134       NVSG_API void removeCamera( unsigned int index );
00135
00141       NVSG_API unsigned int getNumberOfCameraAnimations() const;
00142
00152       NVSG_API TrafoAnimationHandle * getCameraAnimation( unsigned int index = 0 ) const;
00153
00161       NVSG_API void addCameraAnimation( TrafoAnimationHandle * animation );
00162
00169       NVSG_API void removeCameraAnimation( unsigned int index );
00170
00175       NVSG_API NodeHandle * getRootNode() const;
00176
00182       NVSG_API void setRootNode( NodeHandle * root );
00183
00189       NVSG_API bool containsCgFx() const;
00190
00194       NVSG_API bool containsLight() const;
00195
00199       NVSG_API bool containsTransparentGeometry() const;
00200
00204       NVSG_API bool containsAnimation() const;
00205
00206     private:
00207       nvmath::Vec3f                        m_ambientColor;
00208       nvmath::Vec4f                        m_backColor;
00209       nvsg::TextureImageHandle*            m_backImage;
00210       std::vector<CameraHandle*>           m_cameras;
00211       std::vector<TrafoAnimationHandle*>   m_cameraAnimations;
00212       NodeHandle                         * m_root;
00213       int                                  m_frameNumber;
00214   };
00215
00216   inline void Scene::setFrameNumber( int num )
00217   {
00218     NVSG_TRACE();
00219     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00220     m_frameNumber = (num<0) ? 0 : num;
00221   }
00222
00223   inline int Scene::getFrameNumber() const
00224   {
00225     NVSG_TRACE();
00226     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00227     return m_frameNumber;
00228   }
00229
00230   inline void Scene::addCamera( CameraHandle * camera )
00231   {
00232     NVSG_TRACE();
00233     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00234     m_cameras.push_back( camera );
00235     camera->addRef();
00236   }
00237
00238   inline CameraHandle * Scene::getCamera( unsigned int index ) const
00239   {
00240     NVSG_TRACE();
00241     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00242     NVSG_ASSERT( index < m_cameras.size() );
00243     return( m_cameras[index] );
00244   }
00245
00246   inline void Scene::removeCamera( unsigned int index )
00247   {
00248     NVSG_TRACE();
00249     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00250     NVSG_ASSERT(index < m_cameras.size());
00251
00252     m_cameras[index]->removeRef();
00253     m_cameras.erase(m_cameras.begin()+index);
00254   }
00255
00256   inline void Scene::addCameraAnimation( TrafoAnimationHandle *animation )
00257   {
00258     NVSG_TRACE();
00259     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00260     m_cameraAnimations.push_back( animation );
00261     animation->addRef();
00262   }
00263
00264   inline TrafoAnimationHandle * Scene::getCameraAnimation( unsigned int index ) const
00265   {
00266     NVSG_TRACE();
00267     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00268     NVSG_ASSERT( index < m_cameraAnimations.size() );
00269     return( m_cameraAnimations[index] );
00270   }
00271
00272   inline void Scene::removeCameraAnimation( unsigned int index )
00273   {
00274     NVSG_TRACE();
00275     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00276     NVSG_ASSERT(index < m_cameraAnimations.size());
00277
00278     m_cameraAnimations[index]->removeRef();
00279     m_cameraAnimations.erase(m_cameraAnimations.begin()+index);
00280   }
00281
00282   inline unsigned int Scene::getNumberOfCameras() const
00283   {
00284     NVSG_TRACE();
00285     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00286     NVSG_ASSERT( m_cameras.size() <= UINT_MAX );
00287     return( static_cast<unsigned int>(m_cameras.size()) );
00288   }
00289
00290   inline unsigned int Scene::getNumberOfCameraAnimations() const
00291   {
00292     NVSG_TRACE();
00293     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00294     NVSG_ASSERT( m_cameraAnimations.size() <= UINT_MAX );
00295     return( static_cast<unsigned int>(m_cameraAnimations.size()) );
00296   }
00297
00298   inline NodeHandle * Scene::getRootNode() const
00299   {
00300     NVSG_TRACE();
00301     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00302     return( m_root );
00303   }
00304
00305   inline bool Scene::containsCgFx() const
00306   {
00307     NVSG_TRACE();
00308     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00309     nvutil::ReadableObject<Node> root(m_root);
00310     return( root->containsCgFx() );
00311   }
00312
00313   inline bool Scene::containsLight() const
00314   {
00315     NVSG_TRACE();
00316     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00317     return( dynamic_cast<GroupHandle *>(m_root)
00318             ? nvutil::ReadableObject<Group>(dynamic_cast<GroupHandle*>(m_root))->containsLight()
00319             : false );
00320   }
00321
00322   inline bool Scene::containsTransparentGeometry() const
00323   {
00324     NVSG_TRACE();
00325     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00326     nvutil::ReadableObject<Node> root(m_root);
00327     return( root->containsTransparentGeometry() );
00328   }
00329
00330   inline bool Scene::containsAnimation() const
00331   {
00332     NVSG_TRACE();
00333     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00334     return( !m_cameraAnimations.empty() || nvutil::ReadableObject<Node>(m_root)->containsAnimation() );
00335   }
00336
00337   inline const nvmath::Vec3f& Scene::getAmbientColor() const
00338   {
00339     NVSG_TRACE();
00340     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00341     return( m_ambientColor );
00342   }
00343
00344   inline void Scene::setAmbientColor( const nvmath::Vec3f &color )
00345   {
00346     NVSG_TRACE();
00347     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00348     m_ambientColor = color;
00349   }
00350
00351   inline const nvmath::Vec4f& Scene::getBackColor() const
00352   {
00353     NVSG_TRACE();
00354     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00355     return( m_backColor );
00356   }
00357
00358   inline void Scene::setBackColor( const nvmath::Vec4f &color )
00359   {
00360     NVSG_TRACE();
00361     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00362     m_backColor = color;
00363   }
00364  inline  nvsg::TextureImageHandle* Scene::getBackImage() const
00365   {
00366     NVSG_TRACE();
00367     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00368     return(m_backImage);
00369   }
00370 } //  namspace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


SearchTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvtraverser/Traverser.h"

Include dependency graph for SearchTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:14 2008 for NVSGSDK by NVIDIA


SearchTraverser.h Source File

SearchTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvtraverser/Traverser.h"
00017
00018 namespace nvsg
00019 {
00020   class AnimationBase;
00021   class IndependentPrimitiveSet;
00022   class MeshedPrimitiveSet;
00023   class Path;
00024   class StrippedPrimitiveSet;
00025   template<typename T> class Animation;
00026   template<typename T> class KeyFramedAnimation;
00027 }
00028
00029 namespace nvtraverser
00030 {
00032
00034   class SearchTraverser : public SharedTraverser
00035   {
00036     public:
00038       NVSG_API SearchTraverser(void);
00039
00041       typedef std::vector<const nvsg::Object*>::const_iterator iterator;
00042
00044
00045       NVSG_API const std::vector<const nvsg::Path*> & getPaths( void ) const;
00046
00048
00049       NVSG_API const std::vector<nvsg::ObjectHandle*> & getResults( void ) const;
00050
00052
00054       NVSG_API void setClassName( const std::string& name
00055                                 );
00056
00058       NVSG_API void setObjectName(const std::string& objectName
00059                                 );
00061       NVSG_API void setObjectPointer(nvsg::ObjectHandle *ptr
00062                                 );
00063
00065
00068       NVSG_API void setBaseClassSearch( bool enable
00069                                       );
00070
00071     protected:
00073       NVSG_API virtual ~SearchTraverser(void);
00074
00076       NVSG_API virtual void  doApply( nvsg::NodeHandle * root );
00077
00080       NVSG_API void addItem( const nvsg::Object* obj );
00081
00083       NVSG_API virtual void handleBillboard(
00084         const nvsg::Billboard * p
00085         );
00086
00088       NVSG_API virtual void handleGeoNode(
00089         const nvsg::GeoNode * p
00090       );
00091
00093       NVSG_API void handleVolumeNode( const nvsg::VolumeNode * p );
00094
00096       NVSG_API virtual void handleGroup(
00097         const nvsg::Group * p
00098       );
00099
00101       NVSG_API virtual void handleFlipbookAnimation(
00102         const nvsg::FlipbookAnimation * p
00103         );
00104
00106       NVSG_API virtual void handleLOD(
00107         const nvsg::LOD * p
00108       );
00109
00111       NVSG_API virtual void handleSwitch(
00112         const nvsg::Switch * p
00113       );
00114
00116       NVSG_API virtual void handleTransform(
00117         const nvsg::Transform * p
00118       );
00119
00121       NVSG_API virtual void handleAnimatedTransform(
00122         const nvsg::AnimatedTransform * p
00123       );
00124
00126       NVSG_API virtual void handleDirectedLight(
00127         const nvsg::DirectedLight * p
00128       );
00129
00131       NVSG_API virtual void handlePointLight(
00132         const nvsg::PointLight * p
00133       );
00134
00136       NVSG_API virtual void handleSpotLight(
00137         const nvsg::SpotLight * p
00138       );
00139
00141       NVSG_API virtual void handleLines(
00142         const nvsg::Lines * p
00143         );
00144
00146       NVSG_API virtual void handleLineStrips(
00147         const nvsg::LineStrips * p
00148         );
00149
00151       NVSG_API virtual void handlePoints(
00152         const nvsg::Points * p
00153         );
00154
00156       NVSG_API virtual void handleQuadMeshes(
00157         const nvsg::QuadMeshes * p
00158         );
00159
00161       NVSG_API virtual void handleQuads(
00162         const nvsg::Quads * p
00163       );
00164
00166       NVSG_API virtual void handleQuadStrips(
00167         const nvsg::QuadStrips * p
00168       );
00169
00171       NVSG_API virtual void handleTriangles(
00172         const nvsg::Triangles * p
00173       );
00174
00176       NVSG_API virtual void handleSkinnedTriangles(
00177         const nvsg::SkinnedTriangles * p
00178       );
00179
00181       NVSG_API virtual void handleTriFans(
00182         const nvsg::TriFans * p
00183       );
00184
00186       NVSG_API virtual void handleTriStrips(
00187         const nvsg::TriStrips * p
00188       );
00189
00191       NVSG_API virtual void handleStateSet(
00192         const nvsg::StateSet * p
00193       );
00194
00196       NVSG_API virtual void handleStateVariant(
00197         const nvsg::StateVariant * p
00198         );
00199
00201       NVSG_API virtual void handleStatePass(
00202         const nvsg::StatePass * p
00203         );
00204
00206       NVSG_API virtual void handleBlendAttribute(
00207         const nvsg::BlendAttribute * p
00208         );
00209
00211       NVSG_API virtual void handleCgFx(
00212         const nvsg::CgFx * p
00213       );
00214
00216       NVSG_API virtual void handleDepthAttribute(
00217         const nvsg::DepthAttribute * p
00218         );
00219
00221       NVSG_API virtual void handleFaceAttribute(
00222         const nvsg::FaceAttribute * p
00223       );
00224
00226       NVSG_API virtual void handleLineAttribute(
00227         const nvsg::LineAttribute * p
00228         );
00229
00231       NVSG_API virtual void handleMaterial(
00232         const nvsg::Material * p
00233       );
00234
00236       NVSG_API virtual void handlePointAttribute(
00237         const nvsg::PointAttribute * p
00238         );
00239
00241       NVSG_API virtual void handleTextureAttribute(
00242         const nvsg::TextureAttribute * p
00243       );
00244
00246       NVSG_API virtual void handleUnlitColorAttribute(
00247         const nvsg::UnlitColorAttribute* p
00248       );
00249
00251       NVSG_API virtual void handleParallelCamera(
00252         const nvsg::ParallelCamera * p
00253       );
00254
00256       NVSG_API virtual void handlePerspectiveCamera(
00257         const nvsg::PerspectiveCamera * p
00258       );
00259
00261       NVSG_API virtual void handleFramedIndexAnimation(
00262         const nvsg::FramedAnimation<unsigned int> * p
00263         );
00264
00266       NVSG_API virtual void handleFramedTrafoAnimation(
00267         const nvsg::FramedAnimation<nvmath::Trafo> * p
00268       );
00269
00271       NVSG_API virtual void handleFramedVertexAttributeAnimation( const nvsg::FramedAnimation<nvsg::VertexAttribute> * p );
00272
00274       NVSG_API virtual void handleLinearInterpolatedTrafoAnimation(
00275         const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> * p
00276       );
00277
00279       NVSG_API virtual void handleLinearInterpolatedVertexAttributeAnimation( const nvsg::LinearInterpolatedAnimation<nvsg::VertexAttribute> * p );
00280
00282       NVSG_API virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *vas );
00283
00285       NVSG_API virtual void handleAnimatedVertexAttributeSet( const nvsg::AnimatedVertexAttributeSet * avas );
00286
00288       NVSG_API virtual void handleSkin( const nvsg::Skin * skin );
00289
00291
00292       NVSG_API virtual void search( const nvsg::Animation<nvmath::Trafo> *p
00293                                     );
00294
00298       NVSG_API virtual void search( const nvsg::Animation<unsigned int> *p );
00299
00301
00302       NVSG_API virtual void search( const nvsg::Animation<nvsg::VertexAttribute> *p );
00303
00307       NVSG_API virtual void search( const nvsg::AnimationBase *p );
00308
00310
00311       NVSG_API virtual void search( const nvsg::Camera *p
00312                                   );
00313
00315
00316       NVSG_API virtual void search( const nvsg::Drawable *p
00317                                   );
00318
00320
00321       NVSG_API virtual void search( const nvsg::Group *p
00322                                   );
00323
00325
00326       NVSG_API virtual void search( const nvsg::IndependentPrimitiveSet * p
00327                                   );
00328
00330
00331       NVSG_API virtual void search( const nvsg::KeyFramedAnimation<nvmath::Trafo> *p
00332                                   );
00333
00335
00336       NVSG_API virtual void search( const nvsg::KeyFramedAnimation<nvsg::VertexAttribute> *p );
00337
00339
00340       NVSG_API virtual void search( const nvsg::LightSource *p
00341                                   );
00342
00344
00345       NVSG_API virtual void search( const nvsg::MeshedPrimitiveSet * p
00346         );
00347
00349
00350       NVSG_API virtual void search( const nvsg::Node *p
00351                                   );
00352
00354
00355       NVSG_API virtual void search( const nvsg::Object *p
00356                                   );
00357
00359
00360       NVSG_API virtual void search( const nvsg::PrimitiveSet *p
00361                                   );
00362
00364
00365       NVSG_API virtual void search( const nvsg::Quads *p
00366                                   );
00367
00369
00370       NVSG_API virtual void search( const nvsg::StateAttribute *p
00371                                   );
00372
00374
00375       NVSG_API virtual void search( const nvsg::StrippedPrimitiveSet * p
00376                                   );
00377
00379
00380       NVSG_API virtual void search( const nvsg::Transform *p
00381                                   );
00382
00384
00385       NVSG_API virtual void search( const nvsg::Triangles *p
00386                                   );
00387
00389
00390       NVSG_API virtual void search( const nvsg::VertexAttributeSet * p );
00391
00393
00394       NVSG_API virtual void search( const nvsg::OwnedObject<nvsg::PrimitiveSetHandle> * p );
00395
00396
00397     private:
00398       bool searchNode(const nvsg::Object* p, const std::string &classNameToHandle);
00399
00400       nvsg::Path                        * m_currentPath;
00401       std::string                         m_className;
00402       std::string                         m_objectName;
00403       nvsg::ObjectHandle                * m_objectPointer;
00404       std::vector<const nvsg::Path*>      m_paths;
00405       std::vector<nvsg::ObjectHandle*>    m_results;
00406       bool                                m_searchBaseClass;
00407   };
00408
00409   inline const std::vector<nvsg::ObjectHandle *> & SearchTraverser::getResults( void ) const
00410   {
00411     return( m_results );
00412   }
00413
00414   inline const std::vector<const nvsg::Path*> & SearchTraverser::getPaths( void ) const
00415   {
00416     return( m_paths );
00417   }
00418
00419   inline  void  SearchTraverser::setClassName( const std::string& name )
00420   {
00421     m_className = name;
00422   }
00423
00424   inline void SearchTraverser::setObjectName(const std::string &objectName)
00425   {
00426     m_objectName = objectName;
00427   }
00428
00429   inline void SearchTraverser::setObjectPointer(nvsg::ObjectHandle *ptr)
00430   {
00431     m_objectPointer = ptr;
00432   }
00433   inline  void  SearchTraverser::setBaseClassSearch( bool enable )
00434   {
00435     m_searchBaseClass = enable;
00436   }
00437
00438 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Shape.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Drawable.h"
#include "nvsg/PrimitiveSet.h"

Include dependency graph for Shape.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:15 2008 for NVSGSDK by NVIDIA


Shape.h Source File

Shape.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Drawable.h"
00017 #include "nvsg/PrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00026   class Shape : public Drawable
00027   {
00028     public:
00030       NVSG_API virtual ~Shape();
00031
00035       NVSG_API unsigned int getNumberOfPrimitiveSets() const;
00036
00043       NVSG_API PrimitiveSetHandle * getPrimitiveSet( unsigned int index ) const;
00044
00056       NVSG_API virtual bool isEquivalent( const Object * p
00057                                         , bool ignoreNames
00058                                         , bool deepCompare ) const;
00059
00065       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00066
00067     protected:
00071       NVSG_API Shape();
00072
00077       NVSG_API Shape( const Shape& rhs );
00078
00084       NVSG_API void addPrimitiveSet( PrimitiveSetHandle * p );
00085
00093       NVSG_API void removePrimitiveSet( unsigned int index );
00094
00099       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00100
00107       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00108
00115       NVSG_API Shape & operator=(const Shape & rhs);
00116
00117     private:
00118       typedef std::vector<PrimitiveSetHandle *>::const_iterator ConstPrimitiveSetIterator;
00119       typedef std::vector<PrimitiveSetHandle *>::iterator PrimitiveSetIterator;
00120       std::vector<PrimitiveSetHandle *> m_primitiveSets;
00121   };
00122
00123   inline unsigned int Shape::getNumberOfPrimitiveSets() const
00124   {
00125     NVSG_TRACE();
00126     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00127     NVSG_ASSERT( m_primitiveSets.size() <= UINT_MAX );
00128     return( static_cast<unsigned int>(m_primitiveSets.size()) );
00129   }
00130
00131   inline PrimitiveSetHandle * Shape::getPrimitiveSet( unsigned int i ) const
00132   {
00133     NVSG_TRACE();
00134     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00135     NVSG_ASSERT( i < m_primitiveSets.size() );
00136     return( m_primitiveSets[i] );
00137   }
00138
00139 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Singleton.h File Reference

#include "nvsg/nvsgapi.h"

Include dependency graph for Singleton.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:17 2008 for NVSGSDK by NVIDIA


Singleton.h Source File

Singleton.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/nvsgapi.h"  // storage-class defines
00016
00017 namespace nvutil {
00018
00020
00022 template <typename T>
00023 class Singleton
00024 {
00025 public:
00027
00029   static T* instance();
00030
00031 private:
00032   // not permitted
00033   // client must call Singleton<T>::instance() for instantiation
00034   Singleton() {}
00035   Singleton(const Singleton<T>&) {}
00036   ~Singleton() {}
00037   // also not permitted
00038   Singleton<T>& operator=(const Singleton<T>&) {}
00039
00040 private:
00041   static NVSG_API T m_instance;
00042 };
00043
00044 template <typename T>
00045 inline T* Singleton<T>::instance()
00046 {
00047   return &m_instance;
00048 };
00049
00050 } // namespace nvutil
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Skin.h File Reference

#include "nvmath/Matnnt.h"
#include "nvsg/OwnedObject.h"
#include "nvsg/VertexAttributeSet.h"

Include dependency graph for Skin.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:17 2008 for NVSGSDK by NVIDIA


Skin.h Source File

Skin.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvmath/Matnnt.h"
00016 #include "nvsg/OwnedObject.h"
00017 #include "nvsg/VertexAttributeSet.h"
00018
00019 namespace nvsg
00020 {
00037   class Skin : public OwnedObject<PrimitiveSetHandle>
00038   {
00039     friend class PrimitiveSet;
00040
00041     public:
00042       typedef enum
00043       {
00044         NVSG_SKIN_NONE,   // don't skin this VertexAttribute (for texture coordinates, for example)
00045         NVSG_SKIN_POINT,  // skin with the skinning matrices (like positions)
00046         NVSG_SKIN_VECTOR  // skin with the inverse transpose matrices (like normals) and normalize the resulting vector
00047       } SkinningType;
00048
00049     public:
00052       NVSG_API Skin();
00053
00057       NVSG_API Skin( const Skin & rhs );
00058
00060       NVSG_API virtual ~Skin();
00061
00065       NVSG_API Skin & operator=( const Skin & rhs );
00066
00075       NVSG_API virtual bool isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const;
00076
00085       NVSG_API Skin::SkinningType getSkinningType( unsigned int attrib ) const;
00086
00095       NVSG_API void setSkinningType( unsigned int attrib, SkinningType type );
00096
00110       NVSG_API void setInfluenceData( const float * weights
00111                                     , const unsigned int * indices
00112                                     , const unsigned int * counts
00113                                     , unsigned int numberOfInfluences );
00114
00124       NVSG_API void setInfluenceData( unsigned int pos
00125                                     , const float * weights
00126                                     , const unsigned int * indices
00127                                     , const unsigned int * counts
00128                                     , unsigned int numberOfInfluences );
00129
00134       NVSG_API const float * getWeights() const;
00135
00140       NVSG_API const unsigned int * getIndices() const;
00141
00146       NVSG_API const unsigned int * getCounts() const;
00147
00153       NVSG_API const unsigned int * getOffsets() const;
00154
00160       NVSG_API unsigned int getNumberOfInfluences() const;
00161
00166       NVSG_API unsigned int getTotalNumberOfIndices() const;
00167
00173       NVSG_API const nvmath::Mat44f & getBindShapeMatrix() const;
00174
00180       NVSG_API void setBindShapeMatrix( const nvmath::Mat44f & matrix );
00181
00185       NVSG_API unsigned int getNumberOfJoints() const;
00186
00198       NVSG_API unsigned int addJoint( TransformHandle * joint, const nvmath::Mat44f & inverseBindMatrix, unsigned int position = ~0 );
00199
00206       NVSG_API TransformHandle * getJoint( unsigned int position ) const;
00207
00214       NVSG_API const nvmath::Mat44f & getInverseBindMatrix( unsigned int position ) const;
00215
00224       NVSG_API void removeJoint( unsigned int position );
00225
00226       NVSG_API virtual bool isCompatible( const Skin * p ) const;
00227
00228     private:
00229       nvmath::Mat44f                  m_bindShapeMatrix;
00230       std::vector<unsigned int>       m_counts;
00231       std::vector<unsigned int>       m_indices;
00232       std::vector<nvmath::Mat44f>     m_inverseBindMatrices;
00233       std::vector<TransformHandle *>  m_joints;
00234       SkinningType                    m_skinningType[VertexAttributeSet::NVSG_VERTEX_ATTRIB_COUNT];
00235       std::vector<float>              m_weights;
00236
00237       std::vector<unsigned int>       m_offsets;
00238   };
00239
00240   inline Skin::SkinningType Skin::getSkinningType( unsigned int attrib ) const
00241   {
00242     NVSG_TRACE();
00243     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00244     NVSG_ASSERT( attrib < VertexAttributeSet::NVSG_VERTEX_ATTRIB_COUNT );
00245     return( m_skinningType[attrib] );
00246   }
00247
00248   inline const float * Skin::getWeights() const
00249   {
00250     NVSG_TRACE();
00251     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00252     return( &m_weights[0] );
00253   }
00254
00255   inline const unsigned int * Skin::getIndices() const
00256   {
00257     NVSG_TRACE();
00258     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00259     return( &m_indices[0] );
00260   }
00261
00262   inline const unsigned int * Skin::getCounts() const
00263   {
00264     NVSG_TRACE();
00265     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00266     return( &m_counts[0] );
00267   }
00268
00269   inline const unsigned int * Skin::getOffsets() const
00270   {
00271     NVSG_TRACE();
00272     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00273     return( &m_offsets[0] );
00274   }
00275
00276   inline unsigned int Skin::getNumberOfInfluences() const
00277   {
00278     NVSG_TRACE();
00279     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00280     return( static_cast<unsigned int>(m_counts.size()) );
00281   }
00282
00283   inline unsigned int Skin::getTotalNumberOfIndices() const
00284   {
00285     NVSG_TRACE();
00286     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00287     return( static_cast<unsigned int>(m_indices.size()) );
00288   }
00289
00290   inline const nvmath::Mat44f & Skin::getBindShapeMatrix() const
00291   {
00292     NVSG_TRACE();
00293     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00294     return( m_bindShapeMatrix );
00295   }
00296
00297   inline void Skin::setBindShapeMatrix( const nvmath::Mat44f & matrix )
00298   {
00299     NVSG_TRACE();
00300     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00301     if ( matrix != m_bindShapeMatrix )
00302     {
00303       m_bindShapeMatrix = matrix;
00304       invalidateIncarnation();
00305     }
00306   }
00307
00308   inline unsigned int Skin::getNumberOfJoints() const
00309   {
00310     NVSG_TRACE();
00311     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00312     return( static_cast<unsigned int>(m_joints.size()) );
00313   }
00314
00315   inline TransformHandle * Skin::getJoint( unsigned int position ) const
00316   {
00317     NVSG_TRACE();
00318     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00319     NVSG_ASSERT( position < m_joints.size() );
00320     return( m_joints[position] );
00321   }
00322
00323   inline const nvmath::Mat44f & Skin::getInverseBindMatrix( unsigned int position ) const
00324   {
00325     NVSG_TRACE();
00326     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00327     NVSG_ASSERT( position < m_inverseBindMatrices.size() );
00328     return( m_inverseBindMatrices[position] );
00329   }
00330
00331 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


SkinnedTriangles.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Matnnt.h"
#include "nvmath/Trafo.h"
#include "nvsg/Animation.h"
#include "nvsg/Triangles.h"

Include dependency graph for SkinnedTriangles.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:18 2008 for NVSGSDK by NVIDIA


SkinnedTriangles.h Source File

SkinnedTriangles.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Matnnt.h"
00017 #include "nvmath/Trafo.h"
00018 #include "nvsg/Animation.h"
00019 #include "nvsg/Triangles.h" // base class definition
00020
00021 namespace nvsg
00022 {
00031   class Bone
00032   {
00033     public:
00036       NVSG_API Bone();
00037
00043       NVSG_API Bone( const Bone &rhs );
00044
00048       NVSG_API ~Bone();
00049
00053       NVSG_API TrafoAnimationHandle * getAnimation() const;
00054
00061       NVSG_API const nvmath::Mat44f & getMatrix( unsigned int frame ) const;
00062
00065       NVSG_API float getWeight() const;
00066
00072       NVSG_API void setAnimation( TrafoAnimationHandle * animation );
00073
00079       NVSG_API void setInverse( const nvmath::Mat44f & inverse );
00080
00085       NVSG_API void setMatrix( const nvmath::Mat44f & trafo );
00086
00091       NVSG_API void setWeight( float weight );
00092
00099       NVSG_API nvmath::Vec4f operator()( unsigned int frame, const nvmath::Vec4f & v ) const;
00100
00108       NVSG_API bool operator==( const Bone & b ) const;
00109
00117       NVSG_API Bone & operator=( const Bone &rhs );
00118
00119     private:
00120       TrafoAnimationHandle * m_animation;
00121       nvmath::Mat44f m_baseInverse;
00122       float m_weight;
00123
00124       mutable unsigned int  m_currFrame;
00125       mutable nvmath::Mat44f  m_currTrafo;
00126   };
00127
00128   inline TrafoAnimationHandle * Bone::getAnimation() const
00129   {
00130     NVSG_TRACE();
00131     return( m_animation );
00132   }
00133
00134   inline float Bone::getWeight() const
00135   {
00136     NVSG_TRACE();
00137     return( m_weight );
00138   }
00139
00140   inline void Bone::setInverse( const nvmath::Mat44f &inverse )
00141   {
00142     NVSG_TRACE();
00143     m_baseInverse = inverse;
00144   }
00145
00146   inline void Bone::setMatrix( const nvmath::Mat44f &trafo )
00147   {
00148     NVSG_TRACE();
00149     m_currTrafo = trafo;
00150     m_currFrame = 0xFFFFFFFF;
00151   }
00152
00153   inline void Bone::setWeight( float weight )
00154   {
00155     NVSG_TRACE();
00156     m_weight = weight;
00157   }
00158
00159   inline bool Bone::operator==( const Bone &b ) const
00160   {
00161     NVSG_TRACE();
00162     return(   ( m_baseInverse == b.m_baseInverse )
00163           &&  ( m_animation   == b.m_animation   )
00164           &&  ( m_weight      == b.m_weight      ) );
00165   }
00166
00172   class SkinnedTriangles : public Triangles
00173   {
00174     public:
00184       typedef struct
00185       {
00186         std::vector<Bone> m_bones;
00187         nvmath::Vec3f     m_normal;
00188         nvmath::Vec3f     m_vertex;
00189       } Skin;
00190
00191     public:
00193       NVSG_API SkinnedTriangles();
00194
00196       NVSG_API SkinnedTriangles( const Triangles &rhs );
00197
00199       NVSG_API SkinnedTriangles( const SkinnedTriangles &rhs );
00200
00202       NVSG_API virtual ~SkinnedTriangles();
00203
00207       NVSG_API virtual bool isDataShared() const;
00208
00212       NVSG_API virtual DataID getDataID() const;
00213
00222       NVSG_API void setAnimationFrame( unsigned int frame, bool calculateTangentSpace );
00223
00230       NVSG_API unsigned int getNumberOfSkins() const;
00231
00235       NVSG_API const Skin * getSkins() const;
00236
00245       NVSG_API void setSkins( const SkinnedTriangles::Skin * skins, unsigned int numSkins );
00246
00262       NVSG_API void setSkins( unsigned int pos, const SkinnedTriangles::Skin * skins, unsigned int numSkins );
00263
00269       NVSG_API SkinnedTriangles & operator=(const SkinnedTriangles & rhs);
00270
00280       NVSG_API virtual bool isEquivalent( const Object * p
00281                                         , bool ignoreNames
00282                                         , bool deepCompare ) const;
00283
00289       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00290
00293       NVSG_API virtual bool containsAnimation() const;
00294
00298       NVSG_API void evaluateAnimation();
00299
00300     private:
00301       nvutil::RCPtr<nvutil::RCVector<Skin> >  m_skins; // sharable skins
00302   };
00303
00304   // - - - - - - - - - - - - - - - - - - - - - - - - -
00305   // inlines
00306   // - - - - - - - - - - - - - - - - - - - - - - - - -
00307
00308   inline unsigned int SkinnedTriangles::getNumberOfSkins()  const
00309   {
00310     NVSG_TRACE();
00311     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00312     NVSG_ASSERT( m_skins->size() <= UINT_MAX );
00313     return( static_cast<unsigned int>(m_skins->size()) );
00314   }
00315
00316   inline const SkinnedTriangles::Skin * SkinnedTriangles::getSkins()  const
00317   {
00318     NVSG_TRACE();
00319     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00320     return( &(*m_skins)[0] );
00321   }
00322
00323 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


SmoothTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvtraverser/Traverser.h"

Include dependency graph for SmoothTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:18 2008 for NVSGSDK by NVIDIA


SmoothTraverser.h Source File

SmoothTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvtraverser/Traverser.h"
00017
00018 namespace nvsg
00019 {
00020   class IndependentPrimitiveSet;
00021 }
00022
00023 namespace nvtraverser
00024 {
00025   class DestrippingTraverser;
00026
00028
00030   class SmoothTraverser : public ExclusiveTraverser
00031   {
00032     public:
00034       NVSG_API SmoothTraverser(void);
00035
00037       NVSG_API void  setCreaseAngle( float creaseAngle );
00038
00039     protected:
00041       NVSG_API virtual ~SmoothTraverser(void);
00042
00044       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00045
00047
00048       NVSG_API virtual void  handleGeoNode( nvsg::GeoNode *p
00049                                           );
00050
00052       NVSG_API virtual void  handleQuads( nvsg::Quads *p
00053                                         );
00054
00056       NVSG_API virtual void  handleTriangles( nvsg::Triangles *p
00057                                             );
00058
00059 #if !defined(NDEBUG)
00060
00061
00062       NVSG_API virtual void  handleQuadStrips( nvsg::QuadStrips *p
00063                                              );
00064
00066
00067       NVSG_API virtual void  handleTriFans( nvsg::TriFans *p
00068                                           );
00069
00071
00072       NVSG_API virtual void  handleTriStrips( nvsg::TriStrips *p
00073                                             );
00074 #endif
00075
00076     private:
00077       void  handleIndependentPrimitiveSet( nvsg::IndependentPrimitiveSet *p, unsigned int primitiveSize );
00078
00079     private:
00080       float                                     m_creaseAngle;
00081       DestrippingTraverser                    * m_destrippingTraverser;
00082       std::vector<nvsg::PrimitiveSetHandle *>   m_primitiveSets;
00083   };
00084 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Spherent.h File Reference

#include "Vecnt.h"

Include dependency graph for Spherent.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvmath

Detailed Description

Generated on Tue Jan 15 10:28:18 2008 for NVSGSDK by NVIDIA


Spherent.h Source File

Spherent.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "Vecnt.h"
00016
00017 namespace nvmath
00018 {
00023   template<unsigned int n, typename T> class Spherent
00024   {
00025     public:
00029       Spherent();
00030
00034       Spherent( const Vecnt<n,T> &center, T radius );
00035
00036     public:
00040       const Vecnt<n,T> & getCenter() const;
00041
00046       T getRadius() const;
00047
00051       void invalidate();
00052
00058       T operator()( const Vecnt<n,T> &p ) const;
00059
00063       void setCenter( const Vecnt<n,T> &center );
00064
00068       void setRadius( T radius );
00069
00070     private:
00071       Vecnt<n,T>  m_center;
00072       T           m_radius;
00073   };
00074
00075   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00076   // non-member functions
00077   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00078
00084   template<unsigned int n, typename T>
00085     Spherent<n,T> boundingSphere( const Vecnt<n,T> * points, unsigned int numberOfPoints );
00086
00093   template<unsigned int n, typename T>
00094     Spherent<n,T> boundingSphere( const Vecnt<n,T> * points, const unsigned int * indices
00095                                 , unsigned int numberOfIndices );
00096
00103   template<unsigned int n, typename T>
00104     Spherent<n,T> boundingSphere( const Vecnt<n,T> * points
00105                                 , const std::vector<unsigned int> * strips
00106                                 , unsigned int numberOfStrips );
00107
00114   template<unsigned int n, typename T>
00115     Spherent<n,T> boundingSphere( const Spherent<n,T> & s, const Vecnt<n,T> & p );
00116
00123   template<unsigned int n, typename T>
00124     Spherent<n,T> boundingSphere( const Spherent<n,T> & s0, const Spherent<n,T> &s1 );
00125
00130   template<unsigned int n, typename T>
00131     Spherent<n,T> intersectingSphere( const Spherent<n,T> & s0, const Spherent<n,T> & s1 );
00132
00137   template<unsigned int n, typename T>
00138     bool isEmpty( const Spherent<n,T> & s );
00139
00146   template<unsigned int n, typename T>
00147     bool operator==( const Spherent<n,T> & s0, const Spherent<n,T> & s1 );
00148
00155   template<unsigned int n, typename T>
00156   bool operator!=( const Spherent<n,T> & s0, const Spherent<n,T> & s1 );
00157
00158   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00159   // Convenience type definitions
00160   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00161   typedef Spherent<3,float>   Sphere3f;
00162   typedef Spherent<3,double>  Sphere3d;
00163
00164   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00165   // inlined member functions
00166   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00167   template<unsigned int n, typename T>
00168   inline Spherent<n,T>::Spherent()
00169     : m_center(0.0f,0.0f,0.0f)
00170     , m_radius(-1.0f)
00171   {
00172   }
00173
00174   template<unsigned int n, typename T>
00175   inline Spherent<n,T>::Spherent( const Vecnt<n,T> &center, T radius )
00176     : m_center(center)
00177     , m_radius(radius)
00178   {
00179   }
00180
00181   template<unsigned int n, typename T>
00182   inline const Vecnt<n,T> & Spherent<n,T>::getCenter() const
00183   {
00184     return( m_center );
00185   }
00186
00187   template<unsigned int n, typename T>
00188   inline T Spherent<n,T>::getRadius() const
00189   {
00190     return( m_radius );
00191   }
00192
00193   template<unsigned int n, typename T>
00194   inline void Spherent<n,T>::invalidate()
00195   {
00196     m_radius = T(-1);
00197   }
00198
00199   template<unsigned int n, typename T>
00200   inline T Spherent<n,T>::operator()( const Vecnt<n,T> &p ) const
00201   {
00202     return( distance( m_center, p ) - m_radius );
00203   }
00204
00205   template<unsigned int n, typename T>
00206   inline void Spherent<n,T>::setCenter( const Vecnt<n,T> &center )
00207   {
00208     m_center = center;
00209   }
00210
00211   template<unsigned int n, typename T>
00212   inline void Spherent<n,T>::setRadius( T radius )
00213   {
00214     m_radius = radius;
00215   }
00216
00217   template<unsigned int n, typename T>
00218   inline Spherent<n,T> boundingSphere( const Vecnt<n,T> * points, unsigned int numberOfPoints )
00219   {
00220     NVSG_ASSERT( points );
00221     //  determine the bounding box
00222     Vecnt<n,T> bbox[2];
00223     bbox[0] = points[0];
00224     bbox[1] = points[0];
00225     for ( unsigned int i=1 ; i<numberOfPoints ; i++ )
00226     {
00227       for ( unsigned int j=0 ; j<n ; j++ )
00228       {
00229         if ( points[i][j] < bbox[0][j] )
00230         {
00231           bbox[0][j] = points[i][j];
00232         }
00233         else if ( bbox[1][j] < points[i][j] )
00234         {
00235           bbox[1][j] = points[i][j];
00236         }
00237       }
00238     }
00239
00240     //  take the center of the bounding box as the center of the bounding sphere
00241     Vecnt<n,T> center = T(0.5) * ( bbox[0] + bbox[1] );
00242
00243     //  and determine the minimal radius needed from that center points
00244     T minRadius(0);
00245     for ( unsigned int i=0 ; i<numberOfPoints ; i++ )
00246     {
00247       T d = lengthSquared( points[i] - center );
00248       if ( minRadius < d )
00249       {
00250         minRadius = d;
00251       }
00252     }
00253     return( Spherent<n,T>( center, sqrt( minRadius ) ) );
00254   }
00255
00256   template<unsigned int n, typename T>
00257   Spherent<n,T> boundingSphere( const Vecnt<n,T> * points, const unsigned int * indices
00258                               , unsigned int numberOfIndices )
00259   {
00260     NVSG_ASSERT( points && indices );
00261     //  determine the bounding box
00262     Vecnt<n,T> bbox[2];
00263     bbox[0] = points[indices[0]];
00264     bbox[1] = points[indices[0]];
00265     for ( unsigned int i=1 ; i<numberOfIndices ; i++ )
00266     {
00267       unsigned int idx = indices[i];
00268       for ( unsigned int j=0 ; j<n ; j++ )
00269       {
00270         if ( points[idx][j] < bbox[0][j] )
00271         {
00272           bbox[0][j] = points[idx][j];
00273         }
00274         else if ( bbox[1][j] < points[idx][j] )
00275         {
00276           bbox[1][j] = points[idx][j];
00277         }
00278       }
00279     }
00280
00281     //  take the center of the bounding box as the center of the bounding sphere
00282     Vecnt<n,T> center = T(0.5) * ( bbox[0] + bbox[1] );
00283
00284     //  and determine the minimal radius needed from that center points
00285     T minRadius(0);
00286     for ( unsigned int i=0 ; i<numberOfIndices ; i++ )
00287     {
00288       T d = lengthSquared( points[indices[i]] - center );
00289       if ( minRadius < d )
00290       {
00291         minRadius = d;
00292       }
00293     }
00294     return( Spherent<n,T>( center, sqrt( minRadius ) ) );
00295   }
00296
00297   template<unsigned int n, typename T>
00298   Spherent<n,T> boundingSphere( const Vecnt<n,T> * points
00299                               , const std::vector<unsigned int> * strips
00300                               , unsigned int numberOfStrips )
00301   {
00302     NVSG_ASSERT( points && strips );
00303     //  determine the bounding box
00304     Vecnt<n,T> bbox[2];
00305     bbox[0] = points[strips[0][0]];
00306     bbox[1] = points[strips[0][0]];
00307     for ( unsigned int i=0 ; i<numberOfStrips ; i++ )
00308     {
00309       for ( size_t j=0 ; j<strips[i].size() ; j++ )
00310       {
00311         unsigned int idx = strips[i][j];
00312         for ( unsigned int k=0 ; k<n ; k++ )
00313         {
00314           if ( points[idx][k] < bbox[0][k] )
00315           {
00316             bbox[0][k] = points[idx][k];
00317           }
00318           else if ( bbox[1][k] < points[idx][k] )
00319           {
00320             bbox[1][k] = points[idx][k];
00321           }
00322         }
00323       }
00324     }
00325
00326     //  take the center of the bounding box as the center of the bounding sphere
00327     Vecnt<n,T> center = T(0.5) * ( bbox[0] + bbox[1] );
00328
00329     //  and determine the minimal radius needed from that center points
00330     T minRadius = 0.0f;
00331     for ( unsigned int i=0 ; i<numberOfStrips ; i++ )
00332     {
00333       for ( size_t j=0 ; j<strips[i].size() ; j++ )
00334       {
00335         T d = lengthSquared( points[strips[i][j]] - center );
00336         if ( minRadius < d )
00337         {
00338           minRadius = d;
00339         }
00340       }
00341     }
00342     return( Spherent<n,T>( center, sqrt( minRadius ) ) );
00343   }
00344
00345   template<unsigned int n, typename T>
00346   Spherent<n,T> boundingSphere( const Spherent<n,T> & s, const Vecnt<n,T> & p )
00347   {
00348     Vecnt<n,T> center(s.getCenter());
00349     T radius(s.getRadius());
00350     if ( ! isEmpty( s ) )
00351     {
00352       T dist = distance( center, p );
00353       if ( radius < dist )
00354       {
00355         //  the point is outside the sphere
00356         //  the new center is a weighted sum of the old and the point
00357         center = ( ( dist + radius ) * center + ( dist - radius ) * p ) / ( 2 * dist );
00358         //  and the new radius is half the sum of the distance and the radius
00359         radius = T(0.5) * ( radius + dist );
00360       }
00361     }
00362     return( Spherent<n,T>( center, radius ) );
00363   }
00364
00365   template<unsigned int n, typename T>
00366   Spherent<n,T> boundingSphere( const Spherent<n,T> & s0, const Spherent<n,T> & s1 )
00367   {
00368     Spherent<n,T> s;
00369     if ( isEmpty( s0 ) )
00370     {
00371       s = s1;
00372     }
00373     else if ( isEmpty( s1 ) )
00374     {
00375       s = s0;
00376     }
00377     else
00378     {
00379       T dist = distance( s0.getCenter(), s1.getCenter() );
00380       if ( dist + s1.getRadius() <= s0.getRadius() )
00381       {
00382         //  s1 is completely inside of s0, so return s0
00383         s = s0;
00384       }
00385       else if ( dist + s0.getRadius() <= s1.getRadius() )
00386       {
00387         //  s0 is completely inside of s1, so return s1
00388         s = s1;
00389       }
00390       else
00391       {
00392         //  the spheres don't include each other
00393         if ( dist < std::numeric_limits<T>::epsilon() )
00394         {
00395           //  the centers are too close together to calculate the weighted sum, so just take the
00396           //  center of them (knowing, that the radii also have to be close together; see above)
00397           s.setCenter( 0.5f * ( s0.getCenter() + s1.getCenter() ) );
00398           s.setRadius( 0.5f * dist + std::max( s0.getRadius(), s1.getRadius() ) );
00399         }
00400         else
00401         {
00402           //  the new center is a weighted sum of the two given
00403           s.setCenter( (  ( dist + s0.getRadius() - s1.getRadius() ) * s0.getCenter()
00404                         + ( dist + s1.getRadius() - s0.getRadius() ) * s1.getCenter() ) / ( 2 * dist ) );
00405           //  and the new center is half the sum of the distance and the radii
00406           s.setRadius( T(0.5) * ( s0.getRadius() + dist + s1.getRadius() ) );
00407         }
00408       }
00409     }
00410     return( s );
00411   }
00412
00413   template<unsigned int n, typename T>
00414   Spherent<n,T> intersectingSphere( const Spherent<n,T> & s0, const Spherent<n,T> & s1 )
00415   {
00416     Vecnt<n,T> v = s1.getCenter() - s0.getCenter();
00417     T d = v.normalize();
00418     Spherent<n,T> s;   //  the default constructor of a Spherent<n,T> creates an empty sphere
00419     if ( d < ( s0.getRadius() + s1.getRadius() ) )
00420     {
00421       //  the spheres do intersect
00422       T ds = d * d;
00423       T r0s = square( s0.getRadius() );
00424       T r1s = square( s1.getRadius() );
00425       if ( ( ds + r0s ) <= r1s )
00426       {
00427         //  s0 is inside of s1 => intersection is s0
00428         s = s0;
00429       }
00430       else if ( ( ds + r1s ) <= r0s )
00431       {
00432         //  s1 is inside of s0 => intersection is s1
00433         s = s1;
00434       }
00435       else
00436       {
00437         //  nontrivial intersection here
00438         T e = ( ds + r0s - r1s ) / ( 2 * d );
00439         s.setRadius( sqrt( r0s - e*e ) );
00440         s.setCenter( s0.getCenter() + e * v );
00441       }
00442     }
00443     return( s );
00444   }
00445
00446   template<unsigned int n, typename T>
00447   inline bool isEmpty( const Spherent<n,T> & s )
00448   {
00449     return( s.getRadius() < 0 );
00450   }
00451
00452   template<unsigned int n, typename T>
00453   bool operator==( const Spherent<n,T> & s0, const Spherent<n,T> & s1 )
00454   {
00455     return(   ( s0.getCenter() == s1.getCenter() )
00456           &&  abs( s0.getRadius() - s1.getRadius() ) < std::numeric_limits<T>::epsilon() );
00457   }
00458
00459   template<unsigned int n, typename T>
00460   bool operator!=( const Spherent<n,T> & s0, const Spherent<n,T> & s1 )
00461   {
00462     return( ! ( s0 == s1 ) );
00463   }
00464
00466 //  extern NVSG_API const Sphere3f cUnitSphere;
00467
00468 } // namespace nvmath
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


SpotLight.h File Reference

#include "nvsgcommon.h"
#include "nvsg/LightSource.h"

Include dependency graph for SpotLight.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:19 2008 for NVSGSDK by NVIDIA


SpotLight.h Source File

SpotLight.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/LightSource.h"
00017
00018 namespace nvsg
00019 {
00040   class SpotLight : public LightSource
00041   {
00042     public:
00043
00046       NVSG_API SpotLight();
00047
00055       NVSG_API SpotLight( const LightSource &rhs );
00056
00059       NVSG_API SpotLight( const SpotLight &rhs );
00060
00063       NVSG_API virtual ~SpotLight();
00064
00069       NVSG_API const nvmath::Vec3f & getPosition() const;
00070
00075       NVSG_API void setPosition( const nvmath::Vec3f & position );
00076
00081       NVSG_API nvmath::Vec3f getDirection() const;
00082
00088       NVSG_API void setDirection( const nvmath::Vec3f & direction );
00089
00095       NVSG_API const nvmath::Quatf & getOrientation() const;
00096
00102       NVSG_API void setOrientation( const nvmath::Quatf & orientation );
00103
00110       NVSG_API bool isAttenuated() const;
00111
00122       NVSG_API void  getAttenuation( float &c
00123                                    , float &l
00124                                    , float &q ) const;
00125
00135       NVSG_API const nvmath::Vec3f& getAttenuation() const;
00136
00147       NVSG_API void setAttenuation( float c
00148                                   , float l
00149                                   , float q );
00150
00160       NVSG_API void setAttenuation( const nvmath::Vec3f &attenuation );
00161
00167       NVSG_API float getCutoffAngle() const;
00168
00174       NVSG_API void setCutoffAngle( float ca );
00175
00181       NVSG_API float getFalloffExponent() const;
00182
00188       NVSG_API void setFalloffExponent( float fe );
00189
00196       NVSG_API SpotLight & operator=(const SpotLight & rhs);
00197
00208       NVSG_API virtual bool isEquivalent( const Object * p
00209                                         , bool ignoreNames
00210                                         , bool deepCompare ) const;
00211
00212     private:
00213       nvmath::Vec3f m_attenuation;
00214       float         m_cutoffAngle;
00215       float         m_falloffExponent;
00216   };
00217
00218   inline  const nvmath::Vec3f&  SpotLight::getAttenuation()  const
00219   {
00220     NVSG_TRACE();
00221     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00222     return m_attenuation;
00223   }
00224
00225   inline  void  SpotLight::getAttenuation( float &c, float &l, float &q )  const
00226   {
00227     NVSG_TRACE();
00228     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00229     c = m_attenuation[0];
00230     l = m_attenuation[1];
00231     q = m_attenuation[2];
00232   }
00233
00234   inline  float SpotLight::getCutoffAngle()  const
00235   {
00236     NVSG_TRACE();
00237     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00238     return( m_cutoffAngle );
00239   }
00240
00241   inline  float SpotLight::getFalloffExponent()  const
00242   {
00243     NVSG_TRACE();
00244     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00245     return( m_falloffExponent );
00246   }
00247
00248   inline  bool  SpotLight::isAttenuated()  const
00249   {
00250     NVSG_TRACE();
00251     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00252     return(   ( m_attenuation[0] != 1.0f )
00253           ||  ( m_attenuation[1] != 0.0f )
00254           ||  ( m_attenuation[2] != 0.0f )
00255           );
00256   }
00257
00258   inline  void  SpotLight::setAttenuation( float c, float l, float q )
00259   {
00260     NVSG_TRACE();
00261     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00262     if ( ( m_attenuation[0] != c ) || ( m_attenuation[1] != l ) || ( m_attenuation[2] != q ) )
00263     {
00264       m_attenuation[0] = c;
00265       m_attenuation[1] = l;
00266       m_attenuation[2] = q;
00267       invalidateIncarnation();
00268     }
00269   }
00270
00271   inline void SpotLight::setAttenuation( const nvmath::Vec3f & attenuation )
00272   {
00273     NVSG_TRACE();
00274     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00275     if ( m_attenuation != attenuation )
00276     {
00277       m_attenuation = attenuation;
00278       invalidateIncarnation();
00279     }
00280   }
00281
00282   inline  void  SpotLight::setCutoffAngle( float ca )
00283   {
00284     NVSG_TRACE();
00285     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00286     if ( m_cutoffAngle != ca )
00287     {
00288       m_cutoffAngle = ca;
00289       invalidateIncarnation();
00290     }
00291   }
00292
00293   inline  void  SpotLight::setFalloffExponent( float fe )
00294   {
00295     NVSG_TRACE();
00296     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00297     if ( m_falloffExponent != fe )
00298     {
00299       m_falloffExponent = fe;
00300       invalidateIncarnation();
00301     }
00302   }
00303
00304   inline nvmath::Vec3f SpotLight::getDirection() const
00305   {
00306     NVSG_TRACE();
00307     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00308     return nvmath::Vec3f (0.f, 0.f, -1.f) * m_trafo.getOrientation();
00309   }
00310
00311   inline  const nvmath::Vec3f & SpotLight::getPosition() const
00312   {
00313     NVSG_TRACE();
00314     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00315     return m_trafo.getTranslation();
00316   }
00317
00318   inline const nvmath::Quatf & SpotLight::getOrientation() const
00319   {
00320     NVSG_TRACE();
00321     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00322     return m_trafo.getOrientation();
00323   }
00324 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


StateAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/OwnedObject.h"

Include dependency graph for StateAttribute.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:19 2008 for NVSGSDK by NVIDIA


StateAttribute.h Source File

StateAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/OwnedObject.h"
00017
00018 namespace nvsg
00019 {
00025   class StateAttribute : public OwnedObject<StatePassHandle>
00026   {
00027     friend class StatePass;
00028
00029     public:
00031       NVSG_API virtual ~StateAttribute( void );
00032
00042       NVSG_API virtual bool isTransparent( void ) const;
00043
00047       NVSG_API void invalidateTransparencyContainment( void );
00048
00049     protected:
00052       NVSG_API StateAttribute( void );
00053
00058       NVSG_API StateAttribute(const StateAttribute& rhs);
00059
00065       NVSG_API StateAttribute & operator=(const StateAttribute & rhs);
00066
00076       NVSG_API void invalidateContainment( unsigned int mask );
00077
00078     protected:
00079       mutable unsigned int  m_flags; // state flags visible to all derived
00080   };
00081 } //  namespace nvsg
00082
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


StatePass.h File Reference

#include "nvsgcommon.h"
#include "nvsg/OwnedObject.h"
#include "nvutil/BitMask.h"

Include dependency graph for StatePass.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:19 2008 for NVSGSDK by NVIDIA


StatePass.h Source File

StatePass.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/OwnedObject.h" // base class definition
00017 #include "nvutil/BitMask.h"
00018
00019 namespace nvsg
00020 {
00026   class StatePass : public OwnedObject<StateVariantHandle>
00027   {
00028     friend class StateVariant;
00029
00030     public:
00033       NVSG_API StatePass();
00034
00037       NVSG_API StatePass( const Object &rhs );
00038
00040       NVSG_API StatePass( const StatePass& rhs );
00041
00043       NVSG_API virtual ~StatePass();
00044
00048       NVSG_API unsigned int getNumberOfAttributes() const;
00049
00057       NVSG_API StateAttributeHandle * getAttribute( unsigned int index ) const;
00058
00064       NVSG_API StateAttributeHandle * getAttributeByObjectCode( unsigned int objectCode ) const;
00065
00070       NVSG_API unsigned int getAttributeIndex( StateAttributeHandle * attribute ) const;
00071
00079       NVSG_API void addAttribute( StateAttributeHandle * attribute );
00080
00087       NVSG_API void removeAttribute( unsigned int index );
00088
00093       NVSG_API void removeAttribute( StateAttributeHandle * attribute );
00094
00100       NVSG_API void removeAttributeByObjectCode( unsigned int objectCode );
00101
00107       NVSG_API bool isTransparent() const;
00108
00113       NVSG_API void invalidateTransparencyContainment();
00114
00119       NVSG_API bool containsCgFx() const;
00120
00125       NVSG_API void invalidateCgFxContainment();
00126
00134       NVSG_API StatePass & operator=(const StatePass & rhs);
00135
00149       NVSG_API virtual bool isEquivalent( const Object * p
00150                                         , bool ignoreNames
00151                                         , bool deepCompare ) const;
00152
00158       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00159
00169       NVSG_API void invalidateContainment( unsigned int mask );
00170
00171     private:
00172       void invalidateCaches( StateAttributeHandle *attribute, bool insert );
00173
00174     private:
00175       typedef std::vector<StateAttributeHandle*>::const_iterator ConstAttributeIterator;
00176       typedef std::vector<StateAttributeHandle*>::iterator AttributeIterator;
00177       std::vector<StateAttributeHandle *> m_attribs;
00178
00179       mutable unsigned int  m_flags;
00180   };
00181
00182   inline unsigned int StatePass::getNumberOfAttributes() const
00183   {
00184     NVSG_TRACE();
00185     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00186     NVSG_ASSERT( m_attribs.size() <= UINT_MAX );
00187     return( static_cast<unsigned int>(m_attribs.size()) );
00188   }
00189
00190   inline StateAttributeHandle * StatePass::getAttribute( unsigned int index ) const
00191   {
00192     NVSG_TRACE();
00193     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00194     NVSG_ASSERT( index < m_attribs.size() );
00195     return( m_attribs[index] );
00196   }
00197
00198   inline unsigned int StatePass::getAttributeIndex( StateAttributeHandle * attribute ) const
00199   {
00200     NVSG_TRACE();
00201     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00202     std::vector<StateAttributeHandle*>::const_iterator ai =
00203       std::find( m_attribs.begin(), m_attribs.end(), attribute );
00204     NVSG_ASSERT( ( ai == m_attribs.end() ) || ( ( ai - m_attribs.begin() ) <= UINT_MAX ) );
00205     return( ( ai != m_attribs.end() ) ? static_cast<unsigned int>(ai - m_attribs.begin()) : ~0 );
00206   }
00207
00208 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


StateSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/OwnedObject.h"
#include "nvsg/StateVariant.h"
#include "nvutil/BitMask.h"

Include dependency graph for StateSet.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:20 2008 for NVSGSDK by NVIDIA


StateSet.h Source File

StateSet.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/OwnedObject.h" // base class definition
00017 #include "nvsg/StateVariant.h"
00018 #include "nvutil/BitMask.h"
00019
00020 namespace nvsg
00021 {
00022   class Node;
00023
00024   typedef unsigned int VariantKey;
00025
00026   // shared state flag defines
00027   enum
00028   {
00029     SF_CONTAINS_CGFX                 = BIT0,
00030     SF_CONTAINS_CGFX_VALID           = BIT1,
00031     SF_CONTAINS_TRANSPARENCY         = BIT2,
00032     SF_CONTAINS_TRANSPARENCY_VALID   = BIT3,
00033
00034     SF_CONTAINS_MASK        = SF_CONTAINS_CGFX | SF_CONTAINS_TRANSPARENCY,
00035     SF_CONTAINS_VALID_MASK  = SF_CONTAINS_MASK << 1
00036   };
00037
00056   class VariantIterator
00057   {
00058     friend class StateSet;
00059
00060     public:
00064       bool operator!=( VariantIterator it ) const;
00065
00069       bool operator==( VariantIterator it ) const;
00070
00071     private:
00072       typedef std::map<VariantKey, StateVariantHandle *> container_type;
00073       typedef container_type::const_iterator             wrapped_type;
00074       typedef wrapped_type::pointer                      pointer;
00075       typedef wrapped_type::reference                    reference;
00076
00077       VariantIterator();
00078       explicit VariantIterator(wrapped_type it);
00079       pointer operator->() const { return m_iter.operator->(); }
00080       reference operator*() const { return m_iter.operator*(); }
00081       VariantIterator& operator++() { ++m_iter; return *this; } // preincrement
00082       VariantIterator operator++(int) { return VariantIterator(m_iter++); } // postincrement
00083       operator wrapped_type() const { return m_iter; } // implicit conversion to wrapped_type
00084     private:
00085       wrapped_type m_iter;
00086   };
00087
00088   inline VariantIterator::VariantIterator()
00089   : m_iter()
00090   {
00091   }
00092
00093   inline VariantIterator::VariantIterator( wrapped_type it )
00094   : m_iter(it)
00095   {
00096   }
00097
00098   inline bool VariantIterator::operator!=( VariantIterator it ) const
00099   {
00100     return m_iter!=it.m_iter;
00101   }
00102
00103   inline bool VariantIterator::operator==( VariantIterator it ) const
00104   {
00105     return m_iter==it.m_iter;
00106   }
00107
00114   class StateSet : public OwnedObject<NodeHandle>
00115   {
00116     friend class Node;
00117
00118     public:
00119       static const VariantKey INVALID_VARIANT_KEY = 0xFFFFFFFF;
00120
00123       NVSG_API StateSet();
00124
00127       NVSG_API StateSet( const Object &rhs );
00128
00130       NVSG_API StateSet( const StateSet& rhs );
00131
00133       NVSG_API virtual ~StateSet();
00134
00138       NVSG_API unsigned int getNumberOfVariants() const;
00139
00143       NVSG_API VariantIterator getFirstVariantIterator() const;
00144
00149       NVSG_API VariantIterator getNextVariantIterator( VariantIterator it ) const;
00150
00154       NVSG_API VariantIterator getLastVariantIterator() const;
00155
00161       NVSG_API StateVariantHandle * getActiveVariant() const;
00162
00168       NVSG_API StateVariantHandle * getVariant( VariantKey key ) const;
00169
00175       NVSG_API StateVariantHandle * getVariant( VariantIterator it ) const;
00176
00182       NVSG_API VariantKey getVariantKey( VariantIterator it ) const;
00183
00190       NVSG_API VariantKey getActiveVariantKey() const;
00191
00197       NVSG_API void setActiveVariantKey( VariantKey key );
00198
00208       NVSG_API void addVariant( StateVariantHandle * variant
00209                               , VariantKey key );
00210
00216       NVSG_API void removeVariant( VariantKey key );
00217
00225       NVSG_API void replaceVariant( VariantKey key
00226                                   , StateVariantHandle * variant );
00227
00234       NVSG_API void replaceVariantKey( VariantKey oldKey
00235                                      , VariantKey newKey );
00236
00243       NVSG_API unsigned int getNumberOfPasses( VariantKey key = 0 ) const;
00244
00256       NVSG_API StatePassHandle * getPass( unsigned int passIndex
00257                                         , VariantKey key = 0 ) const;
00258
00266       NVSG_API void addPass( StatePassHandle * pass
00267                            , VariantKey key = 0 );
00268
00279       NVSG_API void removePass( unsigned int passIndex, VariantKey key = 0 );
00280
00293       NVSG_API void replacePass( StatePassHandle * pass, unsigned int passIndex, VariantKey key = 0 );
00294
00304       NVSG_API unsigned int getNumberOfAttributes( unsigned int passIndex = 0, VariantKey key = 0 ) const;
00305
00319       NVSG_API StateAttributeHandle * getAttribute( unsigned int attributeIndex
00320                                                   , unsigned int passIndex = 0
00321                                                   , VariantKey key = 0 ) const;
00322
00337       NVSG_API StateAttributeHandle * getAttributeByObjectCode( unsigned int objectCode
00338                                                               , unsigned int passIndex = 0
00339                                                               , VariantKey key = 0 ) const;
00340
00354       NVSG_API unsigned int getAttributeIndex( StateAttributeHandle * attribute
00355                                              , unsigned int passIndex = 0
00356                                              , VariantKey key = 0 ) const;
00357
00372       NVSG_API void addAttribute( StateAttributeHandle * attribute
00373                                 , unsigned int passIndex = 0
00374                                 , VariantKey key = 0 );
00375
00389       NVSG_API void removeAttribute( unsigned int attributeIndex
00390                                    , unsigned int passIndex = 0
00391                                    , VariantKey key = 0 );
00392
00404       NVSG_API void removeAttribute( StateAttributeHandle * attribute
00405                                    , unsigned int passIndex = 0
00406                                    , VariantKey key = 0 );
00407
00420       NVSG_API void removeAttributeByObjectCode( unsigned int objectCode
00421                                                , unsigned int passIndex = 0
00422                                                , VariantKey key = 0 );
00423
00429       NVSG_API bool isTransparent() const;
00430
00440       NVSG_API void invalidateContainment( unsigned int mask );
00441
00446       NVSG_API void invalidateTransparencyContainment();
00447
00452       NVSG_API bool containsCgFx() const;
00453
00458       NVSG_API void invalidateCgFxContainment();
00459
00467       NVSG_API StateSet & operator=(const StateSet & rhs);
00468
00482       NVSG_API virtual bool isEquivalent( const Object * p
00483                                         , bool ignoreNames
00484                                         , bool deepCompare ) const;
00485
00491       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00492
00493     private:
00494       VariantKey m_variantKey;
00495       std::map<VariantKey,StateVariantHandle *> m_variants;
00496       mutable unsigned m_flags;
00497   };
00498
00499 #if defined( _DEBUG )
00500   inline bool find( std::map<VariantKey,StateVariantHandle*>::const_iterator it
00501                   , const std::map<VariantKey,StateVariantHandle*> &m )
00502   {
00503     for ( std::map<VariantKey,StateVariantHandle*>::const_iterator i = m.begin() ; i!=m.end() ; ++i )
00504     {
00505       if ( i == it )
00506       {
00507         return( true );
00508       }
00509     }
00510     return( false );
00511   }
00512 #endif
00513
00514   inline VariantKey StateSet::getActiveVariantKey() const
00515   {
00516     NVSG_TRACE();
00517     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00518     return( m_variantKey );
00519   }
00520
00521   inline StateVariantHandle * StateSet::getActiveVariant() const
00522   {
00523     NVSG_TRACE();
00524     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00525     return( getVariant( m_variantKey ) );
00526   }
00527
00528   inline unsigned int StateSet::getNumberOfVariants() const
00529   {
00530     NVSG_TRACE();
00531     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00532     NVSG_ASSERT( m_variants.size() <= UINT_MAX );
00533     return( static_cast<unsigned int>(m_variants.size()) );
00534   }
00535
00536   inline StateVariantHandle * StateSet::getVariant( VariantKey key ) const
00537   {
00538     NVSG_TRACE();
00539     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00540     std::map<VariantKey,StateVariantHandle*>::const_iterator vi=m_variants.find( key );
00541     return( ( vi != m_variants.end() ) ? vi->second : NULL );
00542   }
00543
00544   inline VariantIterator StateSet::getFirstVariantIterator() const
00545   {
00546     NVSG_TRACE();
00547     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00548     return( VariantIterator(m_variants.begin()) );
00549   }
00550
00551   inline VariantIterator StateSet::getNextVariantIterator( VariantIterator it ) const
00552   {
00553     NVSG_TRACE();
00554     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00555     return( VariantIterator(++it) );
00556   }
00557
00558   inline VariantIterator StateSet::getLastVariantIterator() const
00559   {
00560     NVSG_TRACE();
00561     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00562     return( VariantIterator(m_variants.end()) );
00563   }
00564
00565   inline StateVariantHandle * StateSet::getVariant( VariantIterator it ) const
00566   {
00567     NVSG_TRACE();
00568     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00569 #if defined( _DEBUG )
00570     NVSG_ASSERT( find( it, m_variants ) );
00571 #endif
00572     return( it->second );
00573   }
00574
00575   inline VariantKey StateSet::getVariantKey( VariantIterator it ) const
00576   {
00577     NVSG_TRACE();
00578     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00579 #if defined( _DEBUG )
00580     NVSG_ASSERT( find( it, m_variants ) );
00581 #endif
00582     return( it->first );
00583   }
00584
00585   inline unsigned int StateSet::getNumberOfPasses( VariantKey key ) const
00586   {
00587     NVSG_TRACE();
00588     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00589     std::map<VariantKey,StateVariantHandle*>::const_iterator vi=m_variants.find( key );
00590     if ( vi != m_variants.end() )
00591     {
00592       nvutil::ReadableObject<StateVariant> v(vi->second);
00593       return v->getNumberOfPasses();
00594     }
00595     return 0;
00596   }
00597
00598   inline StatePassHandle * StateSet::getPass( unsigned int passIndex, VariantKey key ) const
00599   {
00600     NVSG_TRACE();
00601     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00602     std::map<VariantKey,StateVariantHandle*>::const_iterator vi=m_variants.find( key );
00603     NVSG_ASSERT( vi != m_variants.end() );
00604     nvutil::ReadableObject<StateVariant> v(vi->second);
00605     return v->getPass(passIndex);
00606   }
00607
00608   inline unsigned int StateSet::getNumberOfAttributes( unsigned int passIndex, VariantKey key ) const
00609   {
00610     NVSG_TRACE();
00611     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00612     std::map<VariantKey,StateVariantHandle*>::const_iterator vi = m_variants.find( key );
00613     if ( vi != m_variants.end() )
00614     {
00615       nvutil::ReadableObject<StateVariant> v(vi->second);
00616       return v->getNumberOfAttributes(passIndex);
00617     }
00618     return 0;
00619   }
00620
00621   inline StateAttributeHandle * StateSet::getAttribute( unsigned int attributeIndex, unsigned int passIndex, VariantKey key ) const
00622   {
00623     NVSG_TRACE();
00624     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00625     std::map<VariantKey,StateVariantHandle*>::const_iterator vi=m_variants.find( key );
00626     NVSG_ASSERT( vi != m_variants.end() );
00627     nvutil::ReadableObject<StateVariant> v(vi->second);
00628     return v->getAttribute( attributeIndex, passIndex );
00629   }
00630
00631   inline StateAttributeHandle * StateSet::getAttributeByObjectCode( unsigned int objectCode, unsigned int passIndex, VariantKey key ) const
00632   {
00633     NVSG_TRACE();
00634     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00635     std::map<VariantKey,StateVariantHandle*>::const_iterator vi=m_variants.find( key );
00636     NVSG_ASSERT( vi != m_variants.end() );
00637     nvutil::ReadableObject<StateVariant> v(vi->second);
00638     return( v->getAttributeByObjectCode( objectCode, passIndex ) );
00639   }
00640
00641   inline unsigned int StateSet::getAttributeIndex( StateAttributeHandle * attribute, unsigned int passIndex, VariantKey key ) const
00642   {
00643     NVSG_TRACE();
00644     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00645     std::map<VariantKey,StateVariantHandle*>::const_iterator vi=m_variants.find( key );
00646     NVSG_ASSERT( vi != m_variants.end() );
00647     nvutil::ReadableObject<StateVariant> v(vi->second);
00648     return( v->getAttributeIndex( attribute, passIndex ) );
00649   }
00650
00651 } //  namespace nvsg
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


StateVariant.h File Reference

#include "nvsgcommon.h"
#include "nvsg/OwnedObject.h"
#include "nvsg/StatePass.h"

Include dependency graph for StateVariant.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:20 2008 for NVSGSDK by NVIDIA


StateVariant.h Source File

StateVariant.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/OwnedObject.h"
00017 #include "nvsg/StatePass.h"
00018
00019 namespace nvsg
00020 {
00021   class StateSet;
00022
00029   class StateVariant : public OwnedObject<StateSetHandle>
00030   {
00031     friend class StateSet;
00032
00033     public:
00036       NVSG_API StateVariant();
00037
00040       NVSG_API StateVariant( const Object &rhs );
00041
00043       NVSG_API StateVariant( const StateVariant& rhs );
00044
00046       NVSG_API virtual ~StateVariant();
00047
00051       NVSG_API unsigned int getNumberOfPasses() const;
00052
00059       NVSG_API StatePassHandle * getPass( unsigned int index ) const;
00060
00065       NVSG_API void addPass( StatePassHandle * pass );
00066
00071       NVSG_API void removePass( StatePassHandle * pass );
00072
00079       NVSG_API void removePass( unsigned int passIndex );
00080
00089       NVSG_API void replacePass( StatePassHandle * pass, unsigned int index );
00090
00097       NVSG_API unsigned int getNumberOfAttributes( unsigned int passIndex = 0 ) const;
00098
00110       NVSG_API StateAttributeHandle * getAttribute( unsigned int attributeIndex
00111                                                   , unsigned int passIndex = 0 ) const;
00112
00123       NVSG_API StateAttributeHandle * getAttributeByObjectCode( unsigned int objectCode
00124                                                               , unsigned int passIndex = 0 ) const;
00125
00135       NVSG_API unsigned int getAttributeIndex( StateAttributeHandle * attribute
00136                                              , unsigned int passIndex = 0 ) const;
00137
00149       NVSG_API void addAttribute( StateAttributeHandle * attribute
00150                                 , unsigned int passIndex = 0 );
00151
00162       NVSG_API void removeAttribute( unsigned int attributeIndex, unsigned int passIndex = 0 );
00163
00171       NVSG_API void removeAttribute( StateAttributeHandle * attribute, unsigned int passIndex = 0 );
00172
00181       NVSG_API void removeAttributeByObjectCode( unsigned int objectCode, unsigned int passIndex );
00182
00188       NVSG_API bool isTransparent() const;
00189
00193       NVSG_API bool isEachPassTransparent() const;
00194
00199       NVSG_API void invalidateTransparencyContainment();
00200
00205       NVSG_API bool containsCgFx() const;
00206
00211       NVSG_API void invalidateCgFxContainment();
00212
00220       NVSG_API StateVariant & operator=( const StateVariant & rhs );
00221
00234       NVSG_API virtual bool isEquivalent( const Object * p
00235                                         , bool ignoreNames
00236                                         , bool deepCompare ) const;
00237
00243       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00244
00254       NVSG_API void invalidateContainment( unsigned int mask );
00255
00256     private:
00257       typedef std::vector<StatePassHandle*>::const_iterator ConstPassIterator;
00258       typedef std::vector<StatePassHandle*>::iterator PassIterator;
00259       std::vector<StatePassHandle *>  m_passes;
00260
00261       mutable unsigned int  m_flags;
00262   };
00263
00264   inline unsigned int StateVariant::getNumberOfPasses() const
00265   {
00266     NVSG_TRACE();
00267     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00268     NVSG_ASSERT( m_passes.size() <= UINT_MAX );
00269     return( static_cast<unsigned int>(m_passes.size()) );
00270   }
00271
00272   inline StatePassHandle * StateVariant::getPass( unsigned int passIndex ) const
00273   {
00274     NVSG_TRACE();
00275     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00276     NVSG_ASSERT( passIndex < m_passes.size() );
00277     return( m_passes[passIndex] );
00278   }
00279
00280   inline unsigned int StateVariant::getNumberOfAttributes( unsigned int passIndex ) const
00281   {
00282     NVSG_TRACE();
00283     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00284     if ( passIndex < m_passes.size() )
00285     {
00286       nvutil::ReadableObject<StatePass> pass(m_passes[passIndex]);
00287       return pass->getNumberOfAttributes();
00288     }
00289     return 0;
00290   }
00291
00292   inline StateAttributeHandle * StateVariant::getAttribute( unsigned int attributeIndex, unsigned int passIndex ) const
00293   {
00294     NVSG_TRACE();
00295     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00296     NVSG_ASSERT( passIndex < m_passes.size() );
00297     nvutil::ReadableObject<StatePass> pass(m_passes[passIndex]);
00298     return pass->getAttribute(attributeIndex);
00299   }
00300
00301   inline StateAttributeHandle * StateVariant::getAttributeByObjectCode( unsigned int objectCode, unsigned int passIndex ) const
00302   {
00303     NVSG_TRACE();
00304     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00305     NVSG_ASSERT( passIndex < m_passes.size() );
00306     nvutil::ReadableObject<StatePass> pass(m_passes[passIndex]);
00307     return pass->getAttributeByObjectCode(objectCode);
00308   }
00309
00310   inline unsigned int StateVariant::getAttributeIndex( StateAttributeHandle * attribute, unsigned int passIndex ) const
00311   {
00312     NVSG_TRACE();
00313     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00314     NVSG_ASSERT( passIndex < m_passes.size() );
00315     nvutil::ReadableObject<StatePass> pass(m_passes[passIndex]);
00316     return pass->getAttributeIndex(attribute);
00317   }
00318
00319   inline void StateVariant::removeAttribute( unsigned int attributeIndex, unsigned int passIndex )
00320   {
00321     NVSG_TRACE();
00322     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00323     NVSG_ASSERT( passIndex < m_passes.size() );
00324     nvutil::WritableObject<StatePass> sp(m_passes[passIndex]);
00325     sp->removeAttribute(attributeIndex);
00326   }
00327
00328   inline void StateVariant::removeAttribute( StateAttributeHandle * attribute, unsigned int passIndex )
00329   {
00330     NVSG_TRACE();
00331     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00332     NVSG_ASSERT( passIndex < m_passes.size() );
00333     nvutil::WritableObject<StatePass> sp(m_passes[passIndex]);
00334     sp->removeAttribute(attribute);
00335   }
00336
00337   inline void StateVariant::removeAttributeByObjectCode( unsigned int objectCode, unsigned int passIndex )
00338   {
00339     NVSG_TRACE();
00340     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00341     NVSG_ASSERT( passIndex < m_passes.size() );
00342     nvutil::WritableObject<StatePass> sp(m_passes[passIndex]);
00343     sp->removeAttributeByObjectCode(objectCode);
00344   }
00345
00346 } //  namespace nvsg
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


StrippedPrimitiveSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/PrimitiveSet.h"
#include "nvsg/nvsg.h"

Include dependency graph for StrippedPrimitiveSet.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:21 2008 for NVSGSDK by NVIDIA


StrippedPrimitiveSet.h Source File

StrippedPrimitiveSet.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/PrimitiveSet.h"
00017 #include "nvsg/nvsg.h"
00018
00019 namespace nvsg
00020 {
00027   class StrippedPrimitiveSet : public PrimitiveSet
00028   {
00029     public:
00031       NVSG_API virtual ~StrippedPrimitiveSet( void );
00032
00042       NVSG_API virtual bool isDataShared( void ) const;
00043
00051       NVSG_API virtual DataID getDataID( void ) const;
00052
00056       NVSG_API bool hasStrips( void )  const;
00057
00061       NVSG_API unsigned int getNumberOfStrips( void ) const;
00062
00066       NVSG_API const IndexSet * getStrips() const;
00067
00075       NVSG_API void setStrips( const IndexSet * strips, unsigned int numStrips );
00076
00093       NVSG_API void setStrips( unsigned int pos, const IndexSet * strips, unsigned int numStrips );
00094
00105       NVSG_API virtual bool isEquivalent( const Object * p
00106                                         , bool ignoreNames
00107                                         , bool deepCompare
00108                                         ) const;
00109
00110     protected:
00115       NVSG_API StrippedPrimitiveSet( void );
00116
00122       NVSG_API StrippedPrimitiveSet( const StrippedPrimitiveSet& rhs );
00123
00128       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00129
00134       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00135
00141       NVSG_API StrippedPrimitiveSet & operator=(const StrippedPrimitiveSet & rhs);
00142
00143     private:
00144       nvutil::RCPtr<nvutil::RCVector<IndexSet> > m_strips;
00145   };
00146
00147
00148   // - - - - - - - - - - - - - - - - - - - - - - - - -
00149   // inlines
00150   // - - - - - - - - - - - - - - - - - - - - - - - - -
00151
00152   inline bool StrippedPrimitiveSet::hasStrips()  const
00153   {
00154     return( !m_strips->empty() );
00155   }
00156
00157   inline unsigned int StrippedPrimitiveSet::getNumberOfStrips()  const
00158   {
00159     NVSG_ASSERT( m_strips->size() <= UINT_MAX );
00160     return( static_cast<unsigned int>(m_strips->size()) );
00161   }
00162
00163   inline const IndexSet * StrippedPrimitiveSet::getStrips( void ) const
00164   {
00165     NVSG_TRACE();
00166     return( &(*m_strips)[0] );
00167   }
00168 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


StrippingTraverser.h File Reference

#include <list>
#include <set>
#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/Face.h"
#include "nvsg/IndependentPrimitiveSet.h"
#include "nvtraverser/Traverser.h"

Include dependency graph for StrippingTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:21 2008 for NVSGSDK by NVIDIA


StrippingTraverser.h Source File

StrippingTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <list>
00016 #include <set>
00017 #include "nvsgcommon.h"
00018 #include "nvsg/nvsg.h"
00019 #include "nvsg/Face.h"
00020 #include "nvsg/IndependentPrimitiveSet.h"
00021 #include "nvtraverser/Traverser.h"
00022
00023 namespace nvtraverser
00024 {
00025
00027
00029   class StrippingTraverser : public ExclusiveTraverser
00030   {
00031     public:
00033       NVSG_API StrippingTraverser(void);
00034
00036
00037       void  getMinimalLengths( unsigned int &triStripLength, unsigned int &quadStripLength ) const;
00038
00040
00041       void  setMinimalLengths( unsigned int triStripLength, unsigned int quadStripLength );
00042
00043     protected:
00045       NVSG_API virtual ~StrippingTraverser(void);
00046
00048       NVSG_API virtual void  handleGeoNode( nvsg::GeoNode *p );
00049
00051       NVSG_API virtual void handleQuads( nvsg::Quads *p );
00052
00054       NVSG_API virtual void handleTriangles( nvsg::Triangles *p );
00055
00057       NVSG_API virtual void handleAnimatedVertexAttributeSet( nvsg::AnimatedVertexAttributeSet * p );
00058
00060       NVSG_API virtual void handleSkin( nvsg::Skin * p );
00061
00062     private:
00063       void    addQuadStrip( const std::list<unsigned int> &vertexList, std::vector<nvsg::IndexSet> &strips
00064                           , nvsg::IndexSet &quads );
00065       void    addTriStrip( const std::list<unsigned int> &vertexList, std::vector<nvsg::IndexSet> &strips
00066                           , nvsg::IndexSet &triangles );
00067       void    connectFaces( const unsigned int *indices, unsigned int fi, unsigned int ps
00068                           , unsigned int i0, unsigned int i1
00069                           , const std::vector<std::list<unsigned int> > &verticesToFaceLists
00070                           , std::vector<unsigned int> &faceConnections );
00071       void    copyVertexAttributeData( nvsg::VertexAttributeSetHandle *from
00072                                      , nvsg::VertexAttributeSetHandle *to
00073                                      , std::vector<nvsg::IndexSet> &strips );
00074       void    copyVertexAttributeData( nvsg::VertexAttributeSetHandle *from
00075                                      , nvsg::VertexAttributeSetHandle *to
00076                                      , nvsg::IndexSet &indices );
00077       void    cutConnections( const std::list<unsigned int> &list, unsigned int vpf
00078                             , std::vector<std::set<unsigned int> > &faceSets
00079                             , std::vector<unsigned int> &faceConnections
00080                             , std::vector<unsigned int> &faceConnectionCounts );
00081       void    determineList( const nvsg::Face3 *faces, unsigned int fi, unsigned int le
00082                            , std::list<unsigned int> &faceList
00083                            , const std::vector<unsigned int> &faceConnections
00084                            , std::list<unsigned int> &vertexList );
00085       void    determineList( const nvsg::Face4 *faces, unsigned int fi, unsigned int le
00086                            , std::list<unsigned int> &faceList
00087                            , const std::vector<unsigned int> &faceConnections
00088                            , std::list<unsigned int> &vertexList );
00089       unsigned int getNextFaceIndex( const unsigned int *indices, unsigned int primitiveSize
00090                                    , std::vector<std::set<unsigned int> > &faceSets
00091                                    , nvsg::IndexSet &faces );
00092       void    prepareStripping( const nvsg::IndependentPrimitiveSet *p, unsigned int primitiveSize
00093                               , std::vector<unsigned int> &faceConnections
00094                               , std::vector<unsigned int> &faceConnectionCounts
00095                               , std::vector<std::set<unsigned int> > &faceSets );
00096
00097       std::pair<nvsg::QuadsHandle*,nvsg::QuadStripsHandle*> createQuadStripsFromQuads( nvsg::QuadsHandle *p );
00098       std::pair<nvsg::TrianglesHandle*,nvsg::TriStripsHandle*>    createTriStripsFromTriangles( nvsg::TrianglesHandle *p );
00099
00100     private:
00101       unsigned int  m_minimalQuadStrip;
00102       unsigned int  m_minimalTriStrip;
00103
00104       bool  m_containsComplexVAS;
00105       std::vector<nvsg::QuadsHandle *>    m_quads;
00106       std::vector<nvsg::TrianglesHandle*> m_triangles;
00107       std::map<nvsg::QuadsHandle*,std::pair<nvsg::QuadsHandle*,nvsg::QuadStripsHandle*> >         m_quadsToQuadStrips;
00108       std::map<nvsg::TrianglesHandle*,std::pair<nvsg::TrianglesHandle*,nvsg::TriStripsHandle*> >  m_trianglesToTriStrips;
00109   };
00110
00111   inline  void StrippingTraverser::getMinimalLengths( unsigned int &triStripLength, unsigned int &quadStripLength ) const
00112   {
00113     triStripLength  = m_minimalTriStrip;
00114     quadStripLength = m_minimalQuadStrip;
00115   }
00116
00117   inline  void  StrippingTraverser::setMinimalLengths( unsigned int triStripLength, unsigned int quadStripLength )
00118   {
00119     m_minimalTriStrip   = triStripLength;
00120     m_minimalQuadStrip  = quadStripLength;
00121   }
00122 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Switch.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Group.h"
#include <set>
#include <map>

Include dependency graph for Switch.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:21 2008 for NVSGSDK by NVIDIA


Switch.h Source File

Switch.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h" // stuff commonly required
00016 #include "nvsg/Group.h" // base class definition
00017 // additional dependencies
00018 #include <set>
00019 #include <map>
00020
00021 namespace nvsg
00022 {
00099   class Switch : public Group
00100   {
00101     public:
00102
00105       typedef unsigned int      MaskKey;
00110       typedef std::set<unsigned int>  SwitchMask;
00114       typedef std::map<MaskKey,SwitchMask>::const_iterator MaskIterator;
00118       enum { DEFAULT_MASK_KEY = ~0 };
00119
00122       NVSG_API Switch();
00123
00131       NVSG_API explicit Switch(const Group &rhs);
00132
00135       NVSG_API Switch(const Switch &rhs);
00136
00139       NVSG_API virtual ~Switch();
00140
00144       NVSG_API void setActive();
00145
00152       NVSG_API void setActive(unsigned int index);
00153
00157       NVSG_API void setInactive();
00158
00165       NVSG_API void setInactive(unsigned int index);
00166
00172       NVSG_API unsigned int getNumberOfActive() const;
00173
00181       NVSG_API unsigned int getActive(std::vector<unsigned int>& indices) const;
00182
00188       NVSG_API bool isActive() const;
00189
00195       NVSG_API bool isActive(unsigned int index) const;
00196
00202       NVSG_API Switch & operator=(const Switch & rhs);
00203
00212       NVSG_API virtual bool isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const;
00213
00218       NVSG_API unsigned int getNumberOfMasks() const;
00219
00223       NVSG_API MaskIterator getFirstMaskIterator() const;
00224
00228       NVSG_API MaskIterator getLastMaskIterator() const;
00229
00234       NVSG_API MaskIterator getNextMaskIterator(MaskIterator it) const;
00235
00240       NVSG_API const MaskKey getMaskKey(MaskIterator it) const;
00241
00246       NVSG_API const SwitchMask & getSwitchMask(MaskIterator it) const;
00247
00251       NVSG_API const MaskKey getActiveMask() const;
00252
00258       NVSG_API bool setActiveMask( MaskKey k );
00259
00267       NVSG_API void addMask( MaskKey key, const SwitchMask & sm );
00268
00275       NVSG_API bool removeMask( MaskKey key );
00276
00277     protected:
00280       typedef std::map<MaskKey,SwitchMask>::iterator NonConstMaskIterator;
00284       NVSG_API virtual void init();
00285
00293       NVSG_API virtual void postRemoveChild(unsigned int index);
00294
00302       NVSG_API virtual void postAddChild(unsigned int index);
00303
00308       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00309
00317       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere( void ) const;
00318
00326       NVSG_API virtual unsigned short determineHintsContainment( unsigned short hints ) const;
00327
00338       NVSG_API virtual bool determineTransparencyContainment() const;
00339
00344       NVSG_API virtual bool determineCgFxContainment() const;
00345
00350       NVSG_API virtual bool determineLightContainment() const;
00351
00356       NVSG_API virtual bool determineLODContainment() const;
00357
00362       NVSG_API virtual bool determineVolumeNodeContainment() const;
00363
00364     private:
00366       std::map<MaskKey, SwitchMask>  m_masks;
00367       MaskKey                        m_activeMaskKey;
00368
00369       //
00370       // Internal methods to get the activemask
00371       //
00372       inline const SwitchMask & activeMask() const
00373       {
00374         NVSG_TRACE();
00375         NVSG_ASSERT(m_masks.end()!=m_masks.find(m_activeMaskKey));
00376         return (*m_masks.find(m_activeMaskKey)).second;
00377       }
00378
00379       inline SwitchMask & activeMask()
00380       {
00381         NVSG_TRACE();
00382         return m_masks[ m_activeMaskKey ];
00383       }
00384   };
00385
00386 } //  namespace nvsg
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


SWMRSync.h File Reference

#include "nvsgcommon.h"
#include "nvsgwindefs.h"
#include <windows.h>
#include <winbase.h>
#include <pthread.h>
#include <map>

Include dependency graph for SWMRSync.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:22 2008 for NVSGSDK by NVIDIA


SWMRSync.h Source File

SWMRSync.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #if defined(_WIN32)
00018 # include "nvsgwindefs.h"
00019 # ifndef NOMINMAX
00020 #  define NOMINMAX // avoid problems with Microsoft definitions in windef.h and min/max from stl
00021 # endif
00022 # include <windows.h>
00023 # include <winbase.h>
00024 # undef NOMINMAX
00025 #endif
00026
00027 #if defined(LINUX)
00028 # include <pthread.h>
00029 #endif
00030
00031 #include <map>
00032
00034 namespace nvutil
00035 {
00036 #if defined(_WIN32)
00037   typedef CRITICAL_SECTION SWMRCriticalSection;
00038 #elif defined(LINUX)
00039   typedef pthread_mutex_t  SWMRCriticalSection;
00040 #endif
00041
00045   NVSG_API extern void EnableLocking();
00046
00053   class SWMRSync
00054   {
00055     public:
00058       NVSG_API SWMRSync();
00059
00063       NVSG_API SWMRSync( const SWMRSync & rhs );
00064
00067       NVSG_API ~SWMRSync(void);
00068
00075       NVSG_API bool lockExclusive()   const;
00076
00081       NVSG_API void unlockExclusive() const;
00082
00089       NVSG_API bool lockShared()      const;
00090
00095       NVSG_API void unlockShared()    const;
00096
00097     private:
00098       void init() const; // general lazy initialization
00099       void initLocking() const; // lazy initialization when locking was requested
00100       void enterCriticalSection() const;
00101       void leaveCriticalSection() const;
00102       void yield()                const; // offers concurrent threads to resume
00103
00104       // lock/unlock workers will be called through
00105       // the below pointers to member functions
00106       bool lockExclusiveInit() const; // performs one-time initialization
00107       bool lockExclusiveLock() const; // locks the object for exclusive access
00108       void unlockExclusiveUnlock() const; // releases the object from exclusive access
00109       bool lockExclusiveNOP() const; // NOP - invoked in single-threaded configurations
00110       void unlockExclusiveNOP() const; // dito
00111       bool lockSharedInit() const; // performs one-time initialization
00112       bool lockSharedLock() const; // locks the object for shared access
00113       void unlockSharedUnlock() const; // releases shared lock
00114       bool lockSharedNOP() const; // NOP - invoked in single-threaded configurations
00115       void unlockSharedNOP() const; // dito
00116
00117       // access lock/unlock functions through these pointers
00118       mutable bool (SWMRSync::*m_pfnLockExclusive)() const;
00119       mutable void (SWMRSync::*m_pfnUnlockExclusive)() const;
00120       mutable bool (SWMRSync::*m_pfnLockShared)() const;
00121       mutable void (SWMRSync::*m_pfnUnlockShared)() const;
00122
00123       mutable SWMRCriticalSection m_cs; // thread synchronization object
00124       mutable bool m_lockingInitialized; // ensures one time initialization of synchronization object
00125
00126       mutable int m_sharedLockCount; // counts concurrent readers
00127                                      // accessed only when inside critical section
00128
00129     // debug helper
00130 #if !defined(NDEBUG)
00131       void DBG_INCR_THREADS_SHARED_LOCK_CNT() const;
00132       void DBG_DECR_THREADS_SHARED_LOCK_CNT() const;
00133       int  DBG_GET_THREADS_SHARED_LOCK_CNT()  const;
00134 #if defined(_WIN32)
00135       typedef std::map<DWORD,int> SWMRPerThreadSharedLockCountMap;
00136 #elif defined(LINUX)
00137       typedef std::map<pthread_t,int> SWMRPerThreadSharedLockCountMap;
00138 #endif
00139       // accessed only when inside critical section
00140       mutable SWMRPerThreadSharedLockCountMap m_perThreadSharedLockCount;
00141 #else
00142 # define DBG_INCR_THREADS_SHARED_LOCK_CNT() static_cast<void*>(0)
00143 # define DBG_DECR_THREADS_SHARED_LOCK_CNT() static_cast<void*>(0)
00144 # define DBG_GET_THREADS_SHARED_LOCK_CNT()  static_cast<void*>(0)
00145 #endif // !NDEBUG
00146   };
00147
00148   class AutoLock
00149   {
00150   public:
00151     explicit AutoLock(const SWMRSync& lock) : m_lock(lock)
00152     {
00153       m_lock.lockExclusive();
00154     }
00155
00156     ~AutoLock()
00157     {
00158       m_lock.unlockExclusive();
00159     }
00160
00161   private:
00162     // don't permit copying and assignment
00163     AutoLock(const AutoLock&);
00164     AutoLock& operator=(const AutoLock&);
00165
00166     const SWMRSync& m_lock; // reference to the lock object passed at instantiation
00167   };
00168
00169   inline bool SWMRSync::lockExclusive() const
00170   {
00171     NVSG_TRACE();
00172     return (this->*m_pfnLockExclusive)();
00173   }
00174
00175   inline void SWMRSync::unlockExclusive() const
00176   {
00177     NVSG_TRACE();
00178     (this->*m_pfnUnlockExclusive)();
00179   }
00180
00181   inline bool SWMRSync::lockShared() const
00182   {
00183     NVSG_TRACE();
00184     return (this->*m_pfnLockShared)();
00185   }
00186
00187   inline void SWMRSync::unlockShared () const
00188   {
00189     NVSG_TRACE();
00190     (this->*m_pfnUnlockShared)();
00191   }
00192
00193   inline void SWMRSync::enterCriticalSection() const
00194   {
00195 #if defined(_WIN32)
00196       EnterCriticalSection(&m_cs);
00197 #elif defined(LINUX)
00198       pthread_mutex_lock(&m_cs);
00199 #endif
00200   }
00201
00202   inline void SWMRSync::leaveCriticalSection() const
00203   {
00204 #if defined(_WIN32)
00205       LeaveCriticalSection(&m_cs);
00206 #elif defined(LINUX)
00207       pthread_mutex_unlock(&m_cs);
00208 #endif
00209   }
00210
00211   inline void SWMRSync::yield() const
00212   {
00213 #if defined(_WIN32)
00214       Sleep(0);
00215 #elif defined(LINUX)
00216       sched_yield();
00217 #endif
00218   }
00219 } // namespace nvutil
00220
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TextureAttribute.h File Reference

#include <map>
#include <string>
#include "nvsgcommon.h"
#include "nvmath/Trafo.h"
#include "nvsg/StateAttribute.h"
#include "nvsg/TextureImage.h"

Include dependency graph for TextureAttribute.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:22 2008 for NVSGSDK by NVIDIA


TextureAttribute.h Source File

TextureAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <map>    // uses std::map
00016 #include <string> // uses std::string
00017 #include "nvsgcommon.h"
00018 #include "nvmath/Trafo.h" // uses Trafo
00019 #include "nvsg/StateAttribute.h" // base class definition
00020 #include "nvsg/TextureImage.h" // base class definition
00021
00022
00023 namespace nvsg
00024 {
00025
00027   typedef enum
00028   {
00029     TCA_S = 0
00030   , TCA_T
00031   , TCA_R
00032   , TCA_Q
00033   } TexCoordAxis;
00034
00036   typedef enum
00037   {
00038     TEM_REPLACE = 0
00039   , TEM_MODULATE
00040   , TEM_DECAL
00041   , TEM_BLEND
00042   , TEM_ADD
00043   , TEM_ADD_SIGNED
00044   , TEM_SUBTRACT
00045   , TEM_INTERPOLATE
00046   , TEM_DOT3_RGB
00047   , TEM_DOT3_RGBA
00048   } TextureEnvMode;
00049
00051   typedef enum
00052   {
00053     TES_1X = 1
00054   , TES_2X = 2
00055   , TES_4X = 4
00056   } TextureEnvScale;
00057
00059   typedef enum
00060   {
00061     TGM_OFF           = -1
00062   , TGM_OBJECT_LINEAR
00063   , TGM_EYE_LINEAR
00064   , TGM_SPHERE_MAP
00065   , TGM_REFLECTION_MAP
00066   , TGM_NORMAL_MAP
00067   } TexGenMode;
00068
00070   typedef enum
00071   {
00072     TGLP_OBJECT = 0
00073   , TGLP_EYE
00074   , TGLP_OBJECT_AND_EYE
00075   } TexGenLinearPlane;
00076
00078   typedef enum
00079   {
00080     TWCA_S = 0
00081   , TWCA_T
00082   , TWCA_R
00083   } TexWrapCoordAxis;
00084
00086   typedef enum
00087   {
00088     TWM_REPEAT = 0
00089   , TWM_CLAMP
00090   , TWM_MIRROR_REPEAT
00091   , TWM_CLAMP_TO_EDGE
00092   , TWM_CLAMP_TO_BORDER
00093   , TWM_MIRROR_CLAMP
00094   , TWM_MIRROR_CLAMP_TO_EDGE
00095   , TWM_MIRROR_CLAMP_TO_BORDER
00096   } TextureWrapMode;
00097
00099   typedef enum
00100   {
00101     TFM_MIN_NEAREST = 0
00102   , TFM_MIN_LINEAR
00103   , TFM_MIN_BILINEAR = TFM_MIN_LINEAR
00104   , TFM_MIN_LINEAR_MIPMAP_LINEAR
00105   , TFM_MIN_TRILINEAR = TFM_MIN_LINEAR_MIPMAP_LINEAR
00106   , TFM_MIN_NEAREST_MIPMAP_NEAREST
00107   , TFM_MIN_NEAREST_MIPMAP_LINEAR
00108   , TFM_MIN_LINEAR_MIPMAP_NEAREST
00109   } TextureMinFilterMode;
00110
00112   typedef enum
00113   {
00114     TFM_MAG_NEAREST = 0
00115   , TFM_MAG_LINEAR
00116   , TFM_MAG_BILINEAR = TFM_MAG_LINEAR
00117   } TextureMagFilterMode;
00118
00119   class TextureAttributeItem;
00120   class TextureImage;
00121
00123   class TextureAttributeItemData : public nvutil::RCObject
00124   {
00125       friend class TextureAttributeItem;
00126     public:
00128
00129       NVSG_API TextureAttributeItemData(const TextureAttributeItemData& rhs);
00130
00131     private:
00132       // instantiation on stack is not permitted.
00133       TextureAttributeItemData();
00134       ~TextureAttributeItemData();
00135       // assignment also not permitted
00136       TextureAttributeItemData& operator=(const TextureAttributeItemData& rhs) {}
00137
00138       TextureTarget         m_textureTarget;
00139       nvmath::Vec4f         m_borderColor;
00140       nvmath::Vec4f         m_envColor;
00141       TextureEnvMode        m_envMode;            // enum environment mode to use with rasterization
00142       TextureEnvScale       m_envScale;           // enum environment scale to use with rasterization
00143       TextureMagFilterMode  m_magFilterMode;
00144       TextureMinFilterMode  m_minFilterMode;
00145       nvmath::Trafo         m_trafo;              // texture coordinate transformation
00146       TextureWrapMode       m_wrapMode[3];
00147       TexGenMode            m_texGenMode[4];
00148       nvmath::Vec4f         m_texGenPlane[2][4];
00149   };
00150
00152
00157   class TextureAttributeItem : public OwnedObject<TextureAttributeHandle>
00158   {
00159     friend class TextureAttribute;
00160
00161   public:
00194     NVSG_API TextureAttributeItem( void );
00195
00204     NVSG_API TextureAttributeItem( const Object &rhs );
00205
00219     NVSG_API TextureAttributeItem( const TextureAttributeItem& rhs );
00220
00230     NVSG_API virtual ~TextureAttributeItem();
00231
00233
00234     NVSG_API virtual bool isDataShared( void ) const;
00235
00237
00238     NVSG_API virtual DataID getDataID( void ) const;
00239
00249     NVSG_API TextureImageHandle * getTextureImage() const;
00250
00256     NVSG_API void setTextureImage(TextureImageHandle * texImg);
00257
00262     NVSG_API const std::string& getTextureFileName() const;
00263
00269     NVSG_API TextureTarget getTextureTarget() const;
00270
00279     NVSG_API void setTextureTarget(TextureTarget target);
00280
00284     NVSG_API const nvmath::Vec4f& getBorderColor( void ) const;
00285
00291     NVSG_API void setBorderColor( const nvmath::Vec4f &color );
00292
00296     NVSG_API const nvmath::Vec4f& getEnvColor( void ) const;
00297
00308     NVSG_API void setEnvColor( const nvmath::Vec4f &color );
00309
00313     NVSG_API TextureEnvMode getEnvMode( void ) const;
00314
00322     NVSG_API void setEnvMode( TextureEnvMode mode );
00323
00327     NVSG_API TextureEnvScale getEnvScale( void ) const;
00328
00337     NVSG_API void setEnvScale( TextureEnvScale scale );
00338
00342     NVSG_API TextureMagFilterMode getMagFilterMode( void ) const;
00343
00350     NVSG_API void setMagFilterMode( TextureMagFilterMode mode );
00351
00355     NVSG_API TextureMinFilterMode getMinFilterMode( void ) const;
00356
00367     NVSG_API void setMinFilterMode( TextureMinFilterMode mode );
00368
00371     NVSG_API bool isMipmapped( TextureMinFilterMode mode ) const;
00372
00378     NVSG_API TextureWrapMode getWrapMode( TexWrapCoordAxis target ) const;
00379
00390     NVSG_API void setWrapMode( TexWrapCoordAxis target , TextureWrapMode mode);
00391
00399     NVSG_API nvmath::Mat44f getMatrix( void ) const;
00400
00404     NVSG_API const nvmath::Quatf & getOrientation( void ) const;
00405
00411     NVSG_API void setOrientation( const nvmath::Quatf & orientation );
00412
00416     NVSG_API const nvmath::Vec3f & getScaling( void ) const;
00417
00423     NVSG_API void setScaling( const nvmath::Vec3f &scale );
00424
00428     NVSG_API const nvmath::Vec3f & getTranslation( void ) const;
00429
00435     NVSG_API void setTranslation( const nvmath::Vec3f &translation );
00436
00455     NVSG_API void setTexGenMode( TexCoordAxis axis, TexGenMode mode );
00456
00462     NVSG_API TexGenMode getTexGenMode( TexCoordAxis axis ) const;
00463
00491     NVSG_API void setTexGenLinearPlane( TexCoordAxis axis, TexGenLinearPlane target, const nvmath::Vec4f& plane );
00492
00502     NVSG_API const nvmath::Vec4f &getTexGenLinearPlane( TexCoordAxis axis, TexGenLinearPlane plane ) const;
00503
00518     NVSG_API TextureAttributeItem & operator=(const TextureAttributeItem & rhs);
00519
00531     NVSG_API virtual bool isEquivalent( const Object *p, bool ignoreNames, bool deepCompare ) const;
00532
00533   private:
00534       void checkIncrementMipmapUseCount(); // conditional incrementation of mipmap use count
00535       void checkDecrementMipmapUseCount(); // conditional decrementation of mipmap use count
00536
00537   private:
00538       nvutil::RCPtr<TextureAttributeItemData>   m_sharedData;
00539       TextureImageHandle * m_texImg; // texture image specification
00540   };
00541
00543
00550   class TextureAttribute : public StateAttribute
00551   {
00552     public:
00564       enum { INVALID_ITEM = ~0 }; // note: used with unsigned comparison, so don't use -1
00565
00602       NVSG_API TextureAttribute( void );
00603
00612       NVSG_API TextureAttribute( const StateAttribute &rhs );
00613
00618       NVSG_API TextureAttribute( const TextureAttribute& rhs );
00619
00629       NVSG_API virtual ~TextureAttribute( void );
00630
00641       NVSG_API void bindTextureAttributeItem( TextureAttributeItemHandle* item, unsigned int unit );
00642
00650       NVSG_API void unbindTextureAttributeItem( unsigned int unit );
00651
00684       NVSG_API unsigned int getFirstItem( void ) const;
00685
00694       NVSG_API unsigned int getNextItem( unsigned int unit ) const;
00695
00706       NVSG_API unsigned int getNumberOfItems( void ) const;
00707
00712       NVSG_API TextureAttributeItemHandle * getTextureAttributeItem( unsigned int unit ) const;
00713
00725       NVSG_API TextureAttribute & operator=(const TextureAttribute & rhs);
00726
00744       NVSG_API virtual bool isEquivalent( const Object *p, bool ignoreNames, bool deepCompare ) const;
00745
00746       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00747
00748     private: // implementation helpers
00749       void _clearBindings();
00750
00751     private:
00752       typedef std::map<unsigned int, TextureAttributeItemHandle*>::const_iterator ConstBindingIterator;
00753       typedef std::map<unsigned int, TextureAttributeItemHandle*>::iterator BindingIterator;
00754       std::map<unsigned int, TextureAttributeItemHandle*> m_bindings; // item bindings
00755   };
00756
00757   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - TextureAttribute
00758   inline unsigned int TextureAttribute::getFirstItem( void ) const
00759   {
00760     NVSG_TRACE();
00761     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00762     return !m_bindings.empty() ? m_bindings.begin()->first : INVALID_ITEM;
00763   }
00764
00765   inline unsigned int TextureAttribute::getNextItem( unsigned int currItem ) const
00766   {
00767     NVSG_TRACE();
00768     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00769     if (currItem!=INVALID_ITEM)
00770     {
00771       ConstBindingIterator ci = m_bindings.upper_bound(currItem);
00772       return ci!=m_bindings.end() ? ci->first : INVALID_ITEM;
00773     }
00774     return INVALID_ITEM;
00775   }
00776
00777   inline unsigned int TextureAttribute::getNumberOfItems( void ) const
00778   {
00779     NVSG_TRACE();
00780     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00781     NVSG_ASSERT( m_bindings.size() <= UINT_MAX );
00782     return( static_cast<unsigned int>(m_bindings.size()) );
00783   }
00784
00785   inline TextureAttributeItemHandle* TextureAttribute::getTextureAttributeItem( unsigned int unit ) const
00786   {
00787     NVSG_TRACE();
00788     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00789     ConstBindingIterator ci = m_bindings.find(unit);
00790     return ci!=m_bindings.end() ? (*ci).second : NULL;
00791   }
00792
00793   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - TextureAttributeItem
00794   inline TextureImageHandle * TextureAttributeItem::getTextureImage() const
00795   {
00796     NVSG_TRACE();
00797     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00798     return m_texImg;
00799   }
00800
00801   inline TextureTarget TextureAttributeItem::getTextureTarget() const
00802   {
00803     NVSG_TRACE();
00804     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00805     return m_sharedData->m_textureTarget;
00806   }
00807
00808   inline const nvmath::Vec4f& TextureAttributeItem::getBorderColor( void ) const
00809   {
00810     NVSG_TRACE();
00811     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00812     return( m_sharedData->m_borderColor );
00813   }
00814
00815   inline const nvmath::Vec4f & TextureAttributeItem::getEnvColor( void ) const
00816   {
00817     NVSG_TRACE();
00818     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00819     return( m_sharedData->m_envColor );
00820   }
00821
00822   inline void TextureAttributeItem::setEnvColor( const nvmath::Vec4f & envColor )
00823   {
00824     NVSG_TRACE();
00825     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00826     if ( m_sharedData->m_envColor != envColor )
00827     {
00828       nvutil::writeAccess(m_sharedData);
00829       m_sharedData->m_envColor = envColor;
00830       invalidateIncarnation();
00831     }
00832   }
00833
00834   inline TextureEnvMode TextureAttributeItem::getEnvMode( void ) const
00835   {
00836     NVSG_TRACE();
00837     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00838     return( m_sharedData->m_envMode );
00839   }
00840
00841   inline TextureEnvScale TextureAttributeItem::getEnvScale( void ) const
00842   {
00843     NVSG_TRACE();
00844     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00845     return( m_sharedData->m_envScale );
00846   }
00847
00848   inline TextureWrapMode TextureAttributeItem::getWrapMode( TexWrapCoordAxis target ) const
00849   {
00850     NVSG_TRACE();
00851     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00852     NVSG_ASSERT(target==TWCA_S||target==TWCA_T||target==TWCA_R);
00853     return( m_sharedData->m_wrapMode[target] );
00854   }
00855
00856   inline TextureMinFilterMode TextureAttributeItem::getMinFilterMode( void ) const
00857   {
00858     NVSG_TRACE();
00859     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00860     return( m_sharedData->m_minFilterMode );
00861   }
00862
00863   inline bool TextureAttributeItem::isMipmapped( TextureMinFilterMode mode ) const
00864   {
00865     NVSG_TRACE();
00866     NVSG_ASSERT(mode == TFM_MIN_NEAREST ||
00867                 mode == TFM_MIN_LINEAR ||
00868                 mode == TFM_MIN_LINEAR_MIPMAP_LINEAR ||
00869                 mode == TFM_MIN_NEAREST_MIPMAP_NEAREST ||
00870                 mode == TFM_MIN_NEAREST_MIPMAP_LINEAR ||
00871                 mode == TFM_MIN_LINEAR_MIPMAP_NEAREST);
00872     return !( mode == TFM_MIN_LINEAR || mode == TFM_MIN_NEAREST );
00873   }
00874
00875   inline TextureMagFilterMode TextureAttributeItem::getMagFilterMode( void ) const
00876   {
00877     NVSG_TRACE();
00878     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00879     return( m_sharedData->m_magFilterMode );
00880   }
00881
00882   inline  nvmath::Mat44f  TextureAttributeItem::getMatrix( void ) const
00883   {
00884     NVSG_TRACE();
00885     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00886     return( m_sharedData->m_trafo.getMatrix() );
00887   }
00888
00889   inline const nvmath::Quatf & TextureAttributeItem::getOrientation( void ) const
00890   {
00891     NVSG_TRACE();
00892     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00893     return( m_sharedData->m_trafo.getOrientation() );
00894   }
00895
00896   inline const nvmath::Vec3f & TextureAttributeItem::getScaling( void ) const
00897   {
00898     NVSG_TRACE();
00899     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00900     return( m_sharedData->m_trafo.getScaling() );
00901   }
00902
00903   inline const nvmath::Vec3f & TextureAttributeItem::getTranslation( void ) const
00904   {
00905     NVSG_TRACE();
00906     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00907     return( m_sharedData->m_trafo.getTranslation() );
00908   }
00909
00910   inline TexGenMode TextureAttributeItem::getTexGenMode( TexCoordAxis axis ) const
00911   {
00912     NVSG_TRACE();
00913     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00914     return( m_sharedData->m_texGenMode[axis] );
00915   }
00916
00917   inline const nvmath::Vec4f &TextureAttributeItem::getTexGenLinearPlane( TexCoordAxis axis, TexGenLinearPlane target ) const
00918   {
00919     NVSG_TRACE();
00920     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00921     NVSG_ASSERT(target==TGLP_OBJECT || target==TGLP_EYE);
00922     return( m_sharedData->m_texGenPlane[target][axis] );
00923   }
00924 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TextureImage.h File Reference

#include "nvsgcommon.h"
#include "nvsg/DAL.h"
#include "nvsg/CoreTypes.h"
#include "nvmath/nvmath.h"
#include "nvutil/BitMask.h"
#include "nvutil/PlugIn.h"
#include <math.h>
#include <vector>
#include <map>
#include <string>

Include dependency graph for TextureImage.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg

Defines

#define | VERTICAL_CROSS_FORMAT(w, h) ((3*(h))==(4*(w)))
#define | allocImagePixels(nbytes) dbgAllocImagePixels( nbytes, __LINE__)

Detailed Description

Generated on Tue Jan 15 10:28:23 2008 for NVSGSDK by NVIDIA


TextureImage.h Source File

TextureImage.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/DAL.h"
00017 #include "nvsg/CoreTypes.h"
00018 #include "nvmath/nvmath.h"
00019 #include "nvutil/BitMask.h"
00020 #include "nvutil/PlugIn.h"
00021 #include <math.h>
00022 #include <vector>
00023 #include <map>
00024 #include <string>
00025
00026 // VERTICAL_CROSS_FORMAT(w,h) macro evaluates to true if
00027 // width and height comply with vertical cross format:
00028 //
00029 //        ___
00030 //       |   |
00031 // 3  ___|___|____
00032 //   |   |   |    |
00033 // 2 |___|___|____|
00034 //       |   |          3xheight == 4xwidth
00035 // 1     |___|
00036 //       |   |
00037 // 0     |___|
00038 //
00039 //     0   1   2
00040 #define VERTICAL_CROSS_FORMAT(w,h) ((3*(h))==(4*(w)))
00041
00042 namespace nvsg
00043 {
00044   class ScaleFilter;
00045   class TextureLoader;
00046   class TextureImage;
00047
00049   enum TextureTarget
00050   {
00051     NVSG_UNSPECIFIED_TEXTURE_TARGET = ~0,
00052     NVSG_TEXTURE_1D = 0,
00053     NVSG_TEXTURE_2D,
00054     NVSG_TEXTURE_3D,
00055     NVSG_TEXTURE_CUBE,
00056     NVSG_TEXTURE_1D_ARRAY,
00057     NVSG_TEXTURE_2D_ARRAY,
00058     NVSG_TEXTURE_RECTANGLE,
00059     NVSG_TEXTURE_TARGET_COUNT
00060   };
00061
00066   NVSG_API TextureTarget determineTextureTarget(TextureImageHandle * img);
00067
00071   struct Image
00072   {
00075     //
00076     // NOTE WELL: THE ORDERING OF THIS TABLE IS VERY IMPORTANT - DO NOT
00077     // CHANGE THE ORDER OF ANY OF THE VALUES WITHOUT KNOWING EXACTLY WHAT
00078     // YOU ARE GETTING YOURSELF INTO!!
00079     //
00080     // TextureImage.cpp and GLContext.cpp contain dependencies.
00081     //
00082     enum PixelFormat
00083     {
00084         IMG_UNKNOWN_FORMAT = -1
00085       , IMG_COLOR_INDEX = 0
00086       , IMG_RGB
00087       , IMG_RGBA
00088       , IMG_BGR
00089       , IMG_BGRA
00090       , IMG_LUMINANCE
00091                             // luminace and intensity are the same cept for A
00092       , IMG_LUMINANCE_ALPHA
00093
00094       //
00095       // New Formats
00096       //
00097       , IMG_ALPHA
00098
00099       , IMG_DEPTH_COMPONENT
00100       , IMG_DEPTH_STENCIL
00101
00102       // Integer
00103       , IMG_INTEGER_ALPHA
00104       , IMG_INTEGER_LUMINANCE
00105       , IMG_INTEGER_LUMINANCE_ALPHA
00106       , IMG_INTEGER_RGB
00107       , IMG_INTEGER_BGR
00108       , IMG_INTEGER_RGBA
00109       , IMG_INTEGER_BGRA
00110
00111       //
00112       // Compressed texture formats
00113       //
00114       // not really a "Format", but these require Compressed entry
00115       // point because they signify that the data has already been
00116       // compressed
00117       //
00118       , IMG_COMPRESSED_LUMINANCE_LATC1
00119       , IMG_COMPRESSED_SIGNED_LUMINANCE_LATC1
00120       , IMG_COMPRESSED_LUMINANCE_ALPHA_LATC2
00121       , IMG_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2
00122       , IMG_COMPRESSED_RED_RGTC1
00123       , IMG_COMPRESSED_SIGNED_RED_RGTC1
00124       , IMG_COMPRESSED_RG_RGTC2
00125       , IMG_COMPRESSED_SIGNED_RG_RGTC2
00126
00127       , IMG_COMPRESSED_RGB_DXT1
00128       , IMG_COMPRESSED_RGBA_DXT1
00129       , IMG_COMPRESSED_RGBA_DXT3
00130       , IMG_COMPRESSED_RGBA_DXT5
00131
00132       , IMG_COMPRESSED_SRGB_DXT1
00133       , IMG_COMPRESSED_SRGBA_DXT1
00134       , IMG_COMPRESSED_SRGBA_DXT3
00135       , IMG_COMPRESSED_SRGBA_DXT5
00136
00137       , IMG_NUM_FORMATS
00138     };
00139
00141     //
00142     // NOTE WELL: THE ORDERING OF THIS TABLE IS VERY IMPORTANT - DO NOT
00143     // CHANGE THE ORDER OF ANY OF THE VALUES WITHOUT KNOWING EXACTLY WHAT
00144     // YOU ARE GETTING YOURSELF INTO!!
00145     //
00146     // TextureImage.cpp and GLContext.cpp contain dependencies.
00147     //
00148     enum PixelDataType
00149     {
00150         IMG_UNKNOWN_TYPE = -1
00151       , IMG_BYTE = 0
00152       , IMG_UNSIGNED_BYTE
00153       , IMG_SHORT
00154       , IMG_UNSIGNED_SHORT
00155       , IMG_INT
00156       , IMG_UNSIGNED_INT
00157       , IMG_FLOAT32
00158       , IMG_FLOAT16
00159
00160       // custom formats
00161       , IMG_UNSIGNED_INT_2_10_10_10
00162       , IMG_UNSIGNED_INT_5_9_9_9
00163                                     //   (EXT_texture_shared_exponent) format
00164       , IMG_UNSIGNED_INT_10F_11F_11F
00165                                      //   (EXT_packed_float) format
00166       , IMG_UNSIGNED_INT_24_8
00167                                      //   (EXT_packed_depth_stencil) format
00168       , IMG_NUM_TYPES
00169
00170       // compatibility
00171       , IMG_FLOAT = IMG_FLOAT32
00172       , IMG_HALF  = IMG_FLOAT16
00173     };
00174
00175
00178     NVSG_API Image();
00179
00190     NVSG_API Image( unsigned int width, unsigned int height, unsigned int depth
00191                   , PixelFormat format, PixelDataType type );
00192
00193     // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
00194     // NOTE:
00195     // We need the copy constructor performing just a flat copy. That is, the
00196     // copy must not allocate its own pixel storage and copy pixels from the
00197     // source, but have m_pixels pointing to the same storage instead!
00198     //
00199     // This is exactly what a default copy constructor does!
00200     // Therefore, we don't need to implement a copy constructor by our own!
00201     // Same is true for the assignment operator!
00202     // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
00203
00204     unsigned int     m_width;
00205     unsigned int     m_height;
00206     unsigned int     m_depth;
00207     PixelFormat      m_format;
00208     PixelDataType    m_type;
00209     unsigned int     m_bpp;
00210     unsigned int     m_bpl;
00211     unsigned int     m_bps;
00212     unsigned int     m_nob;
00213     unsigned char *  m_pixels;
00214   };
00215
00216 #if defined(NDEBUG)
00217
00223   NVSG_API unsigned char * allocImagePixels( unsigned int nbytes );
00224 #else
00225
00226   NVSG_API unsigned char * dbgAllocImagePixels( unsigned int nbytes, unsigned int line );
00227   // This macro allows the same API usage as in the release mode
00228   #define allocImagePixels(nbytes) dbgAllocImagePixels( nbytes, __LINE__)
00229 #endif
00230
00235   NVSG_API void freeImagePixels( unsigned char * pixels );
00236
00241   NVSG_API unsigned int numberOfComponents( Image::PixelFormat format );
00242
00247   NVSG_API unsigned int sizeOfComponents( Image::PixelDataType type );
00248
00269   NVSG_API void calculateContributions( std::vector<std::vector<std::pair<unsigned int,float> > > &contribs
00270                                       , unsigned int srcSize, unsigned int dstSize
00271                                       , const ScaleFilter * filter );
00272
00284   NVSG_API void insert( const Image * src, Image * dst, unsigned int x, unsigned int y, unsigned int z );
00285
00295   NVSG_API void rescale( const Image * src, Image *dst
00296                        , std::vector<std::vector<std::pair<unsigned int,float> > > *contributions );
00297
00305   NVSG_API void convertPixelFormat( const Image * src, Image *dst, Image::PixelFormat destFormat );
00306
00307 #if !defined(NDEBUG)
00308
00309   NVSG_API void assertMipMapChainComplete(const TextureImage * img);
00310 #else
00311 # define assertMipMapChainComplete(i) static_cast<void*>(0)
00312 #endif
00313
00315   class TextureImage : public nvutil::HandledObject, public DALHostHolder  // can host DAL data
00316   {
00317   public:
00318
00320     //  on the GPU as a texture map
00321     enum TextureGPUFormat
00322     {
00323       TGF_DEFAULT, // TYPICALLY, PICK THE FASTEST FORMAT FOR THE GIVEN DATA
00324
00325       // "generic formats"
00326       TGF_FIXED, // USE A FIXED-POINT GPU FORMAT
00327       TGF_FLOAT, // USE A FLOATING-POINT GPU FORMAT (choose format based on size of float data supplied)
00328       TGF_NONLINEAR, // USE AN SRGB FORMAT (choose SRGB/SRGBA based on the data supplied)
00329       TGF_INTEGER, // USE AN INTEGER FORMAT, BASED ON THE DATA
00330       TGF_COMPRESSED_FIXED, // USE A COMPRESSED FIXED POINT FORMAT
00331                             // (compress on upload)
00332
00333       // some "not so generic" formats
00334       TGF_FLOAT16, // USE 16 BIT PER COMPONENT FLOAT FORMAT
00335       TGF_FLOAT32, // USE 32 BIT PER COMPONENT FLOAT FORMAT
00336
00337       TGF_FIXED8,  // USE an 8 bit per component fixed point format
00338       TGF_FIXED10, // USE a 10 BIT PER COMPONENT FIXED POINT FORMAT (10,10,10,2)
00339       TGF_FIXED16, // USE a 16 bit per component fixed point format
00340
00341       // explicit formats
00342       TGF_ALPHA8,
00343       TGF_ALPHA16,
00344       TGF_SIGNED_ALPHA8,
00345       TGF_SIGNED_ALPHA16,
00346       TGF_LUMINANCE8,
00347       TGF_LUMINANCE16,
00348       TGF_SIGNED_LUMINANCE8,
00349       TGF_SIGNED_LUMINANCE16,
00350       TGF_LUMINANCE8_ALPHA8,
00351       TGF_LUMINANCE16_ALPHA16,
00352       TGF_SIGNED_LUMINANCE8_ALPHA8,
00353       TGF_SIGNED_LUMINANCE16_ALPHA16,
00354       TGF_COMPRESSED_LUMINANCE,
00355       TGF_COMPRESSED_LUMINANCE_ALPHA,
00356
00357       TGF_COMPRESSED_LUMINANCE_LATC,         // ext_texture_compression_latc
00358       TGF_SIGNED_COMPRESSED_LUMINANCE_LATC,
00359       TGF_COMPRESSED_LUMINANCE_ALPHA_LATC,
00360       TGF_SIGNED_COMPRESSED_LUMINANCE_ALPHA_LATC,
00361       TGF_COMPRESSED_RED_RGTC,
00362       TGF_SIGNED_COMPRESSED_RED_RGTC,
00363       TGF_COMPRESSED_RG_RGTC,
00364       TGF_SIGNED_COMPRESSED_RG_RGTC,
00365
00366       TGF_RGB8,
00367       TGF_SIGNED_RGB8,
00368       TGF_RGB16,       // native on G80
00369       TGF_RGBA8,
00370       TGF_SIGNED_RGBA8,
00371       TGF_RGB10,       // native on G80
00372       TGF_RGB10_A2,    // native on G80
00373       TGF_RGBA16,      // native on G80
00374
00375       TGF_SRGB,         // ext_texture_srgb
00376       TGF_SRGBA,
00377       TGF_COMPRESSED_SRGB,
00378       TGF_COMPRESSED_SRGBA,
00379       TGF_COMPRESSED_SRGB_DXT1,
00380       TGF_COMPRESSED_SRGB_DXT3,
00381       TGF_COMPRESSED_SRGB_DXT5,
00382       TGF_COMPRESSED_SRGBA_DXT1,
00383       TGF_COMPRESSED_RGB,
00384       TGF_COMPRESSED_RGBA,
00385       TGF_COMPRESSED_RGB_DXT1,
00386       TGF_COMPRESSED_RGB_DXT3,
00387       TGF_COMPRESSED_RGB_DXT5,
00388       TGF_COMPRESSED_RGBA_DXT1,
00389
00390       TGF_DEPTH16,              // arb_depth_texture
00391       TGF_DEPTH24,
00392       TGF_DEPTH32,
00393
00394       TGF_DEPTH24_STENCIL8,     // EXT_packed_depth_stencil
00395
00396       TGF_LUMINANCE16F,         // arb_texture_float
00397       TGF_LUMINANCE32F,
00398       TGF_LUMINANCE_ALPHA16F,
00399       TGF_LUMINANCE_ALPHA32F,
00400       TGF_RGB16F,
00401       TGF_RGB32F,
00402       TGF_RGBA16F,
00403       TGF_RGBA32F,
00404
00405       TGF_SIGNED_RGB_INTEGER32, // ext_texture_integer - require an integer
00406                                 // PixelDataFormat!
00407       TGF_SIGNED_RGB_INTEGER16,
00408       TGF_SIGNED_RGB_INTEGER8,
00409       TGF_RGB_INTEGER32,
00410       TGF_RGB_INTEGER16,
00411       TGF_RGB_INTEGER8,
00412
00413       TGF_SIGNED_RGBA_INTEGER32,
00414       TGF_SIGNED_RGBA_INTEGER16,
00415       TGF_SIGNED_RGBA_INTEGER8,
00416       TGF_RGBA_INTEGER32,
00417       TGF_RGBA_INTEGER16,
00418       TGF_RGBA_INTEGER8,
00419
00420       TGF_SIGNED_LUMINANCE_INTEGER32,
00421       TGF_SIGNED_LUMINANCE_INTEGER16,
00422       TGF_SIGNED_LUMINANCE_INTEGER8,
00423       TGF_LUMINANCE_INTEGER32,
00424       TGF_LUMINANCE_INTEGER16,
00425       TGF_LUMINANCE_INTEGER8,
00426
00427       TGF_SIGNED_LUMINANCE_ALPHA_INTEGER32,
00428       TGF_SIGNED_LUMINANCE_ALPHA_INTEGER16,
00429       TGF_SIGNED_LUMINANCE_ALPHA_INTEGER8,
00430       TGF_LUMINANCE_ALPHA_INTEGER32,
00431       TGF_LUMINANCE_ALPHA_INTEGER16,
00432       TGF_LUMINANCE_ALPHA_INTEGER8,
00433
00434       TGF_UNSIGNED_FLOAT_SHARED_EXPONENT, //USE RGB9_E5 format (EXT_texture_shared_exponent)
00435       TGF_UNSIGNED_FLOAT_PACKED          // USE R11F_G11F_B10F_EXT format, (EXT_texture_packed_float)
00436     };
00437
00439     enum
00440     {
00441       F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD = BIT0
00443     , F_IMAGE_STREAM = BIT2
00445     , F_NO_IMAGE_CREATION = BIT4
00448     , F_SCALE_FILTER_BOX = 0
00449     , F_SCALE_FILTER_TRIANGLE = BIT7
00450     , F_SCALE_FILTER_BELL = BIT8
00451     , F_SCALE_FILTER_BSPLINE = BIT7 | BIT8
00452     , F_SCALE_FILTER_LANCZOS3 = BIT9
00453     , F_SCALE_FILTER_MASK = BIT7 | BIT8 | BIT9
00454
00455     , F_SCALE_POT_NEAREST = 0
00456     , F_SCALE_POT_ABOVE = BIT16
00457     , F_SCALE_POT_BELOW = BIT17
00458     , F_SCALE_POT_MASK= F_SCALE_POT_ABOVE | F_SCALE_POT_BELOW
00459     };
00460
00480     NVSG_API static TextureImageHandle * createFromFile( const std::string& filename
00481                                                        , const std::vector<std::string>& searchPaths
00482                                                        , unsigned int creationFlags = 0 );
00483
00488     NVSG_API TextureImage();
00489
00491     NVSG_API TextureImage(const TextureImage&);
00492
00494     NVSG_API virtual ~TextureImage();
00495
00511     NVSG_API void setCreationFlags(unsigned int flags);
00512
00514
00527     NVSG_API void setTextureGPUFormat( TextureGPUFormat fmt );
00528
00530
00535     NVSG_API TextureGPUFormat getTextureGPUFormat( void ) const;
00536
00541     NVSG_API const std::string& getFileName() const;
00542
00544
00578     NVSG_API unsigned int createImage( unsigned int           width
00579                                      , unsigned int           height
00580                                      , unsigned int           depth
00581                                      , Image::PixelFormat     format
00582                                      , Image::PixelDataType   type
00583                                      , const void           * pixels
00584                                      , const std::vector<const void*>& mipmaps = std::vector<const void*>()
00586                                      );
00587
00598     NVSG_API unsigned int addImage( unsigned int width
00599                                   , unsigned int height
00600                                   , unsigned int depth
00601                                   , Image::PixelFormat format
00602                                   , Image::PixelDataType type );
00603
00622     NVSG_API void setImageData( unsigned int image
00623                               , const void * pixels
00624                               , const std::vector<const void *> & mipmaps = std::vector<const void *>() );
00625
00627
00632     NVSG_API void releaseImagePixels();
00633
00639     NVSG_API bool reloadImagePixels();
00640
00653     NVSG_API void incrementMipmapUseCount();
00654
00666     NVSG_API void decrementMipmapUseCount();
00667
00677     NVSG_API unsigned int getMipmapUseCount() const;
00678
00685     NVSG_API bool createMipmaps();
00686
00690     NVSG_API unsigned int getNumberOfImages() const;
00691
00698     NVSG_API unsigned int getNumberOfMipmaps( unsigned int image=0
00699                                             ) const;
00700
00702
00711     NVSG_API Image::PixelFormat getFormat( unsigned int image=0
00712                                          , unsigned int mipmap=0
00713                                          ) const;
00714
00716
00725     NVSG_API Image::PixelDataType getType( unsigned int image=0
00726                                          , unsigned int mipmap=0
00727                                          ) const;
00728
00739     NVSG_API unsigned int getWidth( unsigned int image=0
00740                                   , unsigned int mipmap=0
00741                                   ) const;
00742
00753     NVSG_API unsigned int getHeight( unsigned int image=0
00754                                    , unsigned int mipmap=0
00755                                    ) const;
00756
00767     NVSG_API unsigned int getDepth( unsigned int image=0
00768                                   , unsigned int mipmap=0
00769                                   ) const;
00770
00772
00780     NVSG_API unsigned int getBytesPerPixel( unsigned int image=0
00781                                           , unsigned int mipmap=0
00782                                           ) const;
00783
00797     NVSG_API unsigned int getBytesPerScanLine( unsigned int image=0, unsigned int mipmap=0 ) const;
00798
00812     NVSG_API unsigned int getBytesPerPlane( unsigned int image=0, unsigned int mipmap=0 ) const;
00813
00826     NVSG_API unsigned int getNumberOfBytes( unsigned int image=0, unsigned int mipmap=0 ) const;
00827
00830     NVSG_API unsigned int getTotalNumberOfBytes() const;
00831
00833
00841     NVSG_API const void * getPixels( unsigned int image = 0
00842                                    , unsigned int mipmap = 0
00843                                    ) const;
00844
00874     NVSG_API bool getSubImagePixels( unsigned int image
00875                                    , unsigned int mipmap
00876                                    , unsigned int x_offset
00877                                    , unsigned int y_offset
00878                                    , unsigned int z_offset
00879                                    , unsigned int width
00880                                    , unsigned int height
00881                                    , unsigned int depth
00882                                    , void * subPixels
00883                                    ) const;
00884
00915     NVSG_API bool setSubImagePixels( unsigned int image
00916                                    , unsigned int mipmap
00917                                    , unsigned int x_offset
00918                                    , unsigned int y_offset
00919                                    , unsigned int z_offset
00920                                    , unsigned int width
00921                                    , unsigned int height
00922                                    , unsigned int depth
00923                                    , const void * subPixels
00924                                    );
00925
00927     NVSG_API unsigned int getUnpackAlignment() const;
00928
00939     NVSG_API bool scale( unsigned int image
00940                        , unsigned int width
00941                        , unsigned int height = 1
00942                        , unsigned int depth = 1
00943                        );
00944
00952     NVSG_API bool convertPixelFormat( Image::PixelFormat newFormat);
00953
00978     NVSG_API bool scaleToPowerOfTwo(unsigned int sizeLimit);
00979
00981
00982     NVSG_API bool is1D()            const;
00983
00985
00986     NVSG_API bool is2D()            const;
00987
00989
00990     NVSG_API bool is2DArray()            const;
00991
00993
00994     NVSG_API bool is1DArray()            const;
00995
00997
00998     NVSG_API bool is3D()            const;
00999
01001
01003
01006
01007
01010
01011
01014
01015
01018
01020
01023
01027
01030
01041
01044
01045
01048
01052
01055
01056
01059
01060
01063
01064
01068
01069
01386
01402
01406
01408
01411
01412
01417
01419
01423
01424
01427
01428
01443
01445
01449
01450
01453
01454
01469
01473
01477
01478
01481
01483
01492
01496
01500
01501
01504
01506
01515
01518
01522
01523
01526
01528
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Tools.h File Reference

#include "nvsgcommon.h"
#include <vector>
#include <stdio.h>

Include dependency graph for Tools.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:23 2008 for NVSGSDK by NVIDIA


Tools.h Source File

Tools.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include <vector>
00017
00018 #include <stdio.h>
00019
00020 namespace nvutil
00021 {
00022
00024
00039   extern NVSG_API bool FindFile( const std::string &mask
00040                                , const std::vector<std::string> &searchPaths
00041                                , std::vector<std::string> &results
00042                                , bool recursive=false
00043                                );
00044
00046
00048   extern NVSG_API bool FindFileFirst( const std::string &mask
00049                                     , const std::vector<std::string> &searchPaths
00050                                     , std::string &nameOut
00051                                     , bool recursive=false
00052                                     );
00053
00055   extern NVSG_API bool FileExists( const std::string &filepath  //<! Input (path+)filename.
00056                                  );
00057
00059   extern NVSG_API bool FileSize( const std::string &filepath,  //<! Input (path+)filename
00060                                  long &size                    //<! Filesize if file exists (function return true)
00061                                );
00062
00064
00066   extern NVSG_API void GetFileNameFromPath( const std::string& path
00067                                           , std::string& fname
00068                                           );
00070
00072   extern NVSG_API void GetFileExtFromPath( const std::string& path
00073                                          , std::string& fext
00074                                          );
00076
00078   extern NVSG_API void GetDirFromPath( const std::string& path
00079                                      , std::string& dir
00080                                      );
00082
00084   extern NVSG_API void GetDrvFromPath( const std::string& path
00085                                      , std::string& drv
00086                                      );
00088
00090   extern NVSG_API void GetDrvAndDirFromPath(const std::string& path
00091                                            , std::string& dir
00092                                            );
00093
00094   extern NVSG_API void SplitPath( const std::string& path
00095                                 , std::string& drv
00096                                 , std::string& dir
00097                                 , std::string& fname
00098                                 , std::string& fext );
00099
00100 #if defined(_WIN32)
00101
00102
00104   extern NVSG_API void GetModulePath( const std::string& module
00105                                     , std::string& path
00106                                     );
00108
00110   extern NVSG_API void GetModulePath( const HMODULE hModule
00111                                     , std::string& path
00112                                     );
00113 #endif
00114
00116
00118   extern NVSG_API void GetModulePath( std::string& path );
00119
00121
00124   extern NVSG_API bool GetCurrentDir( std::string& path
00125                                     );
00126
00128
00131   extern NVSG_API std::string SetCurrentDir( const std::string& dir
00132                                       );
00134
00138   class StrTokenizer
00139   {
00140     public:
00141       explicit NVSG_API StrTokenizer( const std::string& delimString );
00142       NVSG_API ~StrTokenizer();
00143
00144       NVSG_API void setInput( const std::string& inputString );
00145       NVSG_API const std::string& getNextToken();
00146       NVSG_API bool hasMoreTokens() const;
00147
00148     private:
00149       unsigned int m_currentPos;
00150       std::string m_inputString;
00151       std::string m_token;
00152       std::string m_delim;
00153   };
00154
00155 } // namespace nvutil
00156
00157
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Trace.h File Reference

#include "nvsg/nvsgapi.h"
#include "nvutil/nvutil.h"
#include <string>
#include <stdio.h>
#include <stdarg.h>

Include dependency graph for Trace.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvutil

Defines

#define | TRACE_LOG_FILE "QuadroVR.log" /* log file for debug printouts */
Define for the trace log file name.

#define | OutputString traceDebugOutput
#define | NVSG_TRACE()
#define | NVSG_TRACE_OUT(s) if ( dwTraceEnabled ) { TraceFunctor<OutputString>()(s); }
#define | NVSG_TRACE_OUT_F(s) if ( dwTraceEnabled ) { TraceFunctor<OutputString>().format s; }

Variables

NVSG_API const char * | REG_NV_TRACE_SUBKEY
Subkey of Registry where tracing is enabled/disabled on function level.

Detailed Description

Define Documentation

#define TRACE_LOG_FILE "QuadroVR.log" /* log file for debug printouts */

Define for the trace log file name.

#define NVSG_TRACE ( )

Value:

static DWORD dwTraceEnabled = RegVal<DWORD>( __FUNCTION__              \
                                             , REG_NV_TRACE_SUBKEY       \
                                             , REG_DWORD_LITTLE_ENDIAN   \
                                             , HKEY_CURRENT_USER        \
                                             , DWORD(0) );               \
  Trace<TraceFunctor<OutputString> >  traceObject(__FUNCTION__, dwTraceEnabled!=0);

Variable Documentation

NVSG_API const char* REG_NV_TRACE_SUBKEY

Subkey of Registry where tracing is enabled/disabled on function level.

Generated on Tue Jan 15 10:28:26 2008 for NVSGSDK by NVIDIA


Trace.h Source File

Trace.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsg/nvsgapi.h"  // storage-class defines
00016
00017 #include "nvutil/nvutil.h"
00018
00019 #include <string>
00020
00021 #ifndef LINUX
00022 # include <conio.h>
00023 # include "nvutil/Registry.h"
00024 #else
00025 # include <stdio.h>
00026 # include <stdarg.h>
00027 #endif
00028
00030 extern NVSG_API const char * REG_NV_TRACE_SUBKEY;
00031
00032 namespace nvutil {
00033
00034
00036 #define TRACE_LOG_FILE       "QuadroVR.log" /* log file for debug printouts */
00037
00038 //
00039 // a certain output functors
00040 //
00041
00043 struct traceDebugOutput
00044 {
00046   void operator()(const char * str)
00047   {
00048 #ifdef _WIN32
00049   #ifndef UNICODE
00050     OutputDebugStringA(str);
00051   #endif
00052 #elif defined(LINUX)
00053     printf("%s", str);
00054 #endif
00055   }
00056 };
00057
00059 struct traceConsoleOutput
00060 {
00062   void operator()(const char * str)
00063   {
00064 #ifdef _WIN32
00065   _cputs(str);
00066 #endif
00067   }
00068 };
00069
00071 struct traceConsoleDebugOutput
00072 {
00074   void operator()(const char * str)
00075   {
00076 #ifdef _WIN32
00077     traceDebugOutput()(str);
00078     traceConsoleOutput()(str);
00079 #endif
00080   }
00081 };
00082
00084 struct traceFileOutput
00085 {
00087   void operator()(const char * str)
00088   {
00089 #ifdef _WIN32
00090     FILE * fp = fopen(TRACE_LOG_FILE, "a");
00091     if ( fp )
00092     {
00093       fputs(str, fp);
00094       fclose(fp);
00095     }
00096 #endif
00097   }
00098 };
00099
00101 struct traceFileDebugOutput
00102 {
00104   void operator()(const char * str)
00105   {
00106 #ifdef _WIN32
00107     traceFileOutput()(str);
00108     traceDebugOutput()(str);
00109 #endif
00110   }
00111 };
00112
00114 struct traceFileConsoleOutput
00115 {
00117   void operator()(const char * str)
00118   {
00119 #ifdef _WIN32
00120     traceFileOutput()(str);
00121     traceConsoleOutput()(str);
00122 #endif
00123   }
00124 };
00125
00127 template <typename Functor>
00128 class Trace
00129 {
00130 public:
00132   Trace(const char * fn, bool traceOut) : m_fn(NULL), m_traceOut(traceOut)
00133   {
00134     if (m_traceOut)
00135     {
00136       m_fn = new std::string(fn);
00137       enter();
00138     }
00139   }
00140
00142   ~Trace()
00143   {
00144     if (m_traceOut)
00145     {
00146       leave();
00147       delete m_fn;
00148     }
00149   }
00150
00151 private:
00152   void enter()
00153   {
00154     std::string outstr(">>>> Enter ");
00155     outstr += m_fn->c_str();
00156     outstr += "\n";
00157     Functor()(outstr.c_str());
00158   }
00159
00160   void leave()
00161   {
00162     std::string outstr("<<<< Leave ");
00163     outstr += m_fn->c_str();
00164     outstr += "\n";
00165     Functor()(outstr.c_str());
00166   }
00167
00168   std::string * m_fn;
00169   bool m_traceOut;
00170 };
00171
00173 template <typename OutFunctor>
00174 struct TraceFunctor
00175 {
00177   void operator()(const char* str) { OutFunctor()(str); }
00178
00180   void format(const char* fmt, ...)
00181   {
00182     const int bufSize = 1024;
00183     char outBuf[bufSize];
00184
00185     va_list ap;
00186     va_start(ap, fmt);
00187     vsnprintf(outBuf, bufSize-1, fmt, ap);
00188     va_end(ap);
00189
00190     OutFunctor()(outBuf);
00191   }
00192 };
00193
00194
00195 #if !defined(NDEBUG) && defined(_WIN32) && !defined(UNICODE)
00196 // uncomment one of the following for desired tracing
00197 # define OutputString traceDebugOutput
00198 //# define OutputString traceConsoleOutput
00199 //# define OutputString traceConsoleDebugOutput
00200 //# define OutputString traceFileOutput
00201 //# define OutputString traceFileDebugOutput
00202 //# define OutputString traceFileConsoleOutput
00203 # define NVSG_TRACE()                                                       \
00204   static DWORD dwTraceEnabled = RegVal<DWORD>( __FUNCTION__              \
00205                                              , REG_NV_TRACE_SUBKEY       \
00206                                              , REG_DWORD_LITTLE_ENDIAN   \
00207                                              , HKEY_CURRENT_USER        \
00208                                              , DWORD(0) );               \
00209   Trace<TraceFunctor<OutputString> >  traceObject(__FUNCTION__, dwTraceEnabled!=0);
00210 // NVSG_TRACE_OUT(s) - string output
00211 // requires TRACE() macro to be expanded before within the same function
00212 # define NVSG_TRACE_OUT(s)   \
00213   if ( dwTraceEnabled ) { TraceFunctor<OutputString>()(s); }
00214 // NVSG_TRACE_OUT_F(s) - formatted string output
00215 // USAGE: NVSG_TRACE_OUT_F((const char* fmt, ...))
00216 //                      ^                    ^
00217 // requires TRACE() macro to be expanded before within the same function
00218 # define NVSG_TRACE_OUT_F(s) \
00219   if ( dwTraceEnabled ) { TraceFunctor<OutputString>().format s; }
00220
00221 #else // !defined(NDEBUG) && defined(_WIN32)
00222
00223 # define NVSG_TRACE()
00224 # define NVSG_TRACE_OUT(s)
00225 # define NVSG_TRACE_OUT_F(s)
00226
00227 #endif // !NDEBUG
00228
00229 } // namespace nvutil
00230
00231 // avoid tedious, repeated qualification of namespace scope
00232 #if !defined(NDEBUG) && defined(_WIN32)
00233
00234 using nvutil::RegVal;
00235 using nvutil::traceConsoleDebugOutput;
00236 using nvutil::traceConsoleOutput;
00237 using nvutil::traceDebugOutput;
00238 using nvutil::traceFileConsoleOutput;
00239 using nvutil::traceFileDebugOutput;
00240 using nvutil::traceFileOutput;
00241 using nvutil::TraceFunctor;
00242 using nvutil::Trace;
00243
00244 #endif // !defined(NDEBUG) && defined(_WIN32)
00245
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Trackball.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vecnt.h"

Include dependency graph for Trackball.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:26 2008 for NVSGSDK by NVIDIA


Trackball.h Source File

Trackball.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Vecnt.h"
00017
00018 namespace nvutil
00019 {
00020
00022
00027   class Trackball
00028   {
00029     public:
00031       Trackball(void);
00032
00034       virtual ~Trackball(void);
00035
00037
00046       void  apply( const nvmath::Vec2f &p0
00047                  , const nvmath::Vec2f &p1
00048                  , nvmath::Vec3f & axis
00049                  , float & rad
00050                  );
00051
00053
00058       void  setSize( float size
00059                    );
00060
00062
00064       float getSize( void );
00065
00066     protected:
00068
00071       float projectOntoTBSphere( const nvmath::Vec2f & p );
00072
00073       float m_tbsize;
00074   };
00075
00076   inline  void  Trackball::setSize( float size )
00077   {
00078     NVSG_ASSERT( m_tbsize > 0.f );
00079     m_tbsize = size;
00080   }
00081
00082   inline float Trackball::getSize( void )
00083   {
00084     return( m_tbsize );
00085   }
00086
00087 } //  namespace nvui
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TrackballCameraManipulator.h File Reference

#include "nvsgcommon.h"
#include "nvui/Manipulator.h"
#include "nvutil/Trackball.h"
#include "nvui/MouseInput.h"
#include "nvui/KeyInput.h"

Include dependency graph for TrackballCameraManipulator.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:28:27 2008 for NVSGSDK by NVIDIA


TrackballCameraManipulator.h Source File

TrackballCameraManipulator.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include "nvui/Manipulator.h"
00018 #include "nvutil/Trackball.h"
00019 #include "nvui/MouseInput.h"
00020 #include "nvui/KeyInput.h"
00021
00022 namespace nvui
00023 {
00048   class TrackballCameraManipulator : public Manipulator
00049   {
00050   public:
00053     NVSG_API TrackballCameraManipulator();
00054
00056     NVSG_API virtual ~TrackballCameraManipulator();
00057
00061     enum
00062     { _NO_BTN_KEY         = 0x0000
00063     , _LEFT_MOUSE_BTN     = 0x0001
00064     , _MIDDLE_MOUSE_BTN   = 0x0002
00065     , _SHIFT_KEY          = 0x0004
00066     , _CONTROL_KEY        = 0x0008
00067     , _X_KEY              = 0x0010
00068     , _Y_KEY              = 0x0020
00069     , _Z_KEY              = 0x0040
00070     };
00071
00087     NVSG_API virtual bool updateFrame();
00088
00093     NVSG_API virtual bool isActive();
00094
00101     NVSG_API void keyDown( UINT key  );
00102
00109     NVSG_API void keyUp( UINT key );
00110
00121     NVSG_API void mouseButtonDown( UINT btn, int x, int y );
00122
00133     NVSG_API void mouseButtonUp( UINT btn, int x, int y );
00134
00141     NVSG_API void mouseMotion( int x, int y );
00142
00149     NVSG_API void reset();
00150
00159     NVSG_API bool isDolly();
00160
00169     NVSG_API bool isPan();
00170
00178     NVSG_API bool isOrbit();
00179
00192     NVSG_API bool isRotate();
00193
00194   protected:
00195     static NVSG_API const UINT DOLLY1;
00196     static NVSG_API const UINT DOLLY2;
00197     static NVSG_API const UINT PAN1;
00198     static NVSG_API const UINT PAN2;
00199     static NVSG_API const UINT ORBIT;
00200     static NVSG_API const UINT ROTATEXP;
00201     static NVSG_API const UINT ROTATEXN;
00202     static NVSG_API const UINT ROTATEYP;
00203     static NVSG_API const UINT ROTATEYN;
00204     static NVSG_API const UINT ROTATEZP;
00205     static NVSG_API const UINT ROTATEZN;
00206
00207     nvui::MouseInput  m_mouseInput;
00208     nvui::MouseInput  m_miLast;
00209     nvui::KeyInput    m_keyInput;
00210     nvutil::Trackball m_trackball;
00211     nvmath::Vec3f     m_rotationAxis;
00212     int               m_trueX, m_trueY;
00213
00214   protected:
00218     virtual bool orbit();
00219
00223     virtual bool pan();
00224
00228     virtual bool dolly();
00229
00233     virtual bool rotate();
00234   };
00235 } // namespace nvui
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TrackballTransformManipulator.h File Reference

#include "nvsgcommon.h"
#include "nvui/TransformManipulator.h"
#include "nvui/KeyInput.h"
#include "nvui/MouseInput.h"
#include "nvutil/Trackball.h"

Include dependency graph for TrackballTransformManipulator.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:28:27 2008 for NVSGSDK by NVIDIA


TrackballTransformManipulator.h Source File

TrackballTransformManipulator.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include "nvui/TransformManipulator.h"
00018 #include "nvui/KeyInput.h"
00019 #include "nvui/MouseInput.h"
00020 #include "nvutil/Trackball.h"
00021
00022 namespace nvui
00023 {
00052   class TrackballTransformManipulator : public TransformManipulator
00053   {
00054   public:
00057     NVSG_API TrackballTransformManipulator(void);
00058
00060     NVSG_API virtual ~TrackballTransformManipulator(void);
00061
00065     enum
00066     { _NO_BTN_KEY         = 0x0000
00067     , _LEFT_MOUSE_BTN     = 0x0001
00068     , _MIDDLE_MOUSE_BTN   = 0x0002
00069     , _SHIFT_KEY          = 0x0004
00070     , _CONTROL_KEY        = 0x0008
00071     , _X_KEY              = 0x0010
00072     , _Y_KEY              = 0x0020
00073     };
00074
00091     NVSG_API virtual bool updateFrame();
00092
00097     NVSG_API virtual bool isActive();
00098
00105     NVSG_API void keyDown(UINT key);
00106
00113     NVSG_API void keyUp(UINT key);
00114
00125     NVSG_API void mouseButtonDown(UINT btn, int x, int y);
00126
00137     NVSG_API void mouseButtonUp(UINT btn, int x, int y);
00138
00145     NVSG_API void mouseMotion(int x, int y);
00146
00153     NVSG_API void reset();
00154
00163     NVSG_API bool isDolly( void );
00164
00173     NVSG_API bool isPan( void );
00174
00182     NVSG_API bool isRotate( void );
00183
00184   protected:
00185     static NVSG_API const UINT DOLLY1;
00186     static NVSG_API const UINT DOLLY2;
00187     static NVSG_API const UINT PAN1;
00188     static NVSG_API const UINT PAN2;
00189     static NVSG_API const UINT ROTATE;
00190
00191     nvui::MouseInput m_mouseInput;
00192     nvui::KeyInput   m_keyInput;
00193     nvutil::Trackball m_trackball;  // Trackball object that does all the calculations
00194     int m_trueX, m_trueY;
00195
00196   protected:
00200     virtual bool pan();
00201
00205     virtual bool dolly();
00206
00210     virtual bool rotate();
00211   };
00212 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Trafo.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Quatt.h"
#include "nvmath/Vecnt.h"

Include dependency graph for Trafo.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvmath

Detailed Description

Generated on Tue Jan 15 10:28:27 2008 for NVSGSDK by NVIDIA


Trafo.h Source File

Trafo.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Quatt.h"
00017 #include "nvmath/Vecnt.h"
00018
00019 namespace nvmath
00020 {
00022
00024   class Trafo
00025   {
00026     public:
00028       NVSG_API Trafo( void );
00029
00031       NVSG_API Trafo( const Trafo &rhs
00032                     );
00033
00035
00036       NVSG_API const Vec3f & getCenter( void ) const;
00037
00039
00040       NVSG_API const Quatf & getOrientation( void ) const;
00041
00043
00044       NVSG_API const Quatf & getScaleOrientation( void ) const;
00045
00047
00048       NVSG_API const Vec3f & getScaling( void ) const;
00049
00051
00052       NVSG_API const Vec3f & getTranslation( void ) const;
00053
00062       NVSG_API Mat44f getMatrix( void ) const;
00063
00073       NVSG_API Mat44f getInverse( void ) const;
00074
00076       NVSG_API void setCenter( const Vec3f &center
00077                              );
00078
00080       NVSG_API void setIdentity( void );
00081
00083       NVSG_API void setOrientation( const Quatf &orientation
00084                                   );
00085
00087       NVSG_API void setScaleOrientation( const Quatf &scaleOrientation
00088                                        );
00089
00091       NVSG_API void setScaling( const Vec3f &scaling
00092                               );
00093
00095       NVSG_API void setTranslation( const Vec3f &translation
00096                                   );
00097
00099
00100       NVSG_API void setMatrix( const Mat44f &matrix
00101                              );
00102
00104       NVSG_API Trafo & operator=( const Trafo &rhs
00105                        );
00106
00108
00109       NVSG_API bool operator==( const Trafo &t
00110                               ) const;
00111
00112       NVSG_API bool operator!=( const Trafo &t ) const;
00113
00114     private:
00115       Vec3f   m_center;
00116       Quatf   m_orientation;
00117       Quatf   m_scaleOrientation;
00118       Vec3f   m_scaling;
00119       Vec3f   m_translation;
00120   };
00121
00122   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00123   // non-member functions
00124   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00127   NVSG_API Trafo lerp( float alpha
00128                      , const Trafo &t0
00129                      , const Trafo &t1
00130                      );
00131
00132   NVSG_API void lerp( float alpha, const Trafo & t0, const Trafo & t1, Trafo & tr );
00133
00134   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00135   // inlines
00136   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00137   inline const Vec3f & Trafo::getCenter( void ) const
00138   {
00139     NVSG_TRACE();
00140     return( m_center );
00141   }
00142
00143   inline const Quatf & Trafo::getOrientation( void ) const
00144   {
00145     NVSG_TRACE();
00146     return( m_orientation );
00147   }
00148
00149   inline const Quatf & Trafo::getScaleOrientation( void ) const
00150   {
00151     NVSG_TRACE();
00152     return( m_scaleOrientation );
00153   }
00154
00155   inline const Vec3f & Trafo::getScaling( void ) const
00156   {
00157     NVSG_TRACE();
00158     return( m_scaling );
00159   }
00160
00161   inline const Vec3f & Trafo::getTranslation( void ) const
00162   {
00163     NVSG_TRACE();
00164     return( m_translation );
00165   }
00166
00167   inline void Trafo::setCenter( const Vec3f &center )
00168   {
00169     NVSG_TRACE();
00170     m_center = center;
00171   }
00172
00173   inline void Trafo::setOrientation( const Quatf &orientation )
00174   {
00175     NVSG_TRACE();
00176     NVSG_PRIVATE_ASSERT( isNormalized( orientation ) );
00177     m_orientation = orientation;
00178   }
00179
00180   inline void Trafo::setScaleOrientation( const Quatf &scaleOrientation )
00181   {
00182     NVSG_TRACE();
00183     NVSG_PRIVATE_ASSERT( isNormalized( scaleOrientation ) );
00184     m_scaleOrientation = scaleOrientation;
00185   }
00186
00187   inline void Trafo::setScaling( const Vec3f &scaling )
00188   {
00189     NVSG_TRACE();
00190     m_scaling = scaling;
00191   }
00192
00193   inline void Trafo::setTranslation( const Vec3f &translation )
00194   {
00195     NVSG_TRACE();
00196     m_translation = translation;
00197   }
00198
00199   inline bool Trafo::operator!=( const Trafo & t ) const
00200   {
00201     NVSG_TRACE();
00202     return( ! ( *this == t ) );
00203   }
00204
00205   inline void lerp( float alpha, const Trafo & t0, const Trafo & t1, Trafo & tr )
00206   {
00207     tr = lerp( alpha, t0, t1 );
00208   }
00209 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Transform.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Trafo.h"
#include "nvsg/Group.h"

Include dependency graph for Transform.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:28 2008 for NVSGSDK by NVIDIA


Transform.h Source File

Transform.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Trafo.h"
00017 #include "nvsg/Group.h"
00018
00019 namespace nvsg
00020 {
00027   class Transform : public Group
00028   {
00029     friend class Skin;
00030
00031     public:
00034       NVSG_API Transform(void);
00035
00043       NVSG_API Transform( const Group &rhs );
00044
00047       NVSG_API Transform( const Transform &rhs );
00048
00051       NVSG_API virtual ~Transform(void);
00052
00056       NVSG_API virtual const nvmath::Trafo & getTrafo( void ) const;
00057
00063       NVSG_API virtual void setTrafo( const nvmath::Trafo & trafo );
00064
00069       NVSG_API bool isJoint() const;
00070
00077       NVSG_API Transform & operator=(const Transform & rhs);
00078
00087       NVSG_API virtual bool isEquivalent( const Object * p
00088                                         , bool ignoreNames
00089                                         , bool deepCompare ) const;
00090
00091     protected:
00092
00097       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00098
00104       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00105
00113       NVSG_API void incrementJointCount();
00114
00122       NVSG_API void decrementJointCount();
00123
00124     private:
00125       nvmath::Trafo m_trafo;
00126       unsigned int  m_jointCount;
00127   };
00128
00129   inline const nvmath::Trafo & Transform::getTrafo( void ) const
00130   {
00131     NVSG_TRACE();
00132     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00133     return( m_trafo );
00134   }
00135
00136   inline bool Transform::isJoint() const
00137   {
00138     NVSG_TRACE();
00139     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00140     return( 0 < m_jointCount );
00141   }
00142 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TransformManipulator.h File Reference

#include "nvsgcommon.h"
#include "nvui/Manipulator.h"

Include dependency graph for TransformManipulator.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvui

Detailed Description

Generated on Tue Jan 15 10:28:28 2008 for NVSGSDK by NVIDIA


TransformManipulator.h Source File

TransformManipulator.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include "nvui/Manipulator.h"
00018
00019 namespace nvsg
00020 {
00021   class Transform;
00022   class Path;
00023 }
00024
00025 namespace nvui
00026 {
00044   class TransformManipulator : public Manipulator
00045   {
00046   public:
00049     NVSG_API TransformManipulator();
00050
00055     NVSG_API virtual ~TransformManipulator();
00056
00068     NVSG_API void setTransformPath(const nvsg::Path * transformPath);
00069
00076     NVSG_API const nvsg::Path * getTransformPath() const;
00077
00078   protected:
00079     const nvsg::Path * m_transformPath;
00080   };
00081
00082   inline const nvsg::Path * TransformManipulator::getTransformPath() const
00083   {
00084     return( m_transformPath );
00085   }
00086 }
00087
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TransformStack.h File Reference

#include <stack>
#include "nvsgcommon.h"
#include "nvmath/Matnnt.h"

Include dependency graph for TransformStack.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:28 2008 for NVSGSDK by NVIDIA


TransformStack.h Source File

TransformStack.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <stack>
00016 #include "nvsgcommon.h"
00017 #include "nvmath/Matnnt.h"
00018
00019 namespace nvutil
00020 {
00022
00038   class TransformStack
00039   {
00040     public:
00042
00043       TransformStack();
00044
00045     public:
00047       NVSG_API const nvmath::Mat44f  & getClipToModel( void )  const;
00048
00050       NVSG_API const nvmath::Mat44f  & getClipToView( void )   const;
00051
00053       NVSG_API const nvmath::Mat44f  & getModelToClip( void )  const;
00054
00056       NVSG_API const nvmath::Mat44f  & getModelToView( void )  const;
00057
00059       NVSG_API const nvmath::Mat44f  & getModelToWorld( void ) const;
00060
00062       NVSG_API const nvmath::Mat44f  & getViewToClip( void )   const;
00063
00065       NVSG_API const nvmath::Mat44f  & getViewToModel( void )  const;
00066
00068       NVSG_API const nvmath::Mat44f  & getViewToWorld( void )  const;
00069
00071       NVSG_API const nvmath::Mat44f  & getWorldToModel( void ) const;
00072
00074       NVSG_API const nvmath::Mat44f  & getWorldToView( void )  const;
00075
00077       NVSG_API unsigned int getStackDepth( void )   const;
00078
00080       NVSG_API void      popModelToWorld( void );
00081
00083
00084       NVSG_API void      pushModelToWorld( const nvmath::Mat44f &modelWorld
00085                                          , const nvmath::Mat44f &worldModel
00086                                          );
00087
00089
00090       NVSG_API void      setViewToClip( const nvmath::Mat44f &viewClip
00091                                       , const nvmath::Mat44f &clipView
00092                                       );
00093
00095
00096       NVSG_API void      setWorldToView( const nvmath::Mat44f &worldView
00097                                        , const nvmath::Mat44f &viewWorld
00098                                        );
00099
00100     private :
00101       std::stack<nvmath::Mat44f>  m_modelWorld;
00102       std::stack<nvmath::Mat44f>  m_worldModel;
00103       nvmath::Mat44f              m_worldView;
00104       nvmath::Mat44f              m_viewWorld;
00105       nvmath::Mat44f              m_viewClip;
00106       nvmath::Mat44f              m_clipView;
00107
00108       nvutil::SWMRSync        m_lock;
00109       mutable nvmath::Mat44f  m_clipModel;
00110       mutable nvmath::Mat44f  m_modelClip;
00111       mutable nvmath::Mat44f  m_modelView;
00112       mutable nvmath::Mat44f  m_viewModel;
00113       mutable bool            m_clipModelValid;
00114       mutable bool            m_modelClipValid;
00115       mutable bool            m_modelViewValid;
00116       mutable bool            m_viewModelValid;
00117   };
00118
00119
00120   inline  TransformStack::TransformStack()
00121     : m_clipModelValid(false)
00122     , m_modelClipValid(false)
00123     , m_modelViewValid(false)
00124     , m_viewModelValid(false)
00125   {
00126     m_modelWorld.push( nvmath::cIdentity44f );
00127     m_worldModel.push( nvmath::cIdentity44f );
00128   }
00129
00130   inline  const nvmath::Mat44f  & TransformStack::getClipToModel( void )  const
00131   {
00132     m_lock.lockExclusive();
00133     if ( ! m_clipModelValid )
00134     {
00135       m_clipModel = m_clipView * getViewToModel();
00136       m_clipModelValid = true;
00137     }
00138     m_lock.unlockExclusive();
00139     return( m_clipModel );
00140   }
00141
00142   inline  const nvmath::Mat44f  & TransformStack::getClipToView( void )   const
00143   {
00144     return( m_clipView );
00145   }
00146
00147   inline  const nvmath::Mat44f  & TransformStack::getModelToClip( void )  const
00148   {
00149     m_lock.lockExclusive();
00150     if ( ! m_modelClipValid )
00151     {
00152       m_modelClip = getModelToView() * m_viewClip;
00153       m_modelClipValid = true;
00154     }
00155     m_lock.unlockExclusive();
00156     return( m_modelClip );
00157   }
00158
00159   inline  const nvmath::Mat44f  & TransformStack::getModelToView( void )  const
00160   {
00161     m_lock.lockExclusive();
00162     if ( ! m_modelViewValid )
00163     {
00164       m_modelView = m_modelWorld.top() * m_worldView;
00165       m_modelViewValid = true;
00166     }
00167     m_lock.unlockExclusive();
00168     return( m_modelView );
00169   }
00170
00171   inline  const nvmath::Mat44f  & TransformStack::getModelToWorld( void ) const
00172   {
00173     return( m_modelWorld.top() );
00174   }
00175
00176   inline  const nvmath::Mat44f  & TransformStack::getViewToClip( void )   const
00177   {
00178     return( m_viewClip );
00179   }
00180
00181   inline  const nvmath::Mat44f  & TransformStack::getViewToModel( void )  const
00182   {
00183     m_lock.lockExclusive();
00184     if ( ! m_viewModelValid )
00185     {
00186       m_viewModel = m_viewWorld * m_worldModel.top();
00187       m_viewModelValid = true;
00188     }
00189     m_lock.unlockExclusive();
00190     return( m_viewModel );
00191   }
00192
00193   inline  const nvmath::Mat44f  & TransformStack::getViewToWorld( void )  const
00194   {
00195     return( m_viewWorld );
00196   }
00197
00198   inline  const nvmath::Mat44f  & TransformStack::getWorldToModel( void ) const
00199   {
00200     return( m_worldModel.top() );
00201   }
00202
00203   inline  const nvmath::Mat44f  & TransformStack::getWorldToView( void )  const
00204   {
00205     return( m_worldView );
00206   }
00207
00208   inline  unsigned int  TransformStack::getStackDepth( void ) const
00209   {
00210     NVSG_ASSERT( m_modelWorld.size() == m_worldModel.size() );
00211     NVSG_ASSERT( m_modelWorld.size() <= UINT_MAX );
00212     return( static_cast<unsigned int>(m_modelWorld.size()) );
00213   }
00214
00215   inline  void  TransformStack::popModelToWorld( void )
00216   {
00217     m_modelWorld.pop();
00218     m_worldModel.pop();
00219
00220     m_lock.lockExclusive();
00221     m_clipModelValid = false;
00222     m_modelClipValid = false;
00223     m_modelViewValid = false;
00224     m_viewModelValid = false;
00225     m_lock.unlockExclusive();
00226   }
00227
00228   inline  void  TransformStack::pushModelToWorld( const nvmath::Mat44f &modelWorld, const nvmath::Mat44f &worldModel )
00229   {
00230     NVSG_TRACE();
00231     m_modelWorld.push( modelWorld * m_modelWorld.top() );
00232     m_worldModel.push( m_worldModel.top() * worldModel );
00233
00234     m_lock.lockExclusive();
00235     m_clipModelValid = false;
00236     m_modelClipValid = false;
00237     m_modelViewValid = false;
00238     m_viewModelValid = false;
00239     m_lock.unlockExclusive();
00240   }
00241
00242   inline  void  TransformStack::setViewToClip( const nvmath::Mat44f &viewClip, const nvmath::Mat44f &clipView )
00243   {
00244     NVSG_TRACE();
00245     m_viewClip = viewClip;
00246     m_clipView = clipView;
00247
00248     m_lock.lockExclusive();
00249     m_clipModelValid = false;
00250     m_modelClipValid = false;
00251     m_lock.unlockExclusive();
00252   }
00253
00254   inline  void  TransformStack::setWorldToView( const nvmath::Mat44f &worldView, const nvmath::Mat44f &viewWorld )
00255   {
00256     NVSG_TRACE();
00257     m_worldView = worldView;
00258     m_viewWorld = viewWorld;
00259
00260     m_lock.lockExclusive();
00261     m_clipModelValid = false;
00262     m_modelClipValid = false;
00263     m_modelViewValid = false;
00264     m_viewModelValid = false;
00265     m_lock.unlockExclusive();
00266   }
00267 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Traverser.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CoreTypes.h"
#include "nvsg/Object.h"
#include "nvsg/VolumeBrick.h"
#include "nvutil/BitMask.h"
#include "nvutil/Conversion.h"
#include "nvutil/MemFunTbl.h"
#include "nvutil/ProblemLog.h"
#include "nvutil/RCObject.h"
#include <stack>

Include dependency graph for Traverser.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:28 2008 for NVSGSDK by NVIDIA


Traverser.h Source File

Traverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/CoreTypes.h" // forward declarations of core type
00017 #include "nvsg/Object.h" // ObjectCode defines
00018 #include "nvsg/VolumeBrick.h"
00019 #include "nvutil/BitMask.h"
00020 #include "nvutil/Conversion.h"
00021 #include "nvutil/MemFunTbl.h"
00022 #include "nvutil/ProblemLog.h"
00023 #include "nvutil/RCObject.h" // base class definition
00024 #include <stack>
00025
00026
00027 namespace nvtraverser
00028 {
00038   class Traverser : public nvutil::RCObject
00039   {
00040     public:
00047       NVSG_API void setScene( nvsg::SceneHandle * scene );
00048
00055       NVSG_API void setViewState( nvsg::ViewStateHandle * viewState );
00056
00064       NVSG_API void apply( nvsg::NodeHandle * root );
00065
00071       NVSG_API void apply( nvsg::SceneHandle * scene );
00072
00081       NVSG_API void interruptTraversal();
00082
00089       NVSG_API bool wasTraversalInterrupted();
00090
00091     protected:
00095       NVSG_API Traverser();
00096
00098       NVSG_API virtual ~Traverser();
00099
00104       NVSG_API virtual void lockViewState() = 0;
00105
00110       NVSG_API virtual void unlockViewState() = 0;
00111
00116       NVSG_API virtual void lockScene() = 0;
00117
00122       NVSG_API virtual void unlockScene() = 0;
00123
00129       NVSG_API virtual void doApply( nvsg::NodeHandle * root ) = 0;
00130
00137       NVSG_API virtual const nvsg::Object * lockObject( nvsg::ObjectHandle * obj ) = 0;
00138
00143       NVSG_API virtual void unlockObject( nvsg::ObjectHandle * obj ) = 0;
00144
00152       NVSG_API void traverseObject( nvsg::ObjectHandle * obj );
00153
00162       template<typename T> void traverseObject(nvsg::ObjectHandle * obj, T arg);
00163
00188       NVSG_API virtual bool preApply( nvsg::NodeHandle * root );
00189
00199       NVSG_API virtual void postApply( nvsg::NodeHandle * root );
00200
00210       NVSG_API virtual bool preTraverseGroup( const nvsg::Group * grp );
00211
00218       NVSG_API virtual void postTraverseGroup( const nvsg::Group * grp );
00219
00233       NVSG_API virtual bool preTraverseDrawables( const nvsg::GeoNode* gnode, unsigned int geomIndex );
00234
00245       NVSG_API virtual void postTraverseDrawables( const nvsg::GeoNode* gnode, unsigned int geomIndex );
00246
00253       template <typename T> void traverseGroup( const T * grp );
00254
00260       NVSG_API void traverseGeoNode( const nvsg::GeoNode * gnode );
00261
00265       NVSG_API void traverseShape( const nvsg::Shape * shape );
00266
00271       NVSG_API void traverseStateVariant( const nvsg::StateVariant * variant );
00272
00277       NVSG_API void traverseStatePass( const nvsg::StatePass * pass );
00278
00282       NVSG_API void traverseTextureAttribute( const nvsg::TextureAttribute * texAttrib );
00283
00290       NVSG_API void traverseMapList( const nvsg::MapList * mapList );
00291
00296       NVSG_API void traverseVolumeNode( const nvsg::VolumeNode * volNode );
00297
00302       NVSG_API void evaluateCullTree( const nvsg::ViewState * viewState );
00303
00304     protected:
00305       // traverser bits
00306       enum
00307       {
00308         // tree flags
00309         NVSG_SCENE_DIRTY           = BIT0
00310       , NVSG_ROOT_DIRTY            = BIT1
00311       , NVSG_CULLTREE_DIRTY        = BIT2
00312       , NVSG_TREE_DIRTY_MASK       = NVSG_SCENE_DIRTY | NVSG_ROOT_DIRTY | NVSG_CULLTREE_DIRTY
00313         // viewstate flags
00314       , NVSG_VIEWSTATE_DIRTY       = BIT3
00315       // traversal flags
00316       , NVSG_TRAVERSAL_INTERRUPTED = BIT4
00317       };
00318
00319       std::stack<const nvsg::CullData *>    m_cullStack;
00320       unsigned int                          m_currentAttrib;
00321       std::stack<unsigned int>              m_lodStack;
00322       size_t                                m_lodCheckSum;
00323       size_t                                m_lastLodCheckSum;
00324       nvutil::MemFunTbl<Traverser>          m_mftbl;
00325       nvutil::ProblemLog                    m_problemLog;
00326       nvsg::NodeHandle                    * m_root;
00327       nvsg::SceneHandle                   * m_scene;
00328       unsigned int                          m_traverserBits;
00329       nvsg::ViewStateHandle               * m_viewState;
00330
00331       // NOTE: must not encode this into m_traverserBits, because it must remain volatile
00332       bool volatile m_interrupt;
00333
00334     private:
00335       NVSG_API unsigned int     getObjectTraversalCode( const nvsg::Object * object );  // NOTE: used inline, therefore needs to be exported via NVSG_API
00336       void                      traverseLockedObject( const nvsg::Object * obj );
00337       template<typename T> void traverseLockedObject(const nvsg::Object * obj, T arg);
00338
00339       // traverse overrides for Group derived (have only read-only access to objects)
00340       void traverse( const nvsg::Group * );
00341       void traverse( const nvsg::Group *, const nvsg::CullData * );
00342       void traverse( const nvsg::FlipbookAnimation * );
00343       void traverse( const nvsg::FlipbookAnimation *, const nvsg::CullData * );
00344       void traverse( const nvsg::Switch * );
00345       void traverse( const nvsg::Switch *, const nvsg::CullData * );
00346       void traverse( const nvsg::LOD * );
00347       void traverse( const nvsg::LOD *, const nvsg::CullData * );
00348       // specialized helper with GeoNode traversal
00349       void traverse( const nvsg::GeoNode * );
00350
00351     private:
00352       // several incarnation counters to monitor related changes
00353       nvutil::Incarnation m_rootIncarnation;
00354       nvutil::Incarnation m_cullTreeIncarnation;
00355   };
00356
00369   class SharedTraverser : public Traverser
00370   {
00371     public:
00373       NVSG_API SharedTraverser();
00374
00375     protected:
00377       NVSG_API virtual ~SharedTraverser() {}
00378
00407       template <typename T, typename U>
00408       void addObjectHandler( unsigned int objectCode, void (T::*handler)(const U*) );
00409
00438       template <typename T, typename U, typename V>
00439       void addObjectHandler( unsigned int objectCode, void (T::*handler)(const U*, V) );
00440
00447       NVSG_API virtual const nvsg::Object * lockObject( nvsg::ObjectHandle * obj );
00448
00454       NVSG_API virtual void unlockObject( nvsg::ObjectHandle * obj );
00455
00460       NVSG_API virtual void lockViewState();
00461
00466       NVSG_API virtual void unlockViewState();
00467
00472       NVSG_API virtual void lockScene();
00473
00478       NVSG_API virtual void unlockScene();
00479
00485       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00486
00496       NVSG_API virtual void handleParallelCamera( const nvsg::ParallelCamera * camera );
00497
00507       NVSG_API virtual void handlePerspectiveCamera( const nvsg::PerspectiveCamera * camera );
00508
00518       NVSG_API virtual void handleGroup( const nvsg::Group * group );
00519
00530       NVSG_API virtual void handleFlipbookAnimation( const nvsg::FlipbookAnimation * anim );
00531
00541       NVSG_API virtual void handleTransform( const nvsg::Transform * trafo );
00542
00553       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform * trafo );
00554
00564       NVSG_API virtual void handleLOD( const nvsg::LOD * lod );
00565
00575       NVSG_API virtual void handleSwitch( const nvsg::Switch * swtch );
00576
00586       NVSG_API virtual void handleBillboard( const nvsg::Billboard * billboard );
00587
00597       NVSG_API virtual void handleDirectedLight( const nvsg::DirectedLight * light );
00598
00608       NVSG_API virtual void handlePointLight( const nvsg::PointLight * light );
00609
00619       NVSG_API virtual void handleSpotLight( const nvsg::SpotLight * light );
00620
00630       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * gnode );
00631
00641       NVSG_API virtual void handleQuads( const nvsg::Quads * quads );
00642
00652       NVSG_API virtual void handleTriangles( const nvsg::Triangles * triangles );
00653
00664       NVSG_API virtual void handleSkinnedTriangles( const nvsg::SkinnedTriangles * triangles );
00665
00675       NVSG_API virtual void handleLines( const nvsg::Lines * lines );
00676
00686       NVSG_API virtual void handlePoints( const nvsg::Points * points );
00687
00697       NVSG_API virtual void handleQuadMeshes( const nvsg::QuadMeshes * meshes );
00698
00708       NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips * strips );
00709
00719       NVSG_API virtual void handleTriFans( const nvsg::TriFans * fans );
00720
00730       NVSG_API virtual void handleTriStrips( const nvsg::TriStrips * strips );
00731
00741       NVSG_API virtual void handleLineStrips( const nvsg::LineStrips * strips );
00742
00752       NVSG_API virtual void handleShape( const nvsg::Shape * shape );
00753
00763       NVSG_API virtual void handleStateSet( const nvsg::StateSet * stateSet );
00764
00774       NVSG_API virtual void handleStateVariant( const nvsg::StateVariant * variant );
00775
00785       NVSG_API virtual void handleStatePass( const nvsg::StatePass * pass );
00786
00795       NVSG_API virtual void handleCgFx( const nvsg::CgFx * cgfx );
00796
00805       NVSG_API virtual void handleMaterial( const nvsg::Material * material );
00806
00816       NVSG_API virtual void handleTextureAttribute( const nvsg::TextureAttribute * texAttrib );
00817
00827       NVSG_API virtual void handleTextureAttributeItem( const nvsg::TextureAttributeItem * texAttribItem
00828                                                       , unsigned int tu );
00829
00838       NVSG_API virtual void handleAlphaTestAttribute( const nvsg::AlphaTestAttribute * alphaTestAttrib );
00839
00848       NVSG_API virtual void handleBlendAttribute( const nvsg::BlendAttribute * blendAttrib );
00849
00858       NVSG_API virtual void handleDepthAttribute( const nvsg::DepthAttribute * depthAttrib );
00859
00868       NVSG_API virtual void handleFaceAttribute( const nvsg::FaceAttribute * faceAttrib );
00869
00878       NVSG_API virtual void handleLightingAttribute( const nvsg::LightingAttribute * laAttrib );
00879
00888       NVSG_API virtual void handleLineAttribute( const nvsg::LineAttribute * lineAttrib );
00889
00898       NVSG_API virtual void handlePointAttribute( const nvsg::PointAttribute * pointAttrib );
00899
00908       NVSG_API virtual void handleUnlitColorAttribute( const nvsg::UnlitColorAttribute * unlitColor );
00909
00919       NVSG_API virtual void handleMapArray( const nvsg::MapArray * mapArray );
00920
00930       NVSG_API virtual void handleMapElement( const nvsg::MapElement * mapElement );
00931
00941       NVSG_API virtual void handleMapMatrix( const nvsg::MapMatrix * mapMatrix );
00942
00952       NVSG_API virtual void handleMapList( const nvsg::MapList * mapList );
00953
00962       NVSG_API virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *vas );
00963
00971       NVSG_API virtual void handleAnimatedVertexAttributeSet( const nvsg::AnimatedVertexAttributeSet * avas );
00972
00978       NVSG_API virtual void handleSkin( const nvsg::Skin * skin );
00979
00989       NVSG_API virtual void handleFramedIndexAnimation( const nvsg::FramedAnimation<unsigned int> * anim );
00990
01000       NVSG_API virtual void handleFramedTrafoAnimation( const nvsg::FramedAnimation<nvmath::Trafo> * trafo );
01001
01009       NVSG_API virtual void handleFramedVertexAttributeAnimation( const nvsg::FramedAnimation<nvsg::VertexAttribute> * p );
01010
01020       NVSG_API virtual void handleLinearInterpolatedTrafoAnimation( const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> * trafo );
01021
01029       NVSG_API virtual void handleLinearInterpolatedVertexAttributeAnimation( const nvsg::LinearInterpolatedAnimation<nvsg::VertexAttribute> * p );
01030
01041       NVSG_API virtual void handleHighlightBox( const nvsg::HighlightBox * hlBox
01042                                               , const nvsg::PrimitiveSet * pset );
01043
01054       NVSG_API virtual void handleHighlightEdges( const nvsg::HighlightEdges * hlEdges
01055                                                 , const nvsg::PrimitiveSet * pset );
01056
01066       NVSG_API virtual void handleVolumeNode( const nvsg::VolumeNode * vnode );
01067
01077       NVSG_API virtual void traverseCamera( const nvsg::Camera * camera );
01078
01088       NVSG_API virtual void traverseLight( const nvsg::LightSource * light );
01089
01101       NVSG_API virtual void traversePrimitiveSet( const nvsg::PrimitiveSet * pset );
01102
01112       NVSG_API virtual void traverseHighlightObject( const nvsg::HighlightObject * hlObject
01113                                                    , const nvsg::PrimitiveSet * pset );
01114
01115     protected:
01116       const nvsg::Scene * m_lockedScene;
01117       const nvsg::ViewState * m_lockedViewState;
01118   };
01119
01132   class ExclusiveTraverser : public Traverser
01133   {
01134     public:
01136       NVSG_API ExclusiveTraverser();
01137
01138     protected:
01140       NVSG_API virtual ~ExclusiveTraverser() {}
01141
01170       template <typename T, typename U>
01171       void addObjectHandler( unsigned int objectCode, void (T::*handler)(U*) );
01172
01201       template <typename T, typename U, typename V>
01202       void addObjectHandler( unsigned int objectCode, void (T::*handler)(U*, V) );
01203
01210       NVSG_API virtual nvsg::Object * lockObject( nvsg::ObjectHandle * obj );
01211
01217       NVSG_API virtual void unlockObject( nvsg::ObjectHandle * obj );
01218
01223       NVSG_API virtual void lockViewState();
01224
01229       NVSG_API virtual void unlockViewState();
01230
01235       NVSG_API virtual void lockScene();
01236
01241       NVSG_API virtual void unlockScene();
01242
01248       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
01249
01259       NVSG_API virtual void handleParallelCamera( nvsg::ParallelCamera * camera );
01260
01270       NVSG_API virtual void handlePerspectiveCamera( nvsg::PerspectiveCamera * camera );
01271
01281       NVSG_API virtual void handleGroup( nvsg::Group * group );
01282
01293       NVSG_API virtual void handleFlipbookAnimation( nvsg::FlipbookAnimation * anim );
01294
01304       NVSG_API virtual void handleTransform( nvsg::Transform * trafo );
01305
01316       NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransform * trafo );
01317
01327       NVSG_API virtual void handleLOD( nvsg::LOD * lod );
01328
01338       NVSG_API virtual void handleSwitch( nvsg::Switch * swtch );
01339
01349       NVSG_API virtual void handleBillboard( nvsg::Billboard * billboard );
01350
01360       NVSG_API virtual void handleDirectedLight( nvsg::DirectedLight * light );
01361
01371       NVSG_API virtual void handlePointLight( nvsg::PointLight * light );
01372
01382       NVSG_API virtual void handleSpotLight( nvsg::SpotLight * light );
01383
01393       NVSG_API virtual void handleGeoNode( nvsg::GeoNode * gnode );
01394
01404       NVSG_API virtual void handleQuads( nvsg::Quads * quads );
01405
01415       NVSG_API virtual void handleTriangles( nvsg::Triangles * triangles );
01416
01427       NVSG_API virtual void handleSkinnedTriangles( nvsg::SkinnedTriangles * triangles );
01428
01438       NVSG_API virtual void handleLines( nvsg::Lines * lines );
01439
01449       NVSG_API virtual void handlePoints( nvsg::Points * points );
01450
01460       NVSG_API virtual void handleQuadMeshes( nvsg::QuadMeshes * meshes );
01461
01471       NVSG_API virtual void handleQuadStrips( nvsg::QuadStrips * strips );
01472
01482       NVSG_API virtual void handleTriFans( nvsg::TriFans * fans );
01483
01493       NVSG_API virtual void handleTriStrips( nvsg::TriStrips * strips );
01494
01504       NVSG_API virtual void handleLineStrips( nvsg::LineStrips * strips );
01505
01515       NVSG_API virtual void handleShape( nvsg::Shape * shape );
01516
01526       NVSG_API virtual void handleStateSet( nvsg::StateSet * stateSet );
01527
01537       NVSG_API virtual void handleStateVariant( nvsg::StateVariant * variant );
01538
01548       NVSG_API virtual void handleStatePass( nvsg::StatePass * pass );
01549
01558       NVSG_API virtual void handleCgFx( nvsg::CgFx * cgfx );
01559
01568       NVSG_API virtual void handleMaterial( nvsg::Material * material );
01569
01579       NVSG_API virtual void handleTextureAttribute( nvsg::TextureAttribute * texAttrib );
01580
01590       NVSG_API virtual void handleTextureAttributeItem( nvsg::TextureAttributeItem * texAttribItem
01591                                                       , unsigned int tu );
01592
01601       NVSG_API virtual void handleAlphaTestAttribute( nvsg::AlphaTestAttribute * alphaTestAttrib );
01602
01611       NVSG_API virtual void handleBlendAttribute( nvsg::BlendAttribute * blendAttrib );
01612
01621       NVSG_API virtual void handleDepthAttribute( nvsg::DepthAttribute * depthAttrib );
01622
01631       NVSG_API virtual void handleFaceAttribute( nvsg::FaceAttribute * faceAttrib );
01632
01641       NVSG_API virtual void handleLightingAttribute( nvsg::LightingAttribute * laAttrib );
01642
01651       NVSG_API virtual void handleLineAttribute( nvsg::LineAttribute * lineAttrib );
01652
01661       NVSG_API virtual void handlePointAttribute( nvsg::PointAttribute * pointAttrib );
01662
01671       NVSG_API virtual void handleUnlitColorAttribute( nvsg::UnlitColorAttribute * unlitColor );
01672
01682       NVSG_API virtual void handleMapArray( nvsg::MapArray * mapArray );
01683
01693       NVSG_API virtual void handleMapElement( nvsg::MapElement * mapElement );
01694
01704       NVSG_API virtual void handleMapMatrix( nvsg::MapMatrix * mapMatrix );
01705
01715       NVSG_API virtual void handleMapList( nvsg::MapList * mapList );
01716
01725       NVSG_API virtual void handleVertexAttributeSet( nvsg::VertexAttributeSet *vas );
01726
01734       NVSG_API virtual void handleAnimatedVertexAttributeSet( nvsg::AnimatedVertexAttributeSet * avas );
01735
01741       NVSG_API virtual void handleSkin( nvsg::Skin * skin );
01742
01752       NVSG_API virtual void handleFramedIndexAnimation( nvsg::FramedAnimation<unsigned int> * anim );
01753
01763       NVSG_API virtual void handleFramedTrafoAnimation( nvsg::FramedAnimation<nvmath::Trafo> * trafo );
01764
01772       NVSG_API virtual void handleFramedVertexAttributeAnimation( nvsg::FramedAnimation<nvsg::VertexAttribute> * p );
01773
01783       NVSG_API virtual void handleLinearInterpolatedTrafoAnimation( nvsg::LinearInterpolatedAnimation<nvmath::Trafo> * trafo );
01784
01792       NVSG_API virtual void handleLinearInterpolatedVertexAttributeAnimation( nvsg::LinearInterpolatedAnimation<nvsg::VertexAttribute> * p );
01793
01804       NVSG_API virtual void handleHighlightBox( nvsg::HighlightBox * hlBox
01805                                               , const nvsg::PrimitiveSet * pset );
01806
01817       NVSG_API virtual void handleHighlightEdges( nvsg::HighlightEdges * hlEdges
01818                                                 , const nvsg::PrimitiveSet * pset );
01819
01829       NVSG_API virtual void handleVolumeNode( nvsg::VolumeNode * vnode );
01830
01840       NVSG_API virtual void traverseCamera( nvsg::Camera * camera );
01841
01851       NVSG_API virtual void traverseLight( nvsg::LightSource * light );
01852
01864       NVSG_API virtual void traversePrimitiveSet( nvsg::PrimitiveSet * pset );
01865
01875       NVSG_API virtual void traverseHighlightObject( nvsg::HighlightObject * hlObject
01876                                                    , const nvsg::PrimitiveSet * pset );
01877
01878     protected:
01879       nvsg::Scene * m_lockedScene;
01880       nvsg::ViewState * m_lockedViewState;
01881   };
01882
01883
01884   //--- Inline functions ------------------
01885
01886   inline void Traverser::interruptTraversal()
01887   {
01888     NVSG_TRACE();
01889     m_interrupt = true;
01890   }
01891
01892   inline bool Traverser::wasTraversalInterrupted()
01893   {
01894     NVSG_TRACE();
01895     return !!(m_traverserBits & NVSG_TRAVERSAL_INTERRUPTED);
01896   }
01897
01898   inline void Traverser::traverseObject(nvsg::ObjectHandle * obj)
01899   {
01900     NVSG_TRACE();
01901     if ( m_interrupt )
01902     {
01903       // there was an interrupt request.
01904       // directly quit traversal
01905       m_traverserBits |= NVSG_TRAVERSAL_INTERRUPTED;
01906       return;
01907     }
01908     traverseLockedObject(lockObject(obj));
01909     unlockObject(obj);
01910   }
01911
01912   template <typename T>
01913   inline void Traverser::traverseObject(nvsg::ObjectHandle * obj, T arg)
01914   {
01915     NVSG_TRACE();
01916     if ( m_interrupt )
01917     {
01918       // there was an interrupt request.
01919       // directly quit traversal
01920       m_traverserBits |= NVSG_TRAVERSAL_INTERRUPTED;
01921       return;
01922     }
01923     traverseLockedObject(lockObject(obj), arg);
01924     unlockObject(obj);
01925   }
01926
01927   inline void Traverser::traverseLockedObject(const nvsg::Object * obj)
01928   {
01929     unsigned int oc = getObjectTraversalCode( obj );
01930     if ( nvsg::OC_INVALID != oc )
01931     {
01932 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01933       void * __esp__0;
01934       void * __esp__1;
01935       __asm mov __esp__0, esp
01936 #endif
01937         (this->*(void (Traverser::*)(const nvsg::Object*))m_mftbl[oc])(obj);
01938 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01939       __asm mov __esp__1, esp
01940       NVSG_ASSERT(__esp__1==__esp__0);
01941 #endif
01942     }
01943   }
01944
01945   template <typename T>
01946   inline void Traverser::traverseLockedObject(const nvsg::Object * obj, T arg)
01947   {
01948     unsigned int oc = getObjectTraversalCode( obj );
01949     if ( nvsg::OC_INVALID != oc )
01950     {
01951 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01952       void * __esp__0;
01953       void * __esp__1;
01954       __asm mov __esp__0, esp
01955 #endif
01956         (this->*(void (Traverser::*)(const nvsg::Object*,T))m_mftbl[oc])(obj, arg);
01957 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01958       __asm mov __esp__1, esp
01959       NVSG_ASSERT(__esp__1==__esp__0);
01960 #endif
01961     }
01962   }
01963
01964   template <typename T, typename U>
01965   inline void SharedTraverser::addObjectHandler(unsigned int objectCode, void (T::*handler)(const U*))
01966   {
01967     NVSG_CTASSERT(SUPERSUBCLASS(SharedTraverser,T));
01968     m_mftbl.addEntry(objectCode, handler);
01969   }
01970
01971   template <typename T, typename U, typename V>
01972   inline void SharedTraverser::addObjectHandler(unsigned int objectCode, void (T::*handler)(const U*, V))
01973   {
01974     NVSG_CTASSERT(SUPERSUBCLASS(SharedTraverser,T));
01975     m_mftbl.addEntry(objectCode, handler);
01976   }
01977
01978   template <typename T, typename U>
01979   inline void ExclusiveTraverser::addObjectHandler(unsigned int objectCode, void (T::*handler)(U*))
01980   {
01981     NVSG_CTASSERT(SUPERSUBCLASS(ExclusiveTraverser,T));
01982     m_mftbl.addEntry(objectCode, handler);
01983   }
01984
01985   template <typename T, typename U, typename V>
01986   inline void ExclusiveTraverser::addObjectHandler(unsigned int objectCode, void (T::*handler)(U*, V))
01987   {
01988     NVSG_CTASSERT(SUPERSUBCLASS(ExclusiveTraverser,T));
01989     m_mftbl.addEntry(objectCode, handler);
01990   }
01991
01992 } // namespace nvtraverser}
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Triangles.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Face.h"
#include "nvsg/IndependentPrimitiveSet.h"

Include dependency graph for Triangles.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:29 2008 for NVSGSDK by NVIDIA


Triangles.h Source File

Triangles.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/Face.h"
00017 #include "nvsg/IndependentPrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00027   class Triangles : public IndependentPrimitiveSet
00028   {
00029     public:
00031       NVSG_API Triangles();
00032
00034       NVSG_API Triangles( const IndependentPrimitiveSet &rhs );
00035
00037       NVSG_API Triangles( const PrimitiveSet &rhs );
00038
00040       NVSG_API Triangles( const Triangles &rhs );
00041
00043       NVSG_API virtual ~Triangles();
00044
00049       NVSG_API bool hasFaces() const;
00050
00055       NVSG_API unsigned int getNumberOfFaces() const;
00056
00061       NVSG_API const Face3 * getFaces() const;
00062
00071       NVSG_API void setFaces( const Face3 * faces, unsigned int numFaces );
00072
00088       NVSG_API void setFaces( unsigned int pos, const Face3 * faces, unsigned int numFaces );
00089
00095       NVSG_API Triangles & operator=(const Triangles & rhs);
00096
00097   };
00098
00108   NVSG_API void calculateTangentSpace( Triangles * t
00109                                      , unsigned int tu = 0
00110                                      , unsigned int tg = 1
00111                                      , unsigned int bn = 2 );
00112
00117   NVSG_API void generateNormals( Triangles * t );
00118
00119   // - - - - - - - - - - - - - - - - - - - - - - - - -
00120   // inlines
00121   // - - - - - - - - - - - - - - - - - - - - - - - - -
00122
00123   inline bool Triangles::hasFaces()  const
00124   {
00125     NVSG_TRACE();
00126     return( 3 <= getNumberOfIndices() );
00127   }
00128
00129   inline unsigned int Triangles::getNumberOfFaces()  const
00130   {
00131     NVSG_TRACE();
00132     return( getNumberOfIndices() / 3 );
00133   }
00134
00135   inline const Face3 * Triangles::getFaces() const
00136   {
00137     NVSG_TRACE();
00138     return( (const Face3 *) getIndices() );
00139   }
00140
00141   inline void Triangles::setFaces( const Face3* pFaces, unsigned int numFaces )
00142   {
00143     NVSG_TRACE();
00144     setIndices( (const unsigned int *) pFaces, 3 * numFaces );
00145   }
00146
00147   inline void Triangles::setFaces( unsigned int pos, const Face3* pFaces, unsigned int numFaces )
00148   {
00149     NVSG_TRACE();
00150     if ( pos != ~0 )
00151     {
00152       pos *= 3;
00153     }
00154     setIndices( pos, (const unsigned int *) pFaces, 3 * numFaces );
00155   }
00156 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TriangulateTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvtraverser/Traverser.h"

Include dependency graph for TriangulateTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:29 2008 for NVSGSDK by NVIDIA


TriangulateTraverser.h Source File

TriangulateTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include  "nvtraverser/Traverser.h"
00017
00018 namespace nvtraverser
00019 {
00020
00022
00023   class TriangulateTraverser : public ExclusiveTraverser
00024 {
00025   public:
00027     NVSG_API TriangulateTraverser(void);
00028
00029   protected:
00031     NVSG_API virtual ~TriangulateTraverser(void);
00032
00034
00035     NVSG_API virtual void  handleGeoNode(
00036       nvsg::GeoNode *p
00037     );
00038
00040
00041     NVSG_API virtual void  handleQuads(
00042       nvsg::Quads *p
00043     );
00044
00046
00047     NVSG_API virtual void  handleQuadStrips(
00048       nvsg::QuadStrips *p
00049     );
00050
00051   private:
00052     std::vector<std::pair<nvsg::PrimitiveSetHandle*,nvsg::PrimitiveSetHandle*> >  m_primitiveSetReplaces;
00053 };
00054
00055 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TriFans.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/StrippedPrimitiveSet.h"

Include dependency graph for TriFans.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:29 2008 for NVSGSDK by NVIDIA


TriFans.h Source File

TriFans.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/nvsg.h"
00017 #include "nvsg/StrippedPrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00027   class TriFans : public StrippedPrimitiveSet
00028   {
00029     public:
00031       NVSG_API TriFans();
00032
00034       NVSG_API explicit TriFans( const StrippedPrimitiveSet &rhs );
00035
00037       NVSG_API explicit TriFans( const TriFans &rhs );
00038
00040       NVSG_API virtual ~TriFans();
00041
00046       NVSG_API TriFans & operator=(const TriFans & rhs);
00047   };
00048
00058   NVSG_API void calculateTangentSpace( TriFans * tf
00059                                      , unsigned int tu = 0
00060                                      , unsigned int tg = 1
00061                                      , unsigned int bn = 2 );
00062
00067   NVSG_API void generateNormals( TriFans * q );
00068
00069 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TriStrips.h File Reference

#include "nvsgcommon.h"
#include "nvsg/StrippedPrimitiveSet.h"
#include "nvsg/nvsg.h"

Include dependency graph for TriStrips.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:30 2008 for NVSGSDK by NVIDIA


TriStrips.h Source File

TriStrips.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/StrippedPrimitiveSet.h"
00017 #include "nvsg/nvsg.h"
00018
00019 namespace nvsg
00020 {
00037   class TriStrips : public StrippedPrimitiveSet
00038   {
00039     public:
00041       NVSG_API TriStrips();
00042
00044       NVSG_API explicit TriStrips( const StrippedPrimitiveSet &rhs );
00045
00047       NVSG_API explicit TriStrips( const TriStrips &rhs );
00048
00050       NVSG_API virtual ~TriStrips();
00051
00056       NVSG_API TriStrips & operator=(const TriStrips & rhs);
00057   };
00058
00068   NVSG_API void calculateTangentSpace( TriStrips * ts
00069                                      , unsigned int tu = 0
00070                                      , unsigned int tg = 1
00071                                      , unsigned int bn = 2 );
00072
00077   NVSG_API void generateNormals( TriStrips * q );
00078
00079 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


UnlitColorAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vecnt.h"
#include "nvsg/StateAttribute.h"

Include dependency graph for UnlitColorAttribute.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:30 2008 for NVSGSDK by NVIDIA


UnlitColorAttribute.h Source File

UnlitColorAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Vecnt.h"
00017 #include "nvsg/StateAttribute.h"
00018
00019 namespace nvsg
00020 {
00026   class UnlitColorAttribute : public StateAttribute
00027   {
00028     public:
00032       NVSG_API UnlitColorAttribute();
00033
00037       NVSG_API explicit UnlitColorAttribute( const StateAttribute &rhs );
00038
00040       NVSG_API UnlitColorAttribute( const UnlitColorAttribute &rhs );
00041
00043       NVSG_API virtual ~UnlitColorAttribute();
00044
00048       NVSG_API const nvmath::Vec4f & getColor() const;
00049
00053       NVSG_API void setColor( const nvmath::Vec4f & color );
00054
00055     private:
00056       nvmath::Vec4f m_color;
00057   };
00058
00059   inline const nvmath::Vec4f & UnlitColorAttribute::getColor() const
00060   {
00061     NVSG_TRACE();
00062     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00063     return( m_color );
00064   }
00065
00066   inline void UnlitColorAttribute::setColor( const nvmath::Vec4f & color )
00067   {
00068     NVSG_TRACE();
00069     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00070     if ( m_color != color )
00071     {
00072       m_color = color;
00073       invalidateIncarnation();
00074     }
00075   }
00076
00077 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Validated.h File Reference

#include "nvsgcommon.h"

Include dependency graph for Validated.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvutil

Detailed Description

Generated on Tue Jan 15 10:28:30 2008 for NVSGSDK by NVIDIA


Validated.h Source File

Validated.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2004
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 namespace nvutil
00018 {
00020   template<typename T> class Validated
00021   {
00022     public:
00024       Validated( void );
00025
00027       Validated( const T & t );
00028
00029     public:
00031
00032       bool isValid( void ) const;
00033
00035       void invalidate( void );
00036
00038       void validate( void );
00039
00041
00043       const T & get( void ) const;
00044
00046
00047       void set( const T & t );
00048
00049     private:
00050       T     m_data;
00051       bool  m_valid;
00052   };
00053
00054   template<typename T>
00055     inline Validated<T>::Validated( void )
00056     : m_valid(false)
00057   {
00058   }
00059
00060   template<typename T>
00061     inline Validated<T>::Validated( const T & t )
00062   {
00063     set( t );
00064   }
00065
00066   template<typename T>
00067     inline bool Validated<T>::isValid( void ) const
00068   {
00069     return( m_valid );
00070   }
00071
00072   template<typename T>
00073     inline void Validated<T>::invalidate( void )
00074   {
00075     m_valid = false;
00076   }
00077
00078   template<typename T>
00079     inline void Validated<T>::validate( void )
00080   {
00081     m_valid = true;
00082   }
00083
00084   template<typename T>
00085     inline const T & Validated<T>::get( void ) const
00086   {
00087     NVSG_ASSERT( m_valid );
00088     return( m_data );
00089   }
00090
00091   template<typename T>
00092     inline void Validated<T>::set( const T & t )
00093   {
00094     m_data = t;
00095     validate();
00096   }
00097 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Vecnt.h File Reference

#include "nvsgcommon.h"
#include <limits>
#include <vector>
#include <list>
#include <math.h>

Include dependency graph for Vecnt.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvmath

Detailed Description

Generated on Tue Jan 15 10:28:31 2008 for NVSGSDK by NVIDIA


Vecnt.h Source File

Vecnt.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include <limits>
00017 #include <vector>
00018 #include <list>
00019 #include <math.h>
00020
00021 namespace nvmath
00022 {
00023   template<unsigned int n, typename T> class Spherent;
00024
00029   template<unsigned int n, typename T> class Vecnt
00030   {
00031     public:
00034       Vecnt();
00035
00041       template<unsigned int m, typename S>
00042         explicit Vecnt( const Vecnt<m,S> & rhs );
00043
00056       template<typename S, typename R>
00057         Vecnt( const Vecnt<n-1,S> & rhs, R last );
00058
00068       Vecnt( T x, T y );
00069
00081       Vecnt( T x, T y, T z );
00082
00095       Vecnt( T x, T y, T z, T w );
00096
00097     public:
00105       const T * getPtr() const;
00106
00109       T normalize();
00110
00117       template<typename S>
00118         T & operator[]( S i );
00119
00126       template<typename S>
00127         const T & operator[]( S i ) const;
00128
00133       template<typename S>
00134         Vecnt<n,T> & operator=( const Vecnt<n,S> & rhs );
00135
00140       template<typename S>
00141         Vecnt<n,T> & operator+=( const Vecnt<n,S> & rhs );
00142
00147       template<typename S>
00148         Vecnt<n,T> & operator-=( const Vecnt<n,S> & rhs );
00149
00154       template<typename S>
00155         Vecnt<n,T> & operator*=( S s );
00156
00162       template<typename S>
00163         Vecnt<n,T> & operator/=( S s );
00164
00169       void orthonormalize( const Vecnt<n,T> & v );
00170
00171     private:
00172       T m_vec[n];
00173   };
00174
00175
00176   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00177   // non-member functions
00178   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00179
00185   template<unsigned int n, typename T>
00186     void boundingBox( const Vecnt<n,T> * points, size_t numberOfPoints, Vecnt<n,T> & min, Vecnt<n,T> & max );
00187
00195   template<unsigned int n, typename T>
00196     bool areOpposite( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1
00197                     , T eps = std::numeric_limits<T>::epsilon() )
00198   {
00199     NVSG_PRIVATE_ASSERT( isNormalized( v0 ) && isNormalized( v1 ) );
00200     return( ( 1 + v0 * v1 ) <= eps );
00201   }
00202
00210   template<unsigned int n, typename T>
00211     bool areOrthogonal( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1
00212                       , T eps = 2 * std::numeric_limits<T>::epsilon() )
00213   {
00214     return( abs(v0*v1) <= std::max(T(1),length(v0)) * std::max(T(1),length(v1)) * eps );
00215   }
00216
00225   template<unsigned int n, typename T>
00226     bool areOrthonormal( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1
00227                        , T eps = 2 * std::numeric_limits<T>::epsilon() )
00228   {
00229     return( isNormalized(v0) && isNormalized(v1) && ( abs(v0*v1) <= eps ) );
00230   }
00231
00239   template<unsigned int n, typename T>
00240     bool areSimilar( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1, T eps );
00241
00247   template<unsigned int n, typename T>
00248     T distance( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 );
00249
00255   template<unsigned int n, typename T>
00256     bool isNormalized( const Vecnt<n,T> & v, T eps = std::numeric_limits<T>::epsilon() )
00257   {
00258     return( abs( length( v ) - 1 ) <= eps );
00259   }
00260
00266   template<unsigned int n, typename T>
00267     bool isNull( const Vecnt<n,T> & v, T eps = std::numeric_limits<T>::epsilon() )
00268   {
00269     return( length( v ) <= eps );
00270   }
00271
00276   template<unsigned int n, typename T>
00277     T length( const Vecnt<n,T> & v );
00278
00283   template<unsigned int n, typename T>
00284     T lengthSquared( const Vecnt<n,T> & v );
00285
00290   template<unsigned int n, typename T>
00291     T maxElement( const Vecnt<n,T> & v );
00292
00297   template<unsigned int n, typename T>
00298     T minElement( const Vecnt<n,T> & v );
00299
00304   template<unsigned int n, typename T>
00305     T  normalize( Vecnt<n,T> & v );
00306
00313   template<unsigned int n, typename T>
00314     bool operator==( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 );
00315
00322   template<unsigned int n, typename T>
00323     bool operator!=( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 );
00324
00330   template<unsigned int n, typename T>
00331     Vecnt<n,T> operator+( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 );
00332
00337   template<unsigned int n, typename T>
00338     Vecnt<n,T> operator-( const Vecnt<n,T> & v );
00339
00345   template<unsigned int n, typename T>
00346     Vecnt<n,T> operator-( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 );
00347
00353   template<unsigned int n, typename T>
00354     Vecnt<n,T> operator*( const Vecnt<n,T> & v, T s );
00355
00361   template<unsigned int n, typename T>
00362     Vecnt<n,T> operator*( T s, const Vecnt<n,T> & v );
00363
00369   template<unsigned int n, typename T>
00370     T operator*( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 );
00371
00377   template<unsigned int n, typename T>
00378     Vecnt<n,T> operator/( const Vecnt<n,T> & v, T s );
00379
00391   template<unsigned int n, typename T>
00392     Vecnt<n,T> orthonormalize( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 );
00393
00394
00395   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00396   // non-member functions, specialized for n == 2
00397   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00398
00403   template<typename T>
00404     Vecnt<2,T> & setVec( Vecnt<2,T> & v, T x, T y );
00405
00406   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00407   // non-member functions, specialized for n == 3
00408   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00409
00416   template<typename T>
00417     bool areCollinear( const Vecnt<3,T> &v0, const Vecnt<3,T> &v1
00418                      , T eps = std::numeric_limits<T>::epsilon() )
00419   {
00420     return( length( v0 ^ v1 ) < eps );
00421   }
00422
00428   template<typename T>
00429     Vecnt<3,T> operator^( const Vecnt<3,T> &v0, const Vecnt<3,T> &v1 );
00430
00436   template<typename T>
00437     Vecnt<3,T> & setVec( Vecnt<3,T> & v, T x, T y, T z );
00438
00448   template<typename T>
00449     void smoothNormals( const std::vector<Vecnt<3,T> > &vertices, const Spherent<3,T> &sphere
00450                       , T creaseAngle, std::vector<Vecnt<3,T> > &normals );
00451
00452
00453   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00454   // non-member functions, specialized for n == 4
00455   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00456
00463   template<typename T>
00464     Vecnt<4,T> & setVec( Vecnt<4,T> & v, T x, T y, T z, T w );
00465
00466
00467   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00468   // Convenience type definitions
00469   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00470   typedef Vecnt<2,float>  Vec2f;
00471   typedef Vecnt<2,double> Vec2d;
00472   typedef Vecnt<3,float>  Vec3f;
00473   typedef Vecnt<3,double> Vec3d;
00474   typedef Vecnt<4,float>  Vec4f;
00475   typedef Vecnt<4,double> Vec4d;
00476
00477
00478   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00479   // inlined member functions
00480   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00481
00482   template<unsigned int n, typename T>
00483   inline Vecnt<n,T>::Vecnt()
00484   {
00485   }
00486
00487   template<unsigned int n, typename T>
00488   template<unsigned int m, typename S>
00489   inline Vecnt<n,T>::Vecnt( const Vecnt<m,S> & rhs )
00490   {
00491     for ( unsigned int i=0 ; i<std::min( n, m ) ; ++i )
00492     {
00493       m_vec[i] = (T)rhs[i];
00494     }
00495   }
00496
00497   template<unsigned int n, typename T>
00498   template<typename S, typename R>
00499   inline Vecnt<n,T>::Vecnt( const Vecnt<n-1,S> & rhs, R last )
00500   {
00501     for ( unsigned int i=0 ; i<n-1 ; ++i )
00502     {
00503       m_vec[i] = (T)rhs[i];
00504     }
00505     m_vec[n-1] = (T)last;
00506   }
00507
00508   template<unsigned int n, typename T>
00509   inline Vecnt<n,T>::Vecnt( T x, T y )
00510   {
00511     setVec( *this, x, y );
00512   }
00513
00514   template<unsigned int n, typename T>
00515   inline Vecnt<n,T>::Vecnt( T x, T y, T z )
00516   {
00517     setVec( *this, x, y, z );
00518   }
00519
00520   template<unsigned int n, typename T>
00521   inline Vecnt<n,T>::Vecnt( T x, T y, T z, T w )
00522   {
00523     setVec( *this, x, y, z, w );
00524   }
00525
00526   template<unsigned int n, typename T>
00527   inline const T * Vecnt<n,T>::getPtr() const
00528   {
00529     return( &m_vec[0] );
00530   }
00531
00532   template<unsigned int n, typename T>
00533   inline T Vecnt<n,T>::normalize()
00534   {
00535     return( nvmath::normalize( *this ) );
00536   }
00537
00538   template<unsigned int n, typename T>
00539   template<typename S>
00540   inline T & Vecnt<n,T>::operator[]( S i )
00541   {
00542     NVSG_CTASSERT( std::numeric_limits<S>::is_integer );
00543     NVSG_ASSERT( i < n );
00544     return( m_vec[i] );
00545   }
00546
00547   template<unsigned int n, typename T>
00548   template<typename S>
00549   inline const T & Vecnt<n,T>::operator[]( S i ) const
00550   {
00551     NVSG_CTASSERT( std::numeric_limits<S>::is_integer );
00552     NVSG_ASSERT( i < n );
00553     return( m_vec[i] );
00554   }
00555
00556   template<unsigned int n, typename T>
00557   template<typename S>
00558   inline Vecnt<n,T> & Vecnt<n,T>::operator=( const Vecnt<n,S> & rhs )
00559   {
00560     for ( unsigned int i=0 ; i<n ; ++i )
00561     {
00562       m_vec[i] = T(rhs[i]);
00563     }
00564     return( *this );
00565   }
00566
00567   template<unsigned int n, typename T>
00568   template<typename S>
00569   inline Vecnt<n,T> & Vecnt<n,T>::operator+=( const Vecnt<n,S> & rhs )
00570   {
00571     for ( unsigned int i=0 ; i<n ; ++i )
00572     {
00573       m_vec[i] += T(rhs[i]);
00574     }
00575     return( *this );
00576   }
00577
00578   template<unsigned int n, typename T>
00579   template<typename S>
00580   inline Vecnt<n,T> & Vecnt<n,T>::operator-=( const Vecnt<n,S> & rhs )
00581   {
00582     for ( unsigned int i=0 ; i<n ; ++i )
00583     {
00584       m_vec[i] -= T(rhs[i]);
00585     }
00586     return( *this );
00587   }
00588
00589   template<unsigned int n, typename T>
00590   template<typename S>
00591   inline Vecnt<n,T> & Vecnt<n,T>::operator*=( S s )
00592   {
00593     for ( unsigned int i=0 ; i<n ; ++i )
00594     {
00595       m_vec[i] *= T(s);
00596     }
00597     return( *this );
00598   }
00599
00600   template<unsigned int n, typename T>
00601   template<typename S>
00602   inline Vecnt<n,T> & Vecnt<n,T>::operator/=( S s )
00603   {
00604     NVSG_PRIVATE_ASSERT( std::numeric_limits<S>::epsilon() < abs(s) );
00605     for ( unsigned int i=0 ; i<n ; ++i )
00606     {
00607       m_vec[i] /= T(s);
00608     }
00609     return( *this );
00610   }
00611
00612   template<unsigned int n, typename T>
00613   inline void Vecnt<n,T>::orthonormalize( const Vecnt<n,T> & v )
00614   {
00615     *this = nvmath::orthonormalize( v, *this );
00616   }
00617
00618
00619   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00620   // inlined non-member functions
00621   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00622
00623   template<unsigned int n, typename T>
00624   inline void boundingBox( const Vecnt<n,T> * points, size_t numberOfPoints, Vecnt<n,T> & min, Vecnt<n,T> & max )
00625   {
00626     NVSG_ASSERT( 0 < n );
00627     min = max = points[0];
00628     for ( size_t i=1 ; i<numberOfPoints ; i++ )
00629     {
00630       for ( unsigned int j=0 ; j<n ; j++ )
00631       {
00632         if ( points[i][j] < min[j] )
00633         {
00634           min[j] = points[i][j];
00635         }
00636         else if ( max[j] < points[i][j] )
00637         {
00638           max[j] = points[i][j];
00639         }
00640       }
00641     }
00642   }
00643
00644   template<unsigned int n, typename T>
00645   inline bool  areSimilar( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1, T eps )
00646   {
00647     bool eq = true;
00648     for ( unsigned int i=0 ; eq && i<n ; ++i )
00649     {
00650       eq = ( abs( v0[i] - v1[i] ) < eps );
00651     }
00652     return( eq );
00653   }
00654
00655   template<unsigned int n, typename T>
00656   inline T distance( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 )
00657   {
00658     return( length( v0 - v1 ) );
00659   }
00660
00661   template<unsigned int n, typename T>
00662   inline T length( const Vecnt<n,T> & v )
00663   {
00664     return( sqrt( lengthSquared( v ) ) );
00665   }
00666
00667   template<unsigned int n, typename T>
00668   inline T lengthSquared( const Vecnt<n,T> & v )
00669   {
00670     return( v * v );
00671   }
00672
00673   template<unsigned int n, typename T>
00674   inline T maxElement( const Vecnt<n,T> & v )
00675   {
00676     T me = abs( v[0] );
00677     for ( unsigned int i=1 ; i<n ; ++i )
00678     {
00679       T t = abs( v[i] );
00680       if ( me < t )
00681       {
00682         me = t;
00683       }
00684     }
00685     return( me );
00686   }
00687
00688   template<unsigned int n, typename T>
00689   inline T minElement( const Vecnt<n,T> & v )
00690   {
00691     T me = abs( v[0] );
00692     for ( unsigned int i=1 ; i<n ; ++i )
00693     {
00694       T t = abs( v[i] );
00695       if ( t < me )
00696       {
00697         me = t;
00698       }
00699     }
00700     return( me );
00701   }
00702
00703   template<unsigned int n, typename T>
00704   inline T normalize( Vecnt<n,T> & v )
00705   {
00706     T norm = length( v );
00707     if ( std::numeric_limits<T>::epsilon() < norm )
00708     {
00709       v /= norm;
00710       //  NVSG_PRIVATE_ASSERT( isNormalized( v ) ); // due to rounding errors this assertion might fail !
00711     }
00712     return( norm );
00713   }
00714
00715   template<unsigned int n>
00716   inline float normalize( Vecnt<n,float> & v )
00717   {
00718     Vecnt<n,double> vd(v);
00719     double norm = normalize( vd );
00720     v = vd;
00721     NVSG_PRIVATE_ASSERT( ( norm <= std::numeric_limits<double>::epsilon() ) || isNormalized(v) );
00722     return( (float)norm );
00723   }
00724
00725   template<unsigned int n, typename T>
00726   inline bool  operator==( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 )
00727   {
00728     bool eq = true;
00729     for ( unsigned int i=0 ; eq && i<n ; ++i )
00730     {
00731       eq = ( abs( v0[i] - v1[i] ) < std::numeric_limits<T>::epsilon() );
00732     }
00733     return( eq );
00734   }
00735
00736   template<unsigned int n, typename T>
00737   inline bool  operator!=( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 )
00738   {
00739     return( ! ( v0 == v1 ) );
00740   }
00741
00742   template<unsigned int n, typename T>
00743   inline Vecnt<n,T>  operator+( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 )
00744   {
00745     Vecnt<n,T> ret(v0);
00746     ret += v1;
00747     return( ret );
00748   }
00749
00750   template<unsigned int n, typename T>
00751   inline Vecnt<n,T>  operator-( const Vecnt<n,T> & v )
00752   {
00753     Vecnt<n,T> ret;
00754     for ( unsigned int i=0 ; i<n ; ++i )
00755     {
00756       ret[i] = - v[i];
00757     }
00758     return( ret );
00759   }
00760
00761   template<unsigned int n, typename T>
00762   inline Vecnt<n,T>  operator-( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 )
00763   {
00764     Vecnt<n,T> ret(v0);
00765     ret -= v1;
00766     return( ret );
00767   }
00768
00769   template<unsigned int n, typename T>
00770   inline Vecnt<n,T>  operator*( const Vecnt<n,T> & v, T s )
00771   {
00772     Vecnt<n,T> ret(v);
00773     ret *= s;
00774     return( ret );
00775   }
00776
00777   template<unsigned int n, typename T>
00778   inline Vecnt<n,T>  operator*( T s, const Vecnt<n,T> & v )
00779   {
00780     return( v * s );
00781   }
00782
00783   template<unsigned int n, typename T>
00784   inline T operator*( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 )
00785   {
00786     T ret(0);
00787     for ( unsigned int i=0 ; i<n ; ++i )
00788     {
00789       ret += v0[i] * v1[i];
00790     }
00791     return( ret );
00792   }
00793
00794   template<unsigned int n, typename T>
00795   inline Vecnt<n,T>  operator/( const Vecnt<n,T> & v, T s )
00796   {
00797     Vecnt<n,T> ret(v);
00798     ret /= s;
00799     return( ret );
00800   }
00801
00802   template<unsigned int n, typename T>
00803   inline Vecnt<n,T>  orthonormalize( const Vecnt<n,T> & v0, const Vecnt<n,T> & v1 )
00804   {
00805     NVSG_PRIVATE_ASSERT( isNormalized( v0 ) && isNormalized( v1 ) && !areCollinear( v0, v1 ) );
00806     //  determine the orthogonal projection of v1 on v0 : ( v0 * v1 ) * v0
00807     //  and subtract it from v1 resulting in the orthogonalized version of v1
00808     Vecnt<n,T> vr = v1 - ( v0 * v1 ) * v0;
00809     vr.normalize();
00810     //  don't assert the general case, because this orthonormalization is far from exact
00811     //  NVSG_PRIVATE_ASSERT( areOrthonormal( vr, v0 ) );
00812     return( vr );
00813   }
00814
00815   template<typename T>
00816   inline Vecnt<3,T> orthonormalize( const Vecnt<3,T> & v0, const Vecnt<3,T> & v1 )
00817   {
00818     NVSG_PRIVATE_ASSERT( isNormalized( v0 ) && isNormalized( v1 ) && !areCollinear( v0, v1 ) );
00819     Vecnt<3,T> vr = v0 ^ ( v1 ^ v0 );
00820     vr.normalize();
00821     NVSG_PRIVATE_ASSERT( areOrthonormal( vr, v0 ) );
00822     return( vr );
00823   }
00824
00825
00826   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00827   // inlined non-member functions, specialized for n == 2
00828   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00829
00830   template<typename T>
00831   inline Vecnt<2,T> & setVec( Vecnt<2,T> & v, T x, T y )
00832   {
00833     v[0] = x;
00834     v[1] = y;
00835     return( v );
00836   }
00837
00838
00839   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00840   // inlined non-member functions, specialized for n == 3
00841   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00842
00843   template<typename T>
00844   inline Vecnt<3,T> operator^( const Vecnt<3,T> &v0, const Vecnt<3,T> &v1 )
00845   {
00846     Vecnt<3,T> ret;
00847     ret[0] = v0[1] * v1[2] - v0[2] * v1[1];
00848     ret[1] = v0[2] * v1[0] - v0[0] * v1[2];
00849     ret[2] = v0[0] * v1[1] - v0[1] * v1[0];
00850     NVSG_PRIVATE_ASSERT( areOrthogonal( ret, v0 ) && areOrthogonal( ret, v1 ) );
00851     return( ret );
00852   }
00853
00854   template<typename T>
00855   inline Vecnt<3,T> & setVec( Vecnt<3,T> & v, T x, T y, T z )
00856   {
00857     v[0] = x;
00858     v[1] = y;
00859     v[2] = z;
00860     return( v );
00861   }
00862
00863   template<typename T>
00864   size_t _hash( const Vecnt<3,T> &vertex, const Vecnt<3,T> &base, const Vecnt<3,T> &scale
00865               , size_t numVertices )
00866   {
00867 #if 1
00868     size_t value = static_cast<size_t>(floor( ( vertex - base ) * scale ));
00869     NVSG_ASSERT( value < numVertices );
00870     return( value );
00871 #else
00872     int value = (int) floor( ( vertex - base ) * scale );
00873     if ( value < 0 )
00874     {
00875       value = 0;
00876     }
00877     else if ( numVertices <= value )
00878     {
00879       value = (int) numVertices - 1;
00880     }
00881     return( value );
00882 #endif
00883   }
00884
00885   template<typename T>
00886   inline void smoothNormals( const std::vector<Vecnt<3,T> > &vertices, const Spherent<3,T> &sphere
00887                            , T creaseAngle, std::vector<Vecnt<3,T> > &normals )
00888   {
00889     if ( creaseAngle < T(0.01) )
00890     {
00891       for_each( normals.begin(), normals.end(), std::mem_fun_ref(&Vecnt<3,T>::normalize) );
00892     }
00893     else
00894     {
00895       //  the face normals are un-normalized (for weighting them in the smoothing process)
00896       //  and we need the normalized too
00897       std::vector<Vecnt<3,T> > normalizedNormals(normals);
00898       for_each( normalizedNormals.begin(), normalizedNormals.end()
00899               , std::mem_fun_ref(&Vecnt<3,T>::normalize) );
00900
00901       //  the tolerance to distinguish different points is a function of the given radius
00902       T tolerance = sphere.getRadius() / 10000;
00903
00904       //  the toleranceVector is used to determine all slices of the bounding box (_hash entries)
00905       //  within the given tolerance from the current point
00906       Vecnt<3,T> toleranceVector( tolerance, tolerance, tolerance );
00907
00908       //  we create a _hash by using diagonal slices through the bounding box (or some approximation
00909       //  to it)
00910       T halfWidth = sphere.getRadius() + tolerance;
00911       Vecnt<3,T> hashBase = sphere.getCenter() - Vecnt<3,T>( halfWidth, halfWidth, halfWidth );
00912
00913       //  The _hash function is a linear function of x, y, and z such that one corner of the
00914       //  bounding box (hashBase) maps to the key "0" and the opposite corner maps to the key
00915       //  "numVertices()".
00916       T scale = vertices.size() / ( 3 * 2 * halfWidth ) ;
00917       Vecnt<3,T> hashScale( scale, scale, scale );
00918
00919       //  The "indirect" table is a circularly linked list of indices that are within tolerance of
00920       //  each other.
00921       std::vector<size_t>  indirect( vertices.size() );
00922
00923       //  create a _hash table as a vector of lists of indices into the vertex array
00924       std::vector<std::list<size_t> > hashTable( vertices.size() );
00925       for ( size_t i=0 ; i<vertices.size() ; i++ )
00926       {
00927         //  look for an other (previous) vertex that is within tolerance
00928         bool found = false;
00929         size_t lowHashValue = _hash( vertices[i] - toleranceVector, hashBase, hashScale, vertices.size() );
00930         size_t highHashValue = _hash( vertices[i] + toleranceVector, hashBase, hashScale, vertices.size() );
00931         for ( size_t hv=lowHashValue ; ! found && hv<=highHashValue ; hv++ )
00932         {
00933           for ( std::list<size_t>::const_iterator hlit=hashTable[hv].begin()
00934             ; ! found && hlit!=hashTable[hv].end()
00935             ; ++hlit )
00936           {
00937             if ( areSimilar( vertices[i], vertices[*hlit], tolerance ) )
00938             {
00939               indirect[i] = indirect[*hlit];
00940               indirect[*hlit] = i;
00941               found = true;
00942             }
00943           }
00944         }
00945
00946         if ( ! found )
00947         {
00948           //  there is no similar (previous) point, so add it to the hashTable
00949           size_t hashValue = _hash( vertices[i], hashBase, hashScale, vertices.size() );
00950           hashTable[hashValue].push_back( i );
00951           indirect[i] = i;
00952         }
00953       }
00954
00955       //  now the indirect vector maps all vertices i to the (similar) vertex j
00956       std::vector<Vecnt<3,T> > vertexNormals( vertices.size() );
00957       T cosCreaseAngle = cos( creaseAngle );
00958       for ( size_t i=0 ; i<vertices.size() ; i++ )
00959       {
00960         Vecnt<3,T> sum = normals[i];
00961         for ( size_t j=indirect[i] ; j!=i ; j=indirect[j] )
00962         {
00963           if ( normalizedNormals[i] * normalizedNormals[j] > cosCreaseAngle )
00964           {
00965             sum += normals[j];
00966           }
00967         }
00968         sum.normalize();
00969         vertexNormals[i] = sum;
00970       }
00971
00972       //  finally, set the vertex normals
00973       normals.swap( vertexNormals );
00974     }
00975   }
00976
00977
00978   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00979   // inlined non-member functions, specialized for n == 4
00980   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00981
00982   template<typename T>
00983   inline Vecnt<4,T> & setVec( Vecnt<4,T> & v, T x, T y, T z, T w )
00984   {
00985     v[0] = x;
00986     v[1] = y;
00987     v[2] = z;
00988     v[3] = w;
00989     return( v );
00990   }
00991 } // namespace nvmath
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VertexAttribute.h File Reference

#include "nvsgcommon.h"

Include dependency graph for VertexAttribute.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvmath

Detailed Description

Generated on Tue Jan 15 10:28:31 2008 for NVSGSDK by NVIDIA


VertexAttribute.h Source File

VertexAttribute.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 namespace nvsg
00018 {
00024   class VertexAttribute
00025   {
00026     public:
00027       typedef unsigned char mem_t;
00028       typedef mem_t * memptr_t;
00029
00030     public:
00032       NVSG_API VertexAttribute();
00033
00036       NVSG_API VertexAttribute(const VertexAttribute& rhs);
00037
00039       NVSG_API ~VertexAttribute();
00040
00047       NVSG_API void swapData(VertexAttribute& rhs);
00048
00061       NVSG_API void setData(unsigned int size, unsigned int type, const void * data, unsigned int count);
00062
00078       NVSG_API void setData(unsigned int pos, unsigned int size, unsigned int type, const void * data, unsigned int count);
00079
00090       NVSG_API const void * getData() const;
00091
00102       NVSG_API void * getData();
00103
00107       NVSG_API void removeData();
00108
00111       NVSG_API unsigned int getVertexDataCount() const;
00112
00117       NVSG_API unsigned int getVertexDataSize()  const;
00118
00128       NVSG_API unsigned int getVertexDataType()  const;
00129
00134       NVSG_API unsigned int getVertexDataBytes() const;
00135
00140       NVSG_API VertexAttribute & operator=( const VertexAttribute & rhs );
00141
00142     private:
00143       void setData(memptr_t begin, memptr_t end);
00144       void setData(memptr_t where, memptr_t begin, memptr_t end);
00145
00146       unsigned int m_count;   // # vertex data
00147       unsigned int m_size;    // # coordinates per vertex
00148       unsigned int m_type;    // symbolic constant indicating the type of coordinates
00149       unsigned int m_bytes;   // size of vertex in bytes
00150       memptr_t     m_begin;   // start address of the stored data
00151       memptr_t     m_end;     // past the end pointer
00152   };
00153
00157   NVSG_API void normalize( VertexAttribute & va );
00158
00164   NVSG_API bool operator==( const VertexAttribute & va0, const VertexAttribute & va1 );
00165
00171   NVSG_API bool operator!=( const VertexAttribute & va0, const VertexAttribute & va1 );
00172
00173
00174   inline const void * VertexAttribute::getData() const
00175   {
00176     return( m_begin );
00177   }
00178
00179   inline void * VertexAttribute::getData()
00180   {
00181     return( m_begin );
00182   }
00183
00184   inline unsigned int VertexAttribute::getVertexDataCount() const
00185   {
00186     return( m_count );
00187   }
00188
00189   inline unsigned int VertexAttribute::getVertexDataSize() const
00190   {
00191     return( m_size );
00192   }
00193
00194   inline unsigned int VertexAttribute::getVertexDataType() const
00195   {
00196     return( m_type );
00197   }
00198
00199   inline unsigned int VertexAttribute::getVertexDataBytes() const
00200   {
00201     return( m_bytes );
00202   }
00203
00204
00205   inline bool operator==( const VertexAttribute & va0, const VertexAttribute & va1 )
00206   {
00207     return(     ( va0.getVertexDataBytes() == va1.getVertexDataBytes() )
00208             &&  ( va0.getVertexDataCount() == va1.getVertexDataCount() )
00209             &&  ( va0.getVertexDataSize()  == va1.getVertexDataSize() )
00210             &&  ( va0.getVertexDataType()  == va1.getVertexDataType() )
00211             &&  ( memcmp( va0.getData(), va1.getData(), va0.getVertexDataCount() * va0.getVertexDataBytes() ) == 0 ) );
00212   }
00213
00214   inline bool operator!=( const VertexAttribute & va0, const VertexAttribute & va1 )
00215   {
00216     return( ! ( va0 == va1 ) );
00217   }
00218 } //  namespace nvsg
00219
00220
00221 namespace nvmath
00222 {
00230   NVSG_API void lerp( float alpha, const nvsg::VertexAttribute & va0
00231                     , const nvsg::VertexAttribute & va1, nvsg::VertexAttribute & var );
00232 } //  namespace nvmath
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VertexAttributeSet.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Spherent.h"
#include "nvsg/OwnedObject.h"
#include "nvsg/Types.h"
#include "nvsg/VertexAttribute.h"
#include "nvutil/BitMask.h"

Include dependency graph for VertexAttributeSet.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:31 2008 for NVSGSDK by NVIDIA


VertexAttributeSet.h Source File

VertexAttributeSet.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Spherent.h"
00017 #include "nvsg/OwnedObject.h"
00018 #include "nvsg/Types.h"
00019 #include "nvsg/VertexAttribute.h"
00020 #include "nvutil/BitMask.h"
00021
00022
00023 namespace nvsg
00024 {
00037   class VertexAttributeSet : public OwnedObject<PrimitiveSetHandle>
00038   {
00039     friend class PrimitiveSet;
00040
00041     public:
00042
00043       enum
00044       {
00045         // conventional vertex attributes
00046         NVSG_POSITION = 0,
00047         NVSG_VERTEX_WEIGHT,
00048         NVSG_NORMAL,
00049         NVSG_COLOR,
00050         NVSG_SECONDARY_COLOR,
00051         NVSG_FOG_COORD,
00052         NVSG_UNUSED_1,
00053         NVSG_UNUSED_2,
00054         NVSG_TEXCOORD0,
00055         NVSG_TEXCOORD1,
00056         NVSG_TEXCOORD2,
00057         NVSG_TEXCOORD3,
00058         NVSG_TEXCOORD4,
00059         NVSG_TEXCOORD5,
00060         NVSG_TEXCOORD6,
00061         NVSG_TEXCOORD7,
00062
00063         // generic vertex attributes
00064         NVSG_ATTR0,
00065         NVSG_ATTR1,
00066         NVSG_ATTR2,
00067         NVSG_ATTR3,
00068         NVSG_ATTR4,
00069         NVSG_ATTR5,
00070         NVSG_ATTR6,
00071         NVSG_ATTR7,
00072         NVSG_ATTR8,
00073         NVSG_ATTR9,
00074         NVSG_ATTR10,
00075         NVSG_ATTR11,
00076         NVSG_ATTR12,
00077         NVSG_ATTR13,
00078         NVSG_ATTR14,
00079         NVSG_ATTR15,
00080
00081         NVSG_VERTEX_ATTRIB_COUNT = 16
00082       };
00083
00084
00086       NVSG_API VertexAttributeSet();
00087
00089       NVSG_API VertexAttributeSet( const VertexAttributeSet &rhs );
00090
00092       NVSG_API virtual ~VertexAttributeSet(void);
00093
00095
00096       NVSG_API virtual bool isDataShared( void ) const;
00097
00099
00100       NVSG_API virtual DataID getDataID( void ) const;
00101
00120       NVSG_API virtual void swapVertexData(unsigned int attrib, VertexAttribute& rhs);
00121
00199       NVSG_API virtual void setVertexData( unsigned int attrib, unsigned int size, unsigned int type
00200                                          , const void * data, unsigned int count );
00201
00219       NVSG_API virtual void setVertexData( unsigned int attrib, unsigned int pos, unsigned int size
00220                                          , unsigned int type, const void * data, unsigned int count );
00221
00255       NVSG_API virtual void setVertexData( unsigned int attrib, const unsigned int * to
00256                                          , const unsigned int * from, unsigned int size
00257                                          , unsigned int type, const void * data, unsigned int count );
00258
00271       NVSG_API virtual void removeVertexData(unsigned int attrib);
00272
00284       NVSG_API virtual const void * getVertexData(unsigned int attrib) const;
00285
00291       NVSG_API virtual unsigned int getSizeOfVertexData(unsigned int attrib) const;
00292
00304       NVSG_API virtual unsigned int getTypeOfVertexData(unsigned int attrib) const;
00305
00309       NVSG_API virtual unsigned int getNumberOfVertexData(unsigned int attrib) const;
00310
00321       NVSG_API void setEnabled(unsigned int attrib, bool enable);
00322
00327       NVSG_API bool isEnabled(unsigned int attrib) const;
00328
00341       NVSG_API void setNormalizeEnabled(unsigned int attrib, bool enable);
00342
00347       NVSG_API bool isNormalizeEnabled(unsigned int attrib) const;
00348
00362       NVSG_API void setVertices(const nvmath::Vec3f * vertices, unsigned int count);
00363
00374       NVSG_API void setVertices(unsigned int pos, const nvmath::Vec3f * vertices, unsigned int count);
00375
00378       NVSG_API const nvmath::Vec3f * getVertices() const;
00379
00382       NVSG_API unsigned int getNumberOfVertices() const;
00383
00384       // no -longer supported
00385       //NVSG_API void setVertexWeights(const float * weights, unsigned int count);
00386       //NVSG_API void setVertexWeights(unsigned int pos, const float * weights, unsigned int count);
00387       //NVSG_API const void * getVertexWeights() const;
00388       //NVSG_API unsigned int getNumberOfVertexWeights() const;
00389
00402       NVSG_API void setNormals(const nvmath::Vec3f * normals, unsigned int count);
00403
00413       NVSG_API void setNormals(unsigned int pos, const nvmath::Vec3f * normals, unsigned int count);
00414
00417       NVSG_API const nvmath::Vec3f * getNormals() const;
00418
00421       NVSG_API unsigned int getNumberOfNormals() const;
00422
00437       template <unsigned int N, typename T> void setColors(const nvmath::Vecnt<N,T> * colors, unsigned int count);
00438
00451       template <unsigned int N, typename T> void setColors(unsigned int pos, const nvmath::Vecnt<N,T> * colors, unsigned int count);
00452
00455       NVSG_API const void * getColors() const;
00456
00459       NVSG_API unsigned int getNumberOfColors() const;
00460
00464       NVSG_API unsigned int getSizeOfColors() const;
00465
00469       NVSG_API unsigned int getTypeOfColors() const;
00470
00485       template <typename T> void setSecondaryColors(const nvmath::Vecnt<3,T> * colors, unsigned int count);
00486
00499       template <typename T> void setSecondaryColors(unsigned int pos, const nvmath::Vecnt<3,T> * colors, unsigned int count);
00500
00503       NVSG_API const void * getSecondaryColors() const;
00504
00507       NVSG_API unsigned int getNumberOfSecondaryColors() const;
00508
00512       NVSG_API unsigned int getTypeOfSecondaryColors() const;
00513
00527       template <typename T> void setFogCoords(const T * coords, unsigned int count);
00528
00540       template <typename T> void setFogCoords(unsigned int pos, T * coords, unsigned int count);
00541
00544       NVSG_API const void * getFogCoords() const;
00545
00548       NVSG_API unsigned int getNumberOfFogCoords() const;
00549
00553       NVSG_API unsigned int getTypeOfFogCoords() const;
00554
00570       template <unsigned int N, typename T> void setTexCoords(unsigned int unit, const nvmath::Vecnt<N,T> * coords, unsigned int count);
00571
00585       template <unsigned int N, typename T> void setTexCoords(unsigned int unit, unsigned int pos, const nvmath::Vecnt<N,T> * coords, unsigned int count);
00586
00590       NVSG_API const void * getTexCoords(unsigned int unit) const;
00591
00596       NVSG_API unsigned int getNumberOfTexCoords(unsigned int unit) const;
00597
00601       NVSG_API unsigned int getSizeOfTexCoords(unsigned int unit) const;
00602
00607       NVSG_API unsigned int getTypeOfTexCoords(unsigned int unit) const;
00608
00610
00611       NVSG_API VertexAttributeSet & operator=(const VertexAttributeSet & rhs);
00612
00619       NVSG_API virtual bool isCompatible( const VertexAttributeSet * p ) const;
00620
00622
00623       NVSG_API virtual bool isEquivalent( const Object *p
00624                                         , bool ignoreNames
00625                                         , bool deepCompare
00626                                         ) const;
00627
00630       NVSG_API virtual bool containsAnimation() const;
00631
00632     protected:
00634       NVSG_API void releaseCachedData();
00635
00638       NVSG_API void invalidateBoundingVolumes();
00639
00640     private:
00641
00642       unsigned int m_enableFlags; // bits 0-15 conventional attributes, bits 16-31 generic aliases
00643       unsigned int m_normalizeEnableFlags; // only for generic attributes
00644       nvutil::RCPtr<nvutil::RCVector<VertexAttribute> > m_vattribs;
00645   };
00646
00647
00649
00650   typedef enum
00651   {
00652     TCT_CYLINDRICAL,
00653     TCT_PLANAR,
00654     TCT_SPHERICAL,
00655   } TextureCoordType;
00656
00664   NVSG_API void generateTexCoords( VertexAttributeSet * vas
00665                                  , TextureCoordType tct
00666                                  , const nvmath::Sphere3f &sphere
00667                                  , unsigned int tu = 0
00668                                  );
00669
00674   NVSG_API bool genericAttrib( unsigned int attrib );
00675
00683   NVSG_API unsigned int attribIndex( unsigned int attrib );
00684
00685
00686   inline void VertexAttributeSet::setEnabled(unsigned int attrib, bool enable)
00687   {
00688     NVSG_TRACE();
00689     NVSG_ASSERT(attrib>=NVSG_POSITION && attrib<=NVSG_ATTR15);
00690     m_enableFlags &= ~(1<<attrib);
00691     m_enableFlags |= ((!!enable)<<attrib);
00692   }
00693
00694   inline bool VertexAttributeSet::isEnabled(unsigned int attrib) const
00695   {
00696     NVSG_TRACE();
00697     NVSG_ASSERT(attrib>=NVSG_POSITION && attrib<=NVSG_ATTR15);
00698     return !!(m_enableFlags & (1<<attrib));
00699   }
00700
00701   inline void VertexAttributeSet::setNormalizeEnabled(unsigned int attrib, bool enable)
00702   {
00703     NVSG_TRACE();
00704     NVSG_ASSERT(attrib>=NVSG_ATTR0 && attrib<=NVSG_ATTR15); // only for generic attributes!
00705     m_normalizeEnableFlags &= ~(1<<attrib);
00706     m_normalizeEnableFlags |= ~((!!enable)<<attrib);
00707   }
00708
00709   inline bool VertexAttributeSet::isNormalizeEnabled(unsigned int attrib) const
00710   {
00711     NVSG_TRACE();
00712     NVSG_ASSERT(attrib>=NVSG_POSITION && attrib<=NVSG_ATTR15);
00713     return !!(m_normalizeEnableFlags & (1<<attrib));
00714   }
00715
00716   inline void VertexAttributeSet::setVertices(const nvmath::Vec3f * vertices, unsigned int count)
00717   {
00718     NVSG_TRACE();
00719     setVertexData(NVSG_POSITION, 3, NVSG_FLOAT, &vertices[0], count);
00720     setEnabled(NVSG_POSITION, true); // initially enabled!
00721   }
00722
00723   inline void VertexAttributeSet::setVertices(unsigned int pos, const nvmath::Vec3f * vertices, unsigned int count)
00724   {
00725     NVSG_TRACE();
00726     setVertexData(NVSG_POSITION, pos, 3, NVSG_FLOAT, &vertices[0], count);
00727     setEnabled(NVSG_POSITION, true); // initially enabled!
00728   }
00729
00730   inline const nvmath::Vec3f * VertexAttributeSet::getVertices() const
00731   {
00732     NVSG_TRACE();
00733     NVSG_ASSERT(getSizeOfVertexData(NVSG_POSITION)==3);
00734     NVSG_ASSERT(getTypeOfVertexData(NVSG_POSITION)==NVSG_FLOAT);
00735     return (const nvmath::Vec3f *)getVertexData(NVSG_POSITION);
00736   }
00737
00738   inline unsigned int VertexAttributeSet::getNumberOfVertices() const
00739   {
00740     NVSG_TRACE();
00741     return getNumberOfVertexData(NVSG_POSITION);
00742   }
00743
00744   //inline void VertexAttributeSet::setVertexWeights(const float * weights, unsigned int count)
00745   //{
00746   //  NVSG_TRACE();
00747   //  setVertexData(NVSG_VERTEX_WEIGHT, 1, NVSG_FLOAT, weights, count);
00748   //}
00749
00750   //inline void VertexAttributeSet::setVertexWeights(unsigned int pos, const float * weights, unsigned int count)
00751   //{
00752   //  NVSG_TRACE();
00753   //  setVertexData(NVSG_VERTEX_WEIGHT, pos, 1, NVSG_FLOAT, weights, count);
00754   //}
00755
00756   //inline const void * VertexAttributeSet::getVertexWeights() const
00757   // {
00758   //  NVSG_TRACE();
00759   //  return getVertexData(NVSG_VERTEX_WEIGHT);
00760   //}
00761
00762   //inline unsigned int VertexAttributeSet::getNumberOfVertexWeights() const
00763   //{
00764   //  NVSG_TRACE();
00765   //  return getNumberOfVertexData(NVSG_VERTEX_WEIGHT);
00766   //}
00767
00768   inline void VertexAttributeSet::setNormals(const nvmath::Vec3f * normals, unsigned int count)
00769   {
00770     NVSG_TRACE();
00771     setVertexData(NVSG_NORMAL, 3, NVSG_FLOAT, normals, count);
00772     setEnabled(NVSG_NORMAL, true); // initially enabled!
00773   }
00774
00775   inline void VertexAttributeSet::setNormals(unsigned int pos, const nvmath::Vec3f * normals, unsigned int count)
00776   {
00777     NVSG_TRACE();
00778     setVertexData(NVSG_NORMAL, pos, 3, NVSG_FLOAT, normals, count);
00779     setEnabled(NVSG_NORMAL, true); // initially enabled!
00780   }
00781
00782   inline const nvmath::Vec3f * VertexAttributeSet::getNormals() const
00783   {
00784     NVSG_TRACE();
00785     NVSG_ASSERT(    ( getNumberOfNormals() == 0 )
00786                 ||  (   ( getSizeOfVertexData(NVSG_NORMAL) == 3 )
00787                     &&  ( getTypeOfVertexData(NVSG_NORMAL) == NVSG_FLOAT ) ) );
00788     return (const nvmath::Vec3f *)getVertexData(NVSG_NORMAL);
00789   }
00790
00791   inline unsigned int VertexAttributeSet::getNumberOfNormals() const
00792   {
00793     NVSG_TRACE();
00794     return getNumberOfVertexData(NVSG_NORMAL);
00795   }
00796
00797   template <unsigned int N, typename T>
00798   inline void VertexAttributeSet::setColors(const nvmath::Vecnt<N,T> * colors, unsigned int count)
00799   {
00800     NVSG_TRACE();
00801     setVertexData(NVSG_COLOR, N, Type2EnumType<T>::type, colors, count);
00802     setEnabled(NVSG_COLOR, true); // initially enabled!
00803   }
00804
00805   template <unsigned int N, typename T>
00806   inline void VertexAttributeSet::setColors(unsigned int pos, const nvmath::Vecnt<N,T> * colors, unsigned int count)
00807   {
00808     NVSG_TRACE();
00809     setVertexData(NVSG_COLOR, pos, N, Type2EnumType<T>::type, colors, count);
00810     setEnabled(NVSG_COLOR, true); // initially enabled!
00811   }
00812
00813   inline const void * VertexAttributeSet::getColors() const
00814   {
00815     NVSG_TRACE();
00816     return getVertexData(NVSG_COLOR);
00817   }
00818
00819   inline unsigned int VertexAttributeSet::getNumberOfColors() const
00820   {
00821     NVSG_TRACE();
00822     return getNumberOfVertexData(NVSG_COLOR);
00823   }
00824
00825   inline unsigned int VertexAttributeSet::getSizeOfColors() const
00826   {
00827     NVSG_TRACE();
00828     return getSizeOfVertexData(NVSG_COLOR);
00829   }
00830
00831   inline unsigned int VertexAttributeSet::getTypeOfColors() const
00832   {
00833     NVSG_TRACE();
00834     return getTypeOfVertexData(NVSG_COLOR);
00835   }
00836
00837   template <typename T>
00838   inline void VertexAttributeSet::setSecondaryColors(const nvmath::Vecnt<3,T> * colors, unsigned int count)
00839   {
00840     NVSG_TRACE();
00841     setVertexData(NVSG_SECONDARY_COLOR, 3, Type2EnumType<T>::type, colors, count);
00842     setEnabled(NVSG_SECONDARY_COLOR, true); // initially enabled!
00843   }
00844
00845   template <typename T>
00846   inline void VertexAttributeSet::setSecondaryColors(unsigned int pos, const nvmath::Vecnt<3,T> * colors, unsigned int count)
00847   {
00848     NVSG_TRACE();
00849     setVertexData(NVSG_SECONDARY_COLOR, pos, 3, Type2EnumType<T>::type, colors, count);
00850     setEnabled(NVSG_SECONDARY_COLOR, true); // initially enabled!
00851   }
00852
00853   inline const void * VertexAttributeSet::getSecondaryColors() const
00854   {
00855     NVSG_TRACE();
00856     return getVertexData(NVSG_SECONDARY_COLOR);
00857   }
00858
00859   inline unsigned int VertexAttributeSet::getNumberOfSecondaryColors() const
00860   {
00861     NVSG_TRACE();
00862     return getNumberOfVertexData(NVSG_SECONDARY_COLOR);
00863   }
00864
00865   inline unsigned int VertexAttributeSet::getTypeOfSecondaryColors() const
00866   {
00867     NVSG_TRACE();
00868     return getTypeOfVertexData(NVSG_SECONDARY_COLOR);
00869   }
00870
00871   template <typename T>
00872   inline void VertexAttributeSet::setFogCoords(const T * coords, unsigned int count)
00873   {
00874     NVSG_TRACE();
00875     setVertexData(NVSG_FOG_COORD, 1, Type2EnumType<T>::type, coords, count);
00876     setEnabled(NVSG_FOG_COORD, true); // initially enabled!
00877   }
00878
00879   template <typename T>
00880   inline void VertexAttributeSet::setFogCoords(unsigned int pos, T * coords, unsigned int count)
00881   {
00882     NVSG_TRACE();
00883     setVertexData(NVSG_FOG_COORD, pos, 1, Type2EnumType<T>::type, coords, count);
00884     setEnabled(NVSG_FOG_COORD, true); // initially enabled!
00885   }
00886
00887   inline const void * VertexAttributeSet::getFogCoords() const
00888   {
00889     NVSG_TRACE();
00890     return getVertexData(NVSG_FOG_COORD);
00891   }
00892
00893   inline unsigned int VertexAttributeSet::getNumberOfFogCoords() const
00894   {
00895     NVSG_TRACE();
00896     return getNumberOfVertexData(NVSG_FOG_COORD);
00897   }
00898
00899   inline unsigned int VertexAttributeSet::getTypeOfFogCoords() const
00900   {
00901     NVSG_TRACE();
00902     return getTypeOfVertexData(NVSG_FOG_COORD);
00903   }
00904
00905   template <unsigned int N, typename T>
00906   inline void VertexAttributeSet::setTexCoords(unsigned int unit, const nvmath::Vecnt<N,T> * coords, unsigned int count)
00907   {
00908     NVSG_TRACE();
00909     NVSG_ASSERT(unit<8);
00910     setVertexData(NVSG_TEXCOORD0+unit, N, Type2EnumType<T>::type, coords, count);
00911     setEnabled(NVSG_TEXCOORD0+unit, true); // initially enabled!
00912   }
00913
00914   template <unsigned int N, typename T>
00915   inline void VertexAttributeSet::setTexCoords(unsigned int unit, unsigned int pos, const nvmath::Vecnt<N,T> * coords, unsigned int count)
00916   {
00917     NVSG_TRACE();
00918     NVSG_ASSERT(unit<8);
00919     setVertexData(NVSG_TEXCOORD0+unit, pos, N, Type2EnumType<T>::type, coords, count);
00920     setEnabled(NVSG_TEXCOORD0+unit, true); // initially enabled!
00921   }
00922
00923   inline const void * VertexAttributeSet::getTexCoords(unsigned int unit) const
00924   {
00925     NVSG_TRACE();
00926     NVSG_ASSERT(unit<8);
00927     return getVertexData(NVSG_TEXCOORD0+unit);
00928   }
00929
00930   inline unsigned int VertexAttributeSet::getNumberOfTexCoords(unsigned int unit) const
00931   {
00932     NVSG_TRACE();
00933     NVSG_ASSERT(unit<8);
00934     return getNumberOfVertexData(NVSG_TEXCOORD0+unit);
00935   }
00936
00937   inline unsigned int VertexAttributeSet::getSizeOfTexCoords(unsigned int unit) const
00938   {
00939     NVSG_TRACE();
00940     NVSG_ASSERT(unit<8);
00941     return getSizeOfVertexData(NVSG_TEXCOORD0+unit);
00942   }
00943
00944   inline unsigned int VertexAttributeSet::getTypeOfTexCoords(unsigned int unit) const
00945   {
00946     NVSG_TRACE();
00947     NVSG_ASSERT(unit<8);
00948     return getTypeOfVertexData(NVSG_TEXCOORD0+unit);
00949   }
00950
00951
00952   inline bool genericAttrib(unsigned int attrib)
00953   {
00954     return attrib >= VertexAttributeSet::NVSG_ATTR0;
00955   }
00956
00957   inline unsigned int attribIndex(unsigned int attrib)
00958   {
00959     if ( genericAttrib(attrib) )
00960     {
00961       return attrib - VertexAttributeSet::NVSG_ATTR0;
00962     }
00963     return attrib;
00964   }
00965
00966 } //  namespace nvsg
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VertexUnifyTraverser.h File Reference

#include <set>
#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvtraverser/OptimizeTraverser.h"

Include dependency graph for VertexUnifyTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Tue Jan 15 10:28:32 2008 for NVSGSDK by NVIDIA


VertexUnifyTraverser.h Source File

VertexUnifyTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <set>
00016 #include "nvsgcommon.h"
00017 #include "nvsg/nvsg.h"
00018 #include "nvtraverser/OptimizeTraverser.h"
00019
00020 namespace nvtraverser
00021 {
00022
00024
00026   class VertexUnifyTraverser : public OptimizeTraverser
00027   {
00028     public:
00030       NVSG_API VertexUnifyTraverser(void);
00031
00033
00034       NVSG_API void  setEpsilon( float epsilon
00035                                );
00036
00037     protected:
00039       NVSG_API virtual ~VertexUnifyTraverser(void);
00040
00042
00043       NVSG_API virtual void  doApply( nvsg::NodeHandle * root );
00044
00046       void  handleVertexAttributeSet( nvsg::VertexAttributeSet * p );
00047
00049       void  handleAnimatedQuads( nvsg::AnimatedQuads * p );
00050       void  handleAnimatedTriangles( nvsg::AnimatedTriangles * triangles );
00051       void  handleSkinnedTriangles( nvsg::SkinnedTriangles * triangles );
00052
00053     private:
00054       float                                         m_epsilon;
00055       float                                         m_tolerance;
00056       std::set<nvsg::VertexAttributeSetHandle *>    m_multiOwnedHandledVAS;
00057       std::vector<nvsg::VertexAttributeSetHandle *> m_removedVAS;
00058   };
00059
00060   inline  void  VertexUnifyTraverser::setEpsilon( float epsilon )
00061   {
00062     m_epsilon = fabsf( epsilon );
00063   }
00064 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


ViewState.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/Camera.h"
#include "nvsg/MapList.h"

Include dependency graph for ViewState.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:32 2008 for NVSGSDK by NVIDIA


ViewState.h Source File

ViewState.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvsg/nvsg.h"
00017 #include "nvsg/Camera.h"
00018 #include "nvsg/MapList.h"
00019 namespace nvsg
00020 {
00021   class CullData;
00022
00060   class ViewState : public nvutil::HandledObject
00061   {
00062     public:
00063       enum JitterCombineTechnique
00064       {
00065         JCT_NONE,
00066         JCT_CROSS_PRODUCT,
00067         JCT_HIGHER_PASS
00068       };
00077       NVSG_API ViewState();
00078
00081       NVSG_API ViewState( const ViewState& rhs );
00082
00084       NVSG_API virtual ~ViewState();
00085
00090       NVSG_API bool isAnimating() const;
00091
00127       NVSG_API void setAnimating( bool animating );
00128
00135       NVSG_API bool advanceAnimation( unsigned int tick, int delta = 1 );
00136
00142       NVSG_API unsigned int getCurrentTick() const;
00143
00148       NVSG_API int getCurrentDelta() const;
00149
00154       NVSG_API void setCamera(CameraHandle * camera);
00155
00160       NVSG_API CameraHandle * getCamera() const;
00161
00168       NVSG_API bool isJitter() const;
00169
00175       NVSG_API unsigned int getNumberOfJitters() const;
00176
00185         NVSG_API void setFSAAJitters(const std::vector<nvmath::Vec2f>& fsaaJitters);
00186
00195         NVSG_API void setDoFJitters(const std::vector<nvmath::Vec2f>& dofJitters);
00196
00204         NVSG_API void setJittersCombineMethod(JitterCombineTechnique method);
00265       NVSG_API const std::vector<nvmath::Vec2f>* getFSAAJitters() const;
00266
00273       NVSG_API const std::vector<nvmath::Vec2f>* getDoFJitters() const;
00274
00278       NVSG_API const unsigned int getNumberOfFSAAJitters()const;
00279
00283       NVSG_API const unsigned int  getNumberOfDoFJitters()const;
00284
00288       NVSG_API JitterCombineTechnique getJittersCombineMethod() const;
00289
00296       NVSG_API const std::vector<std::pair < nvmath::Vec2f,nvmath::Vec2f> > & getJitters(std::vector <std::pair<nvmath::Vec2f, nvmath::Vec2f > > &inout) const;
00301       NVSG_API float getTargetDistance() const;
00302
00307       NVSG_API void setTargetDistance(float dist);
00308
00312       NVSG_API bool isStereo() const;
00313
00319       NVSG_API void setStereo(bool state);
00320
00324       NVSG_API void toggleStereo();
00325
00333       NVSG_API bool isStereoAutomaticEyeDistanceAdjustment() const;
00334
00341       NVSG_API void setStereoAutomaticEyeDistanceAdjustment(bool state);
00342
00350       NVSG_API float getStereoAutomaticEyeDistanceFactor() const;
00351
00362       NVSG_API void setStereoAutomaticEyeDistanceFactor(float factor);
00363
00374       NVSG_API float getStereoEyeDistance() const;
00375
00382       NVSG_API void setStereoEyeDistance(float distance);
00383
00387       NVSG_API void stereoReverseEyes();
00388
00394       NVSG_API bool isStereoReversedEyes() const;
00395
00405       NVSG_API void setLODRangeScale(float factor);
00406
00408
00417       NVSG_API float getLODRangeScale() const;
00418
00425       NVSG_API void clearCullTree();
00426
00435       NVSG_API const CullData * getCullTree() const;
00436
00444       NVSG_API void setCullTree( const CullData *cullTree );
00445
00454       NVSG_API MapListHandle * getMapList() const;
00455
00464       NVSG_API void setMapList( MapListHandle * ml );
00465
00470       NVSG_API void setViewportSize( unsigned int width, unsigned int height );
00471
00475       NVSG_API unsigned int getViewportWidth() const;
00476
00480       NVSG_API unsigned int getViewportHeight() const;
00481
00488       NVSG_API const nvutil::Incarnation& getIncarnation() const;
00489       NVSG_API const nvutil::Incarnation& getCullTreeIncarnation() const;
00490
00491     private:
00492       // assigning a ViewState is not permitted!
00493       ViewState& operator=(const ViewState&);
00494
00495     private:
00496       CameraHandle                * m_camera;
00497       int                           m_currentDelta;
00498       unsigned int                  m_currentTick;
00499
00500       std::vector<nvmath::Vec2f> m_fsaaJitters;
00501       std::vector<nvmath::Vec2f> m_dofJitters;
00502       JitterCombineTechnique m_combineMethod;
00503
00504
00505       float                         m_targetDistance;
00506       bool                          m_stereoState;
00507       bool                          m_stereoAutomaticEyeDistanceAdjustment;
00508       float                         m_stereoAutomaticEyeDistanceFactor;
00509       float                         m_stereoEyeDistance;
00510       bool                          m_reversedEyes;
00511       float                         m_scaleLODRange;
00512       // the animation state might be modified by concurrently executing threads,
00513       // declare it as volatile for this reason
00514       volatile bool                 m_animating;
00515
00516       const CullData * m_cullTree;
00517       const CullData * m_prevCullTree;
00518
00519       unsigned int    m_viewportWidth;
00520       unsigned int    m_viewportHeight;
00521       MapListHandle * m_mapList;
00522
00523       // will be incremented on edits
00524       nvutil::Incarnation m_incarnation;
00525       nvutil::Incarnation m_cullTreeIncarnation;
00526   };
00527
00528
00529   inline CameraHandle * ViewState::getCamera() const
00530   {
00531     NVSG_TRACE();
00532     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00533     return( m_camera );
00534   }
00535
00536   inline bool ViewState::isAnimating() const
00537   {
00538     NVSG_TRACE();
00539     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00540     return( m_animating );
00541   }
00542
00543   inline void ViewState::setAnimating( bool animating )
00544   {
00545     NVSG_TRACE();
00546     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00547     if ( m_animating != animating )
00548     {
00549       m_animating = animating;
00550       ++m_incarnation;
00551     }
00552   }
00553
00554   inline unsigned int ViewState::getCurrentTick() const
00555   {
00556     NVSG_TRACE();
00557     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00558     return( m_currentTick );
00559   }
00560
00561   inline int ViewState::getCurrentDelta() const
00562   {
00563     NVSG_TRACE();
00564     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00565     return( m_currentDelta );
00566   }
00567
00568   inline void ViewState::setCamera( CameraHandle * pCamera )
00569   {
00570     NVSG_TRACE();
00571     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00572     if ( m_camera != pCamera )
00573     {
00574       if ( m_camera )
00575       {
00576         m_camera->removeRef();
00577       }
00578       m_camera = pCamera;
00579       if ( m_camera )
00580       {
00581         m_camera->addRef();
00582         if ( fabsf( m_targetDistance ) < FLT_EPSILON )
00583         {
00584           nvutil::ReadableObject<Camera> camera(m_camera);
00585           m_targetDistance = camera->getFocusDistance();
00586         }
00587       }
00588       ++m_incarnation;
00589     // a new camera makes the current CullTree obsolete
00590     ++m_cullTreeIncarnation;
00591     }
00592   }
00593
00594   inline bool ViewState::isJitter() const
00595   {
00596     NVSG_TRACE();
00597     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00598     return( !(m_fsaaJitters.empty() && m_dofJitters.empty()) );
00599   }
00600
00601
00602   inline const unsigned int ViewState::getNumberOfFSAAJitters() const
00603   {
00604     NVSG_TRACE();
00605     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00606     NVSG_ASSERT( m_fsaaJitters.size() <= UINT_MAX );
00607     return( static_cast<unsigned int>(m_fsaaJitters.size()) );
00608   }
00609
00610   inline const unsigned int ViewState::getNumberOfDoFJitters() const
00611   {
00612     NVSG_TRACE();
00613     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00614     NVSG_ASSERT( m_dofJitters.size() <= UINT_MAX );
00615     return( static_cast<unsigned int>(m_dofJitters.size()) );
00616   }
00617
00618   inline const std::vector<nvmath::Vec2f>* ViewState::getFSAAJitters() const
00619  {
00620   NVSG_TRACE();
00621   NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00622   return (!m_fsaaJitters.empty()?&m_fsaaJitters:NULL);
00623  }
00624
00625  inline const std::vector<nvmath::Vec2f>* ViewState::getDoFJitters() const
00626  {
00627    NVSG_TRACE();
00628    NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00629    return(!m_dofJitters.empty()?&m_dofJitters:NULL);
00630  }
00631
00632
00633  inline void ViewState::setJittersCombineMethod(JitterCombineTechnique method)
00634  {
00635    NVSG_TRACE();
00636    NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00637    m_combineMethod = method;
00638  }
00639
00640  inline ViewState::JitterCombineTechnique ViewState::getJittersCombineMethod() const
00641  {
00642    NVSG_TRACE();
00643    NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00644    return(m_combineMethod);
00645  }
00646
00647    inline float ViewState::getTargetDistance() const
00648   {
00649     NVSG_TRACE();
00650     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00651     return( m_targetDistance );
00652   }
00653
00654   inline void ViewState::setTargetDistance( float dist )
00655   {
00656     NVSG_TRACE();
00657     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00658     m_targetDistance = dist;
00659     ++m_incarnation;
00660   }
00661
00662   inline bool ViewState::isStereo() const
00663   {
00664     NVSG_TRACE();
00665     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00666     return( m_stereoState );
00667   }
00668
00669   inline void ViewState::setStereo( bool state )
00670   {
00671     NVSG_TRACE();
00672     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00673     m_stereoState = state;
00674     ++m_incarnation;
00675   }
00676
00677   inline void ViewState::toggleStereo()
00678   {
00679     NVSG_TRACE();
00680     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00681     m_stereoState = ! m_stereoState;
00682     ++m_incarnation;
00683   }
00684
00685   inline bool ViewState::isStereoAutomaticEyeDistanceAdjustment() const
00686   {
00687     NVSG_TRACE();
00688     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00689     return( m_stereoAutomaticEyeDistanceAdjustment );
00690   }
00691
00692   inline void ViewState::setStereoAutomaticEyeDistanceAdjustment( bool state )
00693   {
00694     NVSG_TRACE();
00695     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00696     m_stereoAutomaticEyeDistanceAdjustment = state;
00697     ++m_incarnation;
00698   }
00699
00700   inline float ViewState::getStereoAutomaticEyeDistanceFactor() const
00701   {
00702     NVSG_TRACE();
00703     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00704     return( m_stereoAutomaticEyeDistanceFactor );
00705   }
00706
00707   inline void ViewState::setStereoAutomaticEyeDistanceFactor( float factor )
00708   {
00709     NVSG_TRACE();
00710     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00711     m_stereoAutomaticEyeDistanceFactor = factor;
00712     ++m_incarnation;
00713   }
00714
00715   inline float ViewState::getStereoEyeDistance() const
00716   {
00717     NVSG_TRACE();
00718     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00719     if (m_stereoAutomaticEyeDistanceAdjustment)
00720     {
00721       NVSG_ASSERT(m_camera);
00722       nvutil::ReadableObject<Camera> camera(m_camera);
00723       return(m_stereoAutomaticEyeDistanceFactor * camera->getFocusDistance());
00724     }
00725     else
00726     {
00727       return(m_stereoEyeDistance);
00728     }
00729   }
00730
00731   inline void ViewState::setStereoEyeDistance( float distance )
00732   {
00733     NVSG_TRACE();
00734     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00735     m_stereoEyeDistance = distance;
00736     ++m_incarnation;
00737   }
00738
00739   inline void ViewState::stereoReverseEyes()
00740   {
00741     NVSG_TRACE();
00742     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00743     m_reversedEyes = !m_reversedEyes;
00744     ++m_incarnation;
00745   }
00746
00747   inline bool ViewState::isStereoReversedEyes() const
00748   {
00749     NVSG_TRACE();
00750     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00751     return( m_reversedEyes );
00752   }
00753
00754   inline const CullData * ViewState::getCullTree() const
00755   {
00756     NVSG_TRACE();
00757     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00758     return( m_cullTree );
00759   }
00760
00761   inline void ViewState::setLODRangeScale(float factor)
00762   {
00763     NVSG_TRACE();
00764     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00765     m_scaleLODRange = factor;
00766     ++m_incarnation;
00767   }
00768
00769   inline float ViewState::getLODRangeScale() const
00770   {
00771     NVSG_TRACE();
00772     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00773     return m_scaleLODRange;
00774   }
00775
00776   inline MapListHandle * ViewState::getMapList() const
00777   {
00778     NVSG_TRACE();
00779     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00780     return( m_mapList );
00781   }
00782
00783   inline void ViewState::setMapList( MapListHandle * ml )
00784   {
00785     NVSG_TRACE();
00786     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00787     if ( ml )
00788     {
00789       ml->addRef();
00790     }
00791     if ( m_mapList )
00792     {
00793       m_mapList->removeRef();
00794     }
00795     m_mapList = ml;
00796     ++m_incarnation;
00797   }
00798
00799   inline unsigned int ViewState::getViewportWidth() const
00800   {
00801     NVSG_TRACE();
00802     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00803     return( m_viewportWidth );
00804   }
00805
00806   inline unsigned int ViewState::getViewportHeight() const
00807   {
00808     NVSG_TRACE();
00809     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00810     return( m_viewportHeight );
00811   }
00812
00813   inline const nvutil::Incarnation& ViewState::getIncarnation() const
00814   {
00815     NVSG_TRACE();
00816     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00817     return m_incarnation;
00818   }
00819
00820   inline const nvutil::Incarnation& ViewState::getCullTreeIncarnation() const
00821   {
00822     NVSG_TRACE();
00823     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00824     return m_cullTreeIncarnation;
00825   }
00826 } // namespace
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VNVector.h File Reference

#include "nvsgcommon.h"
#include <vector>
#include "nvmath/nvmath.h"

Include dependency graph for VNVector.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvmath

Detailed Description

Generated on Tue Jan 15 10:28:32 2008 for NVSGSDK by NVIDIA


VNVector.h Source File

VNVector.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include <vector>
00017 #include  "nvmath/nvmath.h"
00018
00019 namespace nvsg
00020 {
00026   class VNVector
00027   {
00028     public:
00030
00032       bool operator==( const VNVector &v ) const;
00033       bool operator!=( const VNVector &v ) const;
00034
00035     public:
00036       std::vector<nvmath::Vec3f> normals;
00037       std::vector<nvmath::Vec3f> vertices;
00038   };
00039
00040   inline bool VNVector::operator==( const VNVector &v ) const
00041   {
00042     return( ( normals == v.normals ) && ( vertices == v.vertices ) );
00043   }
00044
00045   inline bool VNVector::operator!=( const VNVector &v ) const
00046   {
00047     return( ! ( *this == v ) );
00048   }
00049 }
00050
00051 namespace nvmath
00052 {
00054
00058   inline nvsg::VNVector lerp( float alpha
00059                             , const nvsg::VNVector &v0
00060                             , const nvsg::VNVector &v1
00061                             )
00062   {
00063     nvsg::VNVector  vnv;
00064
00065     NVSG_ASSERT( v0.vertices.size() == v1.vertices.size() );
00066     vnv.vertices.resize( v0.vertices.size() );
00067     for ( size_t i=0 ; i<v0.vertices.size() ; i++ )
00068     {
00069       vnv.vertices[i] = lerp( alpha, v0.vertices[i], v1.vertices[i] );
00070                       //^^^^ invoke general lerp template
00071     }
00072
00073     NVSG_ASSERT( v0.normals.size()  == v1.normals.size() );
00074     vnv.normals.resize( v0.normals.size() );
00075     for ( size_t i=0 ; i<v0.normals.size() ; i++ )
00076     {
00077       vnv.normals[i] = lerp( alpha, v0.normals[i], v1.normals[i] );
00078                      //^^^^ invoke general lerp template
00079       vnv.normals[i].normalize();
00080     }
00081
00082     return( vnv );
00083   }
00084 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VolumeBrick.h File Reference

#include "nvmath/Planent.h"
#include "nvmath/Vecnt.h"
#include "nvsg/Object.h"
#include "nvutil/BitMask.h"

Include dependency graph for VolumeBrick.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:33 2008 for NVSGSDK by NVIDIA


VolumeBrick.h Source File

VolumeBrick.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvmath/Planent.h"
00016 #include "nvmath/Vecnt.h"
00017 #include "nvsg/Object.h"
00018 #include "nvutil/BitMask.h"
00019
00020 namespace nvsg
00021 {
00022   // Forward declaration
00023   class ChangeCallback;
00024
00034   inline nvmath::Vec3f getSubBrickPosition( const nvmath::Vec3f & pos
00035                                           , const nvmath::Vec3f & halfSize
00036                                           , unsigned int brickIndex )
00037   {
00038     return( nvmath::Vec3f( pos[0] + nvutil::bit(0,brickIndex) * halfSize[0]
00039                          , pos[1] + nvutil::bit(1,brickIndex) * halfSize[1]
00040                          , pos[2] + nvutil::bit(2,brickIndex) * halfSize[2] ) );
00041   }
00042
00053   class VolumeBrick : public nvutil::HandledObject
00054   {
00055     public:
00057       NVSG_API VolumeBrick();
00058
00060       NVSG_API virtual ~VolumeBrick();
00061
00067       NVSG_API QuadsHandle * getBrickBox() const;
00068
00077       NVSG_API TextureImageHandle * getBrickData() const;
00078
00087       NVSG_API TriFansHandle * getFrontPlane() const;
00088
00093       NVSG_API StateVariantHandle * getStateVariant() const;
00094
00100       NVSG_API bool isLeaf() const;
00101
00111       NVSG_API VolumeBrickHandle * operator[]( unsigned int index ) const;
00112
00121       NVSG_API void setData( const std::string & brickName
00122                            , const nvmath::Vec3f & volumeSize
00123                            , const nvmath::Vec3f & brickPosition
00124                            , const nvmath::Vec3f & brickSize );
00125
00134       NVSG_API void setFrontClipPlane( const nvmath::Plane3f &plane );
00135
00143       NVSG_API void setMasterShader( CgFxHandle * shader );
00144
00145     private:
00146       NVSG_API void enterCS() const;
00147       NVSG_API void leaveCS() const;
00148       NVSG_API void removeFrontClipPlane();
00149
00150     private:
00151       QuadsHandle                 * m_brickBox;
00152       std::string                   m_brickName;
00153       nvmath::Vec3f                 m_brickPosition;
00154       nvmath::Vec3f                 m_brickSize;
00155       TriFansHandle               * m_frontPlane;           // proxy geometry in case of front plane clipping
00156       nvutil::SWMRSync              m_lock;                 // helps managing exclusive access to mutable members while reading the object
00157       CgFxHandle                  * m_masterShader;         // The master (VolumeNode's) shader from which the brick shader will be cloned
00158       VolumeBrickHandle           * m_octels[8];
00159       nvmath::Vec3f                 m_volumeSize;
00160
00161       mutable TextureImageHandle  * m_brickData;
00162       mutable ChangeCallback      * m_ChangeCallBack;       // The CallBack responsible for updating the Brick's shader with the (possibly changed) master shader
00163       mutable CgFxHandle          * m_shader;               // The shader for the brick
00164       mutable StateVariantHandle  * m_stateVariant;
00165   };
00166
00167   inline QuadsHandle * VolumeBrick::getBrickBox() const
00168   {
00169     NVSG_TRACE();
00170     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00171     return( m_brickBox );
00172   }
00173
00174   inline TriFansHandle * VolumeBrick::getFrontPlane() const
00175   {
00176     NVSG_TRACE();
00177     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00178     return( m_frontPlane );
00179   }
00180
00181   inline bool VolumeBrick::isLeaf() const
00182   {
00183     NVSG_TRACE();
00184     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00185     return( !(    m_octels[0] || m_octels[1] || m_octels[2] || m_octels[3]
00186               ||  m_octels[4] || m_octels[5] || m_octels[6] || m_octels[7] ) );
00187   }
00188
00189   inline VolumeBrickHandle * VolumeBrick::operator[]( unsigned int index ) const
00190   {
00191     NVSG_TRACE();
00192     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00193     NVSG_ASSERT( index < 8 );
00194     return( m_octels[index] );
00195   }
00196
00197   inline void VolumeBrick::enterCS() const
00198   {
00199     NVSG_TRACE();
00200     m_lock.lockExclusive();
00201   }
00202
00203   inline void VolumeBrick::leaveCS() const
00204   {
00205     NVSG_TRACE();
00206     m_lock.unlockExclusive();
00207   }
00208
00209 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VolumeNode.h File Reference

#include <set>
#include "nvmath/Matnnt.h"
#include "nvmath/Planent.h"
#include "nvsg/CgFx.h"
#include "nvsg/Node.h"

Include dependency graph for VolumeNode.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:33 2008 for NVSGSDK by NVIDIA


VolumeNode.h Source File

VolumeNode.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include <set>
00016 #include "nvmath/Matnnt.h"
00017 #include "nvmath/Planent.h"
00018 #include "nvsg/CgFx.h"
00019 #include "nvsg/Node.h" // base class definition
00020
00021 namespace nvsg
00022 {
00028   class VolumeNode : public Node
00029   {
00030     public:
00032       NVSG_API VolumeNode();
00033
00038       NVSG_API explicit VolumeNode( const Node &rhs );
00039
00041       NVSG_API VolumeNode( const VolumeNode& rhs );
00042
00044       NVSG_API virtual ~VolumeNode();
00045
00060       NVSG_API void determineActiveBricks( nvsg::CameraHandle * cameraHandle
00061                                          , const nvmath::Mat44f & modelToView
00062                                          , float maxScalingFactor );
00063
00076       NVSG_API const std::set<nvsg::VolumeBrickHandle*> & getActiveBricks() const;
00077
00087       NVSG_API CgFxHandle * getShader() const;
00088
00095       NVSG_API void setShader( CgFxHandle * shader );
00096
00103       NVSG_API void effectChanged( void ) const;
00104
00108       NVSG_API const std::string & getVolumeTextureName() const;
00109
00122       NVSG_API const std::string & getTopBrickTextureName() const;
00123
00138       NVSG_API void setFileNames( const std::string & volumeTextureName
00139                                 , const std::string & topBrickTextureName
00140                                 , const std::vector<std::string> & searchPaths );
00141
00147       NVSG_API VolumeBrickHandle * getTopLevelBrick() const;
00148
00154       NVSG_API const unsigned int * getVolumeTextureSize() const;
00155
00161       NVSG_API const unsigned int * getBrickTextureSize() const;
00162
00169       NVSG_API const nvmath::Vec3f & getBricksOverallSize() const;
00170
00177       NVSG_API const nvmath::Plane3f & getFrontClipPlane() const;
00178
00185       NVSG_API void setFrontClipPlane( const nvmath::Plane3f &plane );
00186
00196       NVSG_API float getVoxelLimitFraction() const;
00197
00207       NVSG_API void setVoxelLimitFraction( float vlf );
00208
00221       NVSG_API virtual bool isEquivalent( const Object * p, bool ignoreNames, bool deepCompare ) const;
00222
00229       NVSG_API VolumeNode & operator=(const VolumeNode & rhs);
00230
00237       NVSG_API virtual bool validateIncarnation() const;  // from top to bottom
00238
00239     protected:
00240
00246       NVSG_API virtual nvmath::Box3f calculateBoundingBox() const;
00247
00253       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00254
00261       NVSG_API virtual bool determineTransparencyContainment() const;
00262
00265       NVSG_API virtual bool determineCgFxContainment() const;
00266
00269       NVSG_API virtual bool determineVolumeNodeContainment() const;
00270
00282       NVSG_API virtual bool isActive( const nvsg::VolumeBrick * vb, const nvmath::Sphere3f & bs
00283                                     , const nvsg::Camera * camera );
00284
00285     private:
00286       NVSG_API void gatherActiveBricks( nvsg::VolumeBrickHandle * vbh
00287                                       , const nvsg::Camera * c
00288                                       , const nvmath::Mat44f & modelToView
00289                                       , float maxScalingFactor
00290                                       , std::set<nvsg::VolumeBrickHandle*> & bricks );
00291
00292     private:
00293       std::string   m_topBrickTextureName;    // path to the bricks data files
00294       CgFxHandle  * m_shader;
00295       std::string   m_volumeTextureName;      // file name of volume texture data
00296       float         m_voxelLimitFraction;
00297
00298       std::set<nvsg::VolumeBrickHandle*>    m_activeBricks;           // set of active bricks
00299       VolumeBrickHandle                   * m_topLevelBrick;          // octree of bricks
00300       nvmath::Vec3f                         m_bricksOverallSize;      // overall size of the bricks
00301       unsigned int                          m_brickMinimalVoxelCount; // minimal size of the brick (in voxels)
00302       unsigned int                          m_brickOverlapSize;       // size of the overlap
00303       unsigned int                          m_brickTextureSize[3];    // size of the brick texture
00304       nvmath::Plane3f                       m_frontPlane;             // front clipping plane
00305       nvmath::Vec3f                         m_volumeSize;
00306       unsigned int                          m_volumeTextureSize[3];   // size of the data in the file m_volumeTextureName
00307   };
00308
00309   // - - - - - - - - - - - - - - - - - - - - - - - - -
00310   // inlines
00311   // - - - - - - - - - - - - - - - - - - - - - - - - -
00312
00313   inline const std::set<nvsg::VolumeBrickHandle*> & VolumeNode::getActiveBricks() const
00314   {
00315     NVSG_TRACE();
00316     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00317     return( m_activeBricks );
00318   }
00319
00320   inline CgFxHandle * VolumeNode::getShader() const
00321   {
00322     NVSG_TRACE();
00323     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00324     return( m_shader );
00325   }
00326
00327   inline VolumeBrickHandle * VolumeNode::getTopLevelBrick() const
00328   {
00329     NVSG_TRACE();
00330     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00331     return( m_topLevelBrick );
00332   }
00333
00334   inline const unsigned int * VolumeNode::getVolumeTextureSize() const
00335   {
00336     NVSG_TRACE();
00337     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00338     return( m_volumeTextureSize );
00339   }
00340
00341   inline const nvmath::Vec3f & VolumeNode::getBricksOverallSize() const
00342   {
00343     NVSG_TRACE();
00344     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00345     return( m_bricksOverallSize );
00346   }
00347
00348   inline const std::string & VolumeNode::getTopBrickTextureName() const
00349   {
00350     NVSG_TRACE();
00351     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00352     return( m_topBrickTextureName );
00353   }
00354
00355   inline const std::string & VolumeNode::getVolumeTextureName() const
00356   {
00357     NVSG_TRACE();
00358     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00359     return( m_volumeTextureName );
00360   }
00361
00362   inline const nvmath::Plane3f & VolumeNode::getFrontClipPlane() const
00363   {
00364     NVSG_TRACE();
00365     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00366     return( m_frontPlane );
00367   }
00368
00369   inline float VolumeNode::getVoxelLimitFraction() const
00370   {
00371     NVSG_TRACE();
00372     NVSG_ASSERT_OBJECT_READ_LOCKED(this);
00373     return( m_voxelLimitFraction );
00374   }
00375
00376   inline void VolumeNode::setVoxelLimitFraction( float vlf )
00377   {
00378     NVSG_TRACE();
00379     NVSG_ASSERT_OBJECT_WRITE_LOCKED(this);
00380     if( m_voxelLimitFraction != vlf )
00381     {
00382       m_voxelLimitFraction = vlf;
00383       invalidateIncarnation();
00384     }
00385   }
00386
00387 } //  namespace nvsg
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VolumeTexture.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vecnt.h"
#include "nvsg/CoreTypes.h"
#include "nvsg/TextureImage.h"

Include dependency graph for VolumeTexture.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Tue Jan 15 10:28:33 2008 for NVSGSDK by NVIDIA


VolumeTexture.h Source File

VolumeTexture.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/Vecnt.h"
00017 #include "nvsg/CoreTypes.h"
00018 #include "nvsg/TextureImage.h"
00019
00020 namespace nvsg
00021 {
00026   class VolumeTexture : public TextureImage
00027   {
00028     public:
00032       NVSG_API VolumeTexture();
00033
00035       NVSG_API virtual ~VolumeTexture();
00036
00040       NVSG_API unsigned int getOverlapSize() const;
00041
00047       NVSG_API nvmath::Vec3f getSliceThickness() const;
00048
00052       NVSG_API void setOverlapSize( unsigned int overlap );
00053
00059       NVSG_API void setSliceThickness( const nvmath::Vec3f & thickness );
00060
00061     private:
00062       unsigned int  m_overlap;
00063       nvmath::Vec3f m_sliceThickness;
00064   };
00065
00066   inline unsigned int VolumeTexture::getOverlapSize() const
00067   {
00068     NVSG_TRACE();
00069     return( m_overlap );
00070   }
00071
00072   inline nvmath::Vec3f VolumeTexture::getSliceThickness() const
00073   {
00074     NVSG_TRACE();
00075     return( m_sliceThickness );
00076   }
00077
00078   inline void VolumeTexture::setOverlapSize( unsigned int overlap )
00079   {
00080     NVSG_TRACE();
00081     m_overlap = overlap;
00082   }
00083
00084   inline void VolumeTexture::setSliceThickness( const nvmath::Vec3f & thickness )
00085   {
00086     NVSG_TRACE();
00087     m_sliceThickness = thickness;
00088   }
00089 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VRMLTypes.h File Reference

#include "nvmath/Quatt.h"
#include "nvmath/Vecnt.h"
#include "nvsg/Object.h"

Include dependency graph for VRMLTypes.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | vrml

Detailed Description

Generated on Tue Jan 15 10:28:33 2008 for NVSGSDK by NVIDIA


VRMLTypes.h Source File

VRMLTypes.h

Go to the documentation of this file.
00001  // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvmath/Quatt.h"
00016 #include "nvmath/Vecnt.h"
00017 #include "nvsg/Object.h"
00018
00019 #if !defined(DOXYGEN_IGNORE)
00020 #define USE_QUAD_MESHES_FOR_ELEVATION_GRID  0
00021 #endif
00022
00023 namespace nvsg
00024 {
00025   class Billboard;
00026   class DirectedLight;
00027   class GeoNode;
00028   class Group;
00029   class LineStrips;
00030   class LOD;
00031   class Material;
00032   class Node;
00033   class PointLight;
00034   class Points;
00035   class QuadMeshes;
00036   class Quads;
00037   class SpotLight;
00038   class StateSet;
00039   class Switch;
00040   class TextureAttribute;
00041   class Transform;
00042   class Triangles;
00043 }
00044
00045 namespace vrml
00046 {
00047
00048   //  it's not neccessary to document all these helper classes !
00049 #if ! defined( DOXYGEN_IGNORE )
00050
00051   class Object : public nvutil::RCObject
00052   {
00053     public:
00054       virtual ~Object() {}
00055       virtual const std::string & getType() const;
00056       const std::string& getName() const { return name; }
00057       void setName(const std::string& n) { name = n; }
00058     private:
00059       std::string name;
00060   };
00061
00062   template<typename T>
00063   inline bool isTypeOf( Object *p )
00064   {
00065     return( dynamic_cast<T *>( p ) != NULL );
00066   }
00067
00068   typedef bool                  SFBool;
00069   typedef nvmath::Vec3f         SFColor;
00070   typedef std::vector<SFColor>  MFColor;
00071   typedef float                 SFFloat;
00072   typedef std::vector<SFFloat>  MFFloat;
00073   typedef char                  SFInt8;
00074   typedef int                   SFInt32;
00075   typedef std::vector<SFInt32>  MFInt32;
00076   typedef vrml::Object  *       SFNode;
00077   typedef std::vector<SFNode>   MFNode;
00078   typedef std::string           SFString;
00079   typedef std::vector<SFString> MFString;
00080   typedef double                SFTime;
00081   typedef std::vector<SFTime>   MFTime;
00082   typedef nvmath::Vec2f         SFVec2f;
00083   typedef std::vector<SFVec2f>  MFVec2f;
00084   typedef nvmath::Vec3f         SFVec3f;
00085   typedef std::vector<SFVec3f>  MFVec3f;
00086
00087   class SFImage
00088   {
00089     public:
00090       SFImage();
00091       ~SFImage();
00092
00093     public:
00094       SFInt32   width;
00095       SFInt32   height;
00096       SFInt32   numComponents;
00097       SFInt8  * pixelsValues;
00098   };
00099
00100   class SFRotation : public nvmath::Vec4f
00101   {
00102     public:
00103       SFRotation()  {}
00104       SFRotation( const SFVec3f &axis, SFFloat angle );
00105       SFRotation( const nvmath::Vec4f &v )
00106         : nvmath::Vec4f( v )
00107       {
00108       }
00109   };
00110   typedef std::vector<SFRotation>  MFRotation;
00111
00112   inline SFRotation lerp( float alpha, const SFRotation &r0, const SFRotation &r1 )
00113   {
00114     nvmath::Quatf q0(nvmath::Vec3f(r0[0],r0[1],r0[2]),r0[3]);
00115     nvmath::Quatf q1(nvmath::Vec3f(r1[0],r1[1],r1[2]),r1[3]);
00116     nvmath::Quatf q = nvmath::lerp( alpha, q0, q1 );
00117     return( SFRotation(SFVec3f(q[0],q[1],q[2]),q[3]) );
00118   }
00119
00120
00121   class Geometry : public Object
00122   {
00123     public:
00124       virtual ~Geometry() {}
00125       virtual const std::string & getType( void ) const;
00126   };
00127
00128   class Group : public Object
00129   {
00130     public:
00131       Group();
00132       virtual ~Group();
00133       virtual const std::string & getType( void ) const;
00134
00135     public:
00136       SFVec3f bboxCenter;
00137       SFVec3f bboxSize;
00138       MFNode  children;
00139
00140       nvsg::GroupHandle * pGroup;
00141   };
00142
00143   class Sensor : public Object
00144   {
00145     public:
00146       Sensor();
00147       virtual ~Sensor()  {}
00148       virtual const std::string & getType( void ) const;
00149
00150     public:
00151       SFBool  enabled;
00152   };
00153
00154   class TimeSensor : public Sensor
00155   {
00156     public:
00157       TimeSensor();
00158       virtual ~TimeSensor()  {}
00159       virtual const std::string & getType( void ) const;
00160
00161     public:
00162       SFTime  cycleInterval;
00163       SFBool  loop;
00164       SFTime  startTime;
00165       SFTime  stopTime;
00166   };
00167
00168   class Interpolator : public Object
00169   {
00170     public:
00171       Interpolator();
00172       virtual ~Interpolator();
00173       virtual const std::string & getType( void ) const;
00174
00175     public:
00176       MFFloat                     key;
00177       bool                        interpreted;
00178       TimeSensor                * set_fraction;
00179       std::vector<unsigned int>   steps;
00180   };
00181
00182   class Light : public Object
00183   {
00184     public:
00185       Light();
00186       virtual ~Light()  {}
00187       virtual const std::string & getType( void ) const;
00188
00189     public:
00190       SFFloat ambientIntensity;
00191       SFColor color;
00192       SFFloat intensity;
00193       SFBool  on;
00194   };
00195
00196   class Texture : public Object
00197   {
00198     public:
00199       Texture();
00200       virtual ~Texture()  {}
00201       virtual const std::string & getType( void ) const;
00202
00203     public:
00204       SFBool  repeatS;
00205       SFBool  repeatT;
00206   };
00207
00208   class Anchor : public Group
00209   {
00210     public:
00211       virtual ~Anchor() {}
00212       virtual const std::string & getType( void ) const;
00213
00214     public:
00215       SFString  description;
00216       MFString  parameter;
00217       MFString  url;
00218   };
00219
00220   class Appearance : public Object
00221   {
00222     public:
00223       Appearance();
00224       virtual ~Appearance();
00225       virtual const std::string & getType( void ) const;
00226
00227     public:
00228       SFNode  material;
00229       SFNode  texture;
00230       SFNode  textureTransform;
00231
00232       nvsg::StateSetHandle  * pStateSet;
00233   };
00234
00235   class AudioClip : public Object
00236   {
00237     public:
00238       AudioClip();
00239       virtual ~AudioClip()  {}
00240       virtual const std::string & getType( void ) const;
00241
00242     public:
00243       SFString  description;
00244       SFBool    loop;
00245       SFFloat   pitch;
00246       SFTime    startTime;
00247       SFTime    stopTime;
00248       MFString  url;
00249   };
00250
00251   class Background : public Object
00252   {
00253     public:
00254       Background();
00255       virtual ~Background() {}
00256       virtual const std::string & getType( void ) const;
00257
00258     public:
00259       MFFloat   groundAngle;
00260       MFColor   groundColor;
00261       MFString  backUrl;
00262       MFString  bottomUrl;
00263       MFString  frontUrl;
00264       MFString  leftUrl;
00265       MFString  rightUrl;
00266       MFString  topUrl;
00267       MFFloat   skyAngle;
00268       MFColor   skyColor;
00269   };
00270
00271   class Billboard : public Group
00272   {
00273     public:
00274       Billboard();
00275       virtual ~Billboard();
00276       virtual const std::string & getType( void ) const;
00277
00278     public:
00279       SFVec3f axisOfRotation;
00280
00281       nvsg::BillboardHandle * pBillboard;
00282   };
00283
00284   class Box : public Geometry
00285   {
00286     public:
00287       Box();
00288       virtual ~Box();
00289       virtual const std::string & getType( void ) const;
00290
00291     public:
00292       SFVec3f size;
00293
00294       nvsg::TrianglesHandle * pTriangles;
00295       nvsg::QuadsHandle     * pQuads;
00296   };
00297
00298   class Collision : public Group
00299   {
00300     public:
00301       Collision();
00302       virtual ~Collision();
00303       virtual const std::string & getType( void ) const;
00304
00305     public:
00306       SFBool  collide;
00307       SFNode  proxy;
00308   };
00309
00310   class ColorInterpolator : public Interpolator
00311   {
00312     public:
00313       virtual ~ColorInterpolator()  {}
00314       virtual const std::string & getType( void ) const;
00315
00316     public:
00317       MFColor keyValue;
00318   };
00319
00320   class Color : public Object
00321   {
00322     public:
00323       Color();
00324       virtual ~Color() {}
00325       virtual const std::string & getType( void ) const;
00326
00327     public:
00328       MFColor             color;
00329       bool                interpreted;
00330       ColorInterpolator * set_color;
00331   };
00332
00333   class Cone : public Geometry
00334   {
00335     public:
00336       Cone();
00337       virtual ~Cone() {}
00338       virtual const std::string & getType( void ) const;
00339
00340     public:
00341       SFBool  bottom;
00342       SFFloat bottomRadius;
00343       SFFloat height;
00344       SFBool  side;
00345   };
00346
00347   class CoordinateInterpolator : public Interpolator
00348   {
00349     public:
00350       virtual ~CoordinateInterpolator()  {}
00351       virtual const std::string & getType( void ) const;
00352
00353     public:
00354       MFVec3f keyValue;
00355   };
00356
00357   class Coordinate : public Object
00358   {
00359     public:
00360       Coordinate();
00361       virtual ~Coordinate();
00362       virtual const std::string & getType( void ) const;
00363
00364     public:
00365       MFVec3f                   point;
00366       bool                      interpreted;
00367       CoordinateInterpolator  * set_point;
00368   };
00369
00370   class Cylinder : public Geometry
00371   {
00372     public:
00373       Cylinder();
00374       virtual ~Cylinder() {}
00375       virtual const std::string & getType( void ) const;
00376
00377     public:
00378       SFBool  bottom;
00379       SFFloat height;
00380       SFFloat radius;
00381       SFBool  side;
00382       SFBool  top;
00383   };
00384
00385   class CylinderSensor : public Sensor
00386   {
00387     public:
00388       CylinderSensor();
00389       virtual ~CylinderSensor()  {}
00390       virtual const std::string & getType( void ) const;
00391
00392     public:
00393       SFBool  autoOffset;
00394       SFFloat diskAngle;
00395       SFFloat maxAngle;
00396       SFFloat minAngle;
00397       SFFloat offset;
00398   };
00399
00400   class DirectionalLight : public Light
00401   {
00402     public:
00403       DirectionalLight();
00404       virtual ~DirectionalLight();
00405       virtual const std::string & getType( void ) const;
00406
00407     public:
00408       SFVec3f direction;
00409
00410       nvsg::DirectedLightHandle * pDirectedLight;
00411   };
00412
00413   class ElevationGrid : public Geometry
00414   {
00415     public:
00416       ElevationGrid();
00417       virtual ~ElevationGrid();
00418       virtual const std::string & getType( void ) const;
00419
00420     public:
00421       SFNode  color;
00422       SFNode  normal;
00423       SFNode  texCoord;
00424       MFFloat height;
00425       SFBool  ccw;
00426       SFBool  colorPerVertex;
00427       SFFloat creaseAngle;
00428       SFBool  normalPerVertex;
00429       SFBool  solid;
00430       SFInt32 xDimension;
00431       SFFloat xSpacing;
00432       SFInt32 zDimension;
00433       SFFloat zSpacing;
00434
00435 #if USE_QUAD_MESHES_FOR_ELEVATION_GRID
00436       nvsg::QuadMeshesHandle * pQuadMeshes;
00437 #else
00438       nvsg::TrianglesHandle * pTriangles;
00439       nvsg::QuadsHandle     * pQuads;
00440 #endif
00441   };
00442
00443   class Extrusion : public Geometry
00444   {
00445     public:
00446       Extrusion();
00447       virtual ~Extrusion()  {}
00448       virtual const std::string & getType( void ) const;
00449
00450     public:
00451       SFBool      beginCap;
00452       SFBool      ccw;
00453       SFBool      convex;
00454       SFFloat     creaseAngle;
00455       MFVec2f     crossSection;
00456       SFBool      endCap;
00457       MFRotation  orientation;
00458       MFVec2f     scale;
00459       SFBool      solid;
00460       MFVec3f     spine;
00461   };
00462
00463   class Fog : public Object
00464   {
00465     public:
00466       Fog();
00467       virtual ~Fog()  {}
00468       virtual const std::string & getType( void ) const;
00469
00470     public:
00471       SFColor   color;
00472       SFString  fogType;
00473       SFFloat   visibilityRange;
00474   };
00475
00476   class FontStyle : public Object
00477   {
00478     public:
00479       FontStyle();
00480       virtual ~FontStyle()  {}
00481       virtual const std::string & getType( void ) const;
00482
00483     public:
00484       MFString  family;
00485       SFBool    horizontal;
00486       MFString  justify;
00487       SFString  language;
00488       SFBool    leftToRight;
00489       SFFloat   size;
00490       SFFloat   spacing;
00491       SFString  style;
00492       SFBool    topToBottom;
00493   };
00494
00495   class ImageTexture : public Texture
00496   {
00497     public:
00498       ImageTexture();
00499       virtual ~ImageTexture();
00500       virtual const std::string & getType( void ) const;
00501
00502     public:
00503       MFString  url;
00504
00505       nvsg::TextureAttributeHandle  * pTextureAttribute;
00506   };
00507
00508   class IndexedFaceSet : public Geometry
00509   {
00510     public:
00511       IndexedFaceSet();
00512       virtual ~IndexedFaceSet();
00513       virtual const std::string & getType( void ) const;
00514
00515     public:
00516       SFNode  color;
00517       SFNode  coord;
00518       SFNode  normal;
00519       SFNode  texCoord;
00520       SFBool  ccw;
00521       MFInt32 colorIndex;
00522       SFBool  colorPerVertex;
00523       SFBool  convex;
00524       MFInt32 coordIndex;
00525       SFFloat creaseAngle;
00526       MFInt32 normalIndex;
00527       SFBool  normalPerVertex;
00528       SFBool  solid;
00529       MFInt32 texCoordIndex;
00530
00531       nvsg::TrianglesHandle * pTriangles;
00532       nvsg::QuadsHandle     * pQuads;
00533   };
00534
00535   class IndexedLineSet : public Geometry
00536   {
00537     public:
00538       IndexedLineSet();
00539       virtual ~IndexedLineSet();
00540       virtual const std::string & getType( void ) const;
00541
00542     public:
00543       SFNode  color;
00544       SFNode  coord;
00545       MFInt32 colorIndex;
00546       SFBool  colorPerVertex;
00547       MFInt32 coordIndex;
00548
00549       nvsg::LineStripsHandle * pLineStrips;
00550   };
00551
00552   class Inline : public Object
00553   {
00554     public:
00555       Inline();
00556       virtual ~Inline();
00557       virtual const std::string & getType( void ) const;
00558
00559     public:
00560       MFString  url;
00561       SFVec3f   bboxCenter;
00562       SFVec3f   bboxSize;
00563
00564       nvsg::NodeHandle  * pNode;
00565   };
00566
00567   class LOD : public Group
00568   {
00569     public:
00570       LOD();
00571       virtual ~LOD();
00572       virtual const std::string & getType( void ) const;
00573
00574     public:
00575       SFVec3f center;
00576       MFFloat range;
00577
00578       nvsg::LODHandle * pLOD;
00579   };
00580
00581   class Material : public Object
00582   {
00583     public:
00584       Material();
00585       virtual ~Material();
00586       virtual const std::string & getType( void ) const;
00587
00588     public:
00589       SFFloat ambientIntensity;
00590       SFColor diffuseColor;
00591       SFColor emissiveColor;
00592       SFFloat shininess;
00593       SFColor specularColor;
00594       SFFloat transparency;
00595
00596       nvsg::MaterialHandle *pMaterial;
00597   };
00598
00599   class MovieTexture : public Texture
00600   {
00601     public:
00602       MovieTexture();
00603       virtual ~MovieTexture()  {}
00604       virtual const std::string & getType( void ) const;
00605
00606     public:
00607       SFBool    loop;
00608       SFFloat   speed;
00609       SFTime    startTime;
00610       SFTime    stopTime;
00611       MFString  url;
00612   };
00613
00614   class NavigationInfo : public Object
00615   {
00616     public:
00617       NavigationInfo();
00618       virtual ~NavigationInfo() {}
00619       virtual const std::string & getType( void ) const;
00620
00621     public:
00622       MFFloat   avatarSize;
00623       SFBool    headlight;
00624       SFFloat   speed;
00625       MFString  type;
00626       SFFloat   visibilityLimit;
00627   };
00628
00629   class NormalInterpolator : public Interpolator
00630   {
00631     public:
00632       virtual ~NormalInterpolator()  {}
00633       virtual const std::string & getType( void ) const;
00634
00635     public:
00636       MFVec3f keyValue;
00637   };
00638
00639   class Normal : public Object
00640   {
00641     public:
00642       Normal();
00643       virtual ~Normal();
00644       virtual const std::string & getType( void ) const;
00645
00646     public:
00647       MFVec3f               vector;
00648       bool                  interpreted;
00649       NormalInterpolator  * set_vector;
00650   };
00651
00652   class OrientationInterpolator : public Interpolator
00653   {
00654     public:
00655       virtual ~OrientationInterpolator()  {}
00656       virtual const std::string & getType( void ) const;
00657
00658     public:
00659       MFRotation  keyValue;
00660
00661       std::vector<nvmath::Quatf> keyValueQuatf;
00662   };
00663
00664   class PixelTexture : public Texture
00665   {
00666     public:
00667       PixelTexture();
00668       virtual ~PixelTexture()  {}
00669       virtual const std::string & getType( void ) const;
00670
00671     public:
00672       SFImage image;
00673   };
00674
00675   class PlaneSensor : public Sensor
00676   {
00677     public:
00678       PlaneSensor();
00679       virtual ~PlaneSensor()  {}
00680       virtual const std::string & getType( void ) const;
00681
00682     public:
00683       SFBool  autoOffset;
00684       SFVec2f maxPosition;
00685       SFVec2f minPosition;
00686       SFVec3f offset;
00687   };
00688
00689   class PointLight : public Light
00690   {
00691     public:
00692       PointLight();
00693       virtual ~PointLight();
00694       virtual const std::string & getType( void ) const;
00695
00696     public:
00697       SFVec3f attenuation;
00698       SFVec3f location;
00699       SFFloat radius;
00700
00701       nvsg::PointLightHandle  * pPointLight;
00702   };
00703
00704   class PointSet : public Geometry
00705   {
00706     public:
00707       PointSet();
00708       virtual ~PointSet();
00709       virtual const std::string & getType( void ) const;
00710
00711     public:
00712       SFNode  color;
00713       SFNode  coord;
00714
00715       nvsg::PointsHandle * pPoints;
00716   };
00717
00718   class PositionInterpolator : public Interpolator
00719   {
00720     public:
00721       virtual ~PositionInterpolator()  {}
00722       virtual const std::string & getType( void ) const;
00723
00724     public:
00725       MFVec3f keyValue;
00726   };
00727
00728   class ProximitySensor : public Sensor
00729   {
00730     public:
00731       ProximitySensor();
00732       virtual ~ProximitySensor()  {}
00733       virtual const std::string & getType( void ) const;
00734
00735     public:
00736       SFVec3f center;
00737       SFVec3f size;
00738   };
00739
00740   class ScalarInterpolator : public Interpolator
00741   {
00742     public:
00743       virtual ~ScalarInterpolator()  {}
00744       virtual const std::string & getType( void ) const;
00745
00746     public:
00747       MFFloat keyValue;
00748   };
00749
00750   class Script : public Object
00751   {
00752     public:
00753       Script();
00754       virtual ~Script() {}
00755       virtual const std::string & getType( void ) const;
00756
00757     public:
00758       MFString  url;
00759       SFBool    directOutput;
00760       SFBool    mustEvaluate;
00761   };
00762
00763   class Shape : public Object
00764   {
00765     public:
00766       Shape();
00767       virtual ~Shape();
00768       virtual const std::string & getType( void ) const;
00769
00770     public:
00771       SFNode  appearance;
00772       SFNode  geometry;
00773
00774       nvsg::GeoNodeHandle * pGeoNode;
00775   };
00776
00777   class Sound : public Object
00778   {
00779     public:
00780       Sound();
00781       virtual ~Sound();
00782       virtual const std::string & getType( void ) const;
00783
00784     public:
00785       SFVec3f direction;
00786       SFFloat intensity;
00787       SFVec3f location;
00788       SFFloat maxBack;
00789       SFFloat maxFront;
00790       SFFloat minBack;
00791       SFFloat minFront;
00792       SFFloat priority;
00793       SFNode  source;
00794       SFBool  spatialize;
00795   };
00796
00797   class Sphere : public Geometry
00798   {
00799     public:
00800       Sphere();
00801       virtual ~Sphere() {}
00802       virtual const std::string & getType( void ) const;
00803
00804     public:
00805       SFFloat radius;
00806   };
00807
00808   class SphereSensor : public Sensor
00809   {
00810     public:
00811       SphereSensor();
00812       virtual ~SphereSensor()  {}
00813       virtual const std::string & getType( void ) const;
00814
00815     public:
00816       SFBool      autoOffset;
00817       SFRotation  offset;
00818   };
00819
00820   class SpotLight : public Light
00821   {
00822     public:
00823       SpotLight();
00824       virtual ~SpotLight();
00825       virtual const std::string & getType( void ) const;
00826
00827     public:
00828       SFVec3f attenuation;
00829       SFFloat beamWidth;
00830       SFFloat cutOffAngle;
00831       SFVec3f direction;
00832       SFVec3f location;
00833       SFFloat radius;
00834
00835       nvsg::SpotLightHandle * pSpotLight;
00836   };
00837
00838   class Switch : public Group
00839   {
00840     public:
00841       Switch();
00842       virtual ~Switch();
00843       virtual const std::string & getType( void ) const;
00844
00845     public:
00846       SFInt32 whichChoice;
00847
00848       nvsg::SwitchHandle  * pSwitch;
00849   };
00850
00851   class Text : public Geometry
00852   {
00853     public:
00854       Text();
00855       virtual ~Text();
00856       virtual const std::string & getType( void ) const;
00857
00858     public:
00859       MFString  string;
00860       SFNode    fontStyle;
00861       MFFloat   length;
00862       SFFloat   maxExtent;
00863   };
00864
00865   class TextureCoordinate : public Object
00866   {
00867     public:
00868       virtual ~TextureCoordinate()  {}
00869       virtual const std::string & getType( void ) const;
00870
00871     public:
00872       MFVec2f point;
00873   };
00874
00875   class TextureTransform : public Object
00876   {
00877     public:
00878       TextureTransform();
00879       virtual ~TextureTransform()  {}
00880       virtual const std::string & getType( void ) const;
00881
00882     public:
00883       SFVec2f center;
00884       SFFloat rotation;
00885       SFVec2f scale;
00886       SFVec2f translation;
00887   };
00888
00889   class TouchSensor : public Sensor
00890   {
00891     public:
00892       virtual ~TouchSensor()  {}
00893       virtual const std::string & getType( void ) const;
00894   };
00895
00896   class Transform : public Group
00897   {
00898     public:
00899       Transform();
00900       virtual ~Transform();
00901       virtual const std::string & getType( void ) const;
00902
00903     public:
00904       SFVec3f     center;
00905       SFRotation  rotation;
00906       SFVec3f     scale;
00907       SFRotation  scaleOrientation;
00908       SFVec3f     translation;
00909
00910       PositionInterpolator    * set_center;
00911       OrientationInterpolator * set_rotation;
00912       PositionInterpolator    * set_scale;
00913       PositionInterpolator    * set_translation;
00914
00915       nvsg::TransformHandle * pTransform;
00916   };
00917
00918   class Viewpoint : public Object
00919   {
00920     public:
00921       Viewpoint();
00922       virtual ~Viewpoint();
00923       virtual const std::string & getType( void ) const;
00924
00925     public:
00926       SFFloat     fieldOfView;
00927       SFBool      jump;
00928       SFRotation  orientation;
00929       SFVec3f     position;
00930       SFString    description;
00931
00932       OrientationInterpolator * set_orientation;
00933       PositionInterpolator    * set_position;
00934   };
00935
00936   class VisibilitySensor : public Sensor
00937   {
00938     public:
00939       VisibilitySensor();
00940       virtual ~VisibilitySensor()  {}
00941       virtual const std::string & getType( void ) const;
00942
00943     public:
00944       SFVec3f center;
00945       SFVec3f size;
00946   };
00947
00948   class WorldInfo : public Object
00949   {
00950     public:
00951       virtual ~WorldInfo()  {}
00952       virtual const std::string & getType( void ) const;
00953
00954     public:
00955       MFString  info;
00956       SFString  title;
00957   };
00958
00959
00960   class ROUTE
00961   {
00962     public:
00963       ROUTE();
00964       ~ROUTE();
00965
00966     public:
00967       SFNode  fromNode;
00968       std::string  fromAction;
00969       SFNode  toNode;
00970       std::string  toAction;
00971   };
00972
00973
00974   template  <typename T>  inline  bool  is( const Object *p )
00975   {
00976     return( dynamic_cast<const T *>( p ) != NULL );
00977   }
00978
00979 #endif  //  DOXYGEN_IGNORE
00980
00981 } //  namespace vrml
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


WalkCameraManipulator.h File Reference

#include "nvsgcommon.h"
#include "nvmath/nvmath.h"
#include "nvmath/Vecnt.h"
#include "nvui/Manipulator.h"
#include "nvui/KeyInput.h"
#include "nvui/MouseInput.h"

Include dependency graph for WalkCameraManipulator.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvui

Detailed Description

Generated on Tue Jan 15 10:28:33 2008 for NVSGSDK by NVIDIA


WalkCameraManipulator.h Source File

WalkCameraManipulator.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016 #include "nvmath/nvmath.h"
00017 #include "nvmath/Vecnt.h"
00018 #include "nvui/Manipulator.h"
00019 #include "nvui/KeyInput.h"
00020 #include "nvui/MouseInput.h"
00021
00022 namespace nvui
00023 {
00024
00064   class WalkCameraManipulator : public Manipulator
00065   {
00066     public:
00076       NVSG_API WalkCameraManipulator(UINT screenSizeX = 1280, UINT screenSizeY = 1024);
00077
00079       NVSG_API ~WalkCameraManipulator();
00080
00082       enum
00083       { _NO_BTN_KEY         = 0x0000
00084       , _LEFT_MOUSE_BTN     = 0x0001
00085       , _MIDDLE_MOUSE_BTN   = 0x0002
00086       , _CONTROL_KEY        = 0x0004
00087       , _W_KEY              = 0x0008
00088       , _S_KEY              = 0x0010
00089       };
00090
00113       NVSG_API virtual bool updateFrame();
00114
00119       NVSG_API virtual bool isActive();
00120
00130       NVSG_API virtual bool isWalk();
00131
00138       NVSG_API virtual bool isWalkForward();
00139
00146       NVSG_API virtual bool isWalkBackward();
00147
00155       NVSG_API virtual bool isTranslate();
00156
00164       NVSG_API virtual bool isTilt();
00165
00173       void setWorldUpVector(nvmath::Vec3f up);
00174
00180       const nvmath::Vec3f& getWorldUpVector();
00181
00189       void setSpeedIncreaseFactor(float factor);
00190
00197       float getSpeedIncreaseFactor();
00198
00206       void setHSensitivity(float sensitivity);
00207
00215       float getHSensitivity();
00216
00221       void setSpeed(float speed);
00222
00226       float getSpeed();
00227
00237       void setScreenSize(UINT x, UINT y);
00238
00246       NVSG_API void reset();
00247
00254       NVSG_API void keyDown(UINT key);
00255
00262       NVSG_API void keyUp(UINT key);
00263
00274       NVSG_API void mouseButtonDown(UINT btn, int x, int y);
00275
00286       NVSG_API void mouseButtonUp(UINT btn, int x, int y);
00287
00294       NVSG_API void mouseMotion(int x, int y);
00295
00300       NVSG_API void setCameraHeightAboveTerrain( float offset );
00301
00306       NVSG_API float getCameraHeightAboveTerrain();
00307
00308     protected:
00309
00311       bool findTerrainPosition( nvmath::Vec3f & );
00312
00314       static NVSG_API const UINT WALKFORWARD;
00316       static NVSG_API const UINT WALKBACKWARD;
00318       static NVSG_API const UINT TRANSLATE;
00320       static NVSG_API const UINT TILT;
00322       static NVSG_API const UINT INCREASESPEED;
00324       static NVSG_API const UINT DECREASESPEED;
00326       static NVSG_API const UINT AREAOFPEACE;
00327
00328       UINT  m_ScreenSizeX;
00329       UINT  m_ScreenSizeY;
00330
00331       nvmath::Vec3f m_worldUpVector;
00332       float m_speedIncreaseFactor;
00333       float m_hSensitivity;
00334       float m_speed;
00335       float m_cameraHeightAboveTerrain;
00336
00337       nvui::MouseInput m_mouseInput;
00338       nvui::KeyInput   m_keyInput;
00339
00340     protected:
00345       virtual bool walk();
00346
00351       virtual bool translate();
00352
00357       virtual bool tilt();
00358   };
00359
00360   inline void WalkCameraManipulator::setScreenSize(UINT x, UINT y)
00361   {
00362     NVSG_ASSERT(x>0);
00363     NVSG_ASSERT(y>0);
00364     m_ScreenSizeX = x;
00365     m_ScreenSizeX = y;
00366   }
00367
00368   inline void WalkCameraManipulator::setCameraHeightAboveTerrain( float offset )
00369   {
00370     m_cameraHeightAboveTerrain = offset;
00371   }
00372
00373   inline float WalkCameraManipulator::getCameraHeightAboveTerrain()
00374   {
00375     return m_cameraHeightAboveTerrain;
00376   }
00377
00378   inline void WalkCameraManipulator::setWorldUpVector( nvmath::Vec3f up )
00379   {
00380     m_worldUpVector = up;
00381   }
00382
00383   inline const nvmath::Vec3f& WalkCameraManipulator::getWorldUpVector()
00384   {
00385     return m_worldUpVector;
00386   }
00387
00388   inline void WalkCameraManipulator::setSpeedIncreaseFactor(float factor)
00389   {
00390     NVSG_ASSERT(fabs(factor) > FLT_EPSILON);
00391     m_speedIncreaseFactor = factor;
00392   }
00393
00394   inline float WalkCameraManipulator::getSpeedIncreaseFactor()
00395   {
00396     return m_speedIncreaseFactor;
00397   }
00398
00399   inline void WalkCameraManipulator::setHSensitivity(float sensitivity)
00400   {
00401     m_hSensitivity = sensitivity;
00402   }
00403
00404   inline float WalkCameraManipulator::getHSensitivity()
00405   {
00406     return m_hSensitivity;
00407   }
00408
00409   inline void WalkCameraManipulator::setSpeed(float speed)
00410   {
00411     m_speed = speed;
00412   }
00413
00414   inline float WalkCameraManipulator::getSpeed()
00415   {
00416     return m_speed;
00417   }
00418 } //  namespace nvui
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


WRLLoader.h File Reference

#include <windows.h>
#include <fstream>
#include <set>
#include "nvsg/nvsg.h"
#include "nvsg/PlugInterface.h"
#include "VRMLTypes.h"

Include dependency graph for WRLLoader.h:

Include dependency graph

Go to the source code of this file.

Classes

class | WRLLoader
A Scene loader for wrl files. More...

Functions

void | lib_init () __attribute__((constructor))
WRLLOADER_API bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

WRLLOADER_API bool | queryPlugInterfaceType (const nvutil::UPITID &pitid, std::vector< nvutil::UPIID > &piids)
Query the supported types of PlugIn Interfaces.

Detailed Description

Function Documentation

WRLLOADER_API bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) |

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a WRLLoader. If the PlugIn ID piid equals PIID_WRL_SCENE_LOADER, a WRLLoader is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

WRLLOADER_API bool queryPlugInterfaceType | ( | const nvutil::UPITID & | pitid,
 |  | std::vector< nvutil::UPIID > & | piids
 | ) |

Query the supported types of PlugIn Interfaces.

Every PlugIn has to resolve this function. It is used to query the supported Interface types of this PlugIn. If the Plug In Type ID pitid equals PITID_SCENE_LOADER, the vector piids is filled with one element PIID_WRL_SCENE_LOADER.

Returns:
true, if a PITID_SCENE_LOADER is requested, otherwise false

Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


WRLLoader.h Source File

WRLLoader.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #if defined(_WIN32) || defined(_WIN64)
00016 # define WIN32_LEAN_AND_MEAN    // Exclude rarely-used stuff from Windows headers
00017 # include <windows.h>         // MFC core and standard components
00018 #endif
00019
00020 #include  <fstream>
00021 #include  <set>
00022 #include  "nvsg/nvsg.h"
00023 #include  "nvsg/PlugInterface.h"
00024 #include  "VRMLTypes.h"
00025
00026
00027 //  Don't need to document the API specifier
00028 #if ! defined( DOXYGEN_IGNORE ) && defined(_WIN32)
00029 # ifdef WRLLOADER_EXPORTS
00030 # define WRLLOADER_API __declspec(dllexport)
00031 # else
00032 # define WRLLOADER_API __declspec(dllimport)
00033 # endif
00034 #else
00035 # define WRLLOADER_API
00036 #endif
00037
00038 #if defined(LINUX)
00039 void lib_init() __attribute__ ((constructor));   // will be called before dlopen() returns
00040 #endif
00041
00043
00047 #if defined(LINUX)
00048 extern "C"
00049 {
00050 #endif
00051 WRLLOADER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00052
00054
00059 WRLLOADER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00060 #if defined(LINUX)
00061 }
00062 #endif
00063
00242 class WRLLoader : public nvsg::SceneLoader
00243 {
00244   public :
00245     //  Default constructor/destructor.
00246     WRLLoader();
00247     ~WRLLoader();
00248
00249   public :
00256     unsigned int getStepsPerUnit() const;
00257
00264     void setStepsPerUnit( unsigned int stepsPerUnit );
00265
00267
00268     void deleteThis( void );
00269
00271
00276     nvsg::SceneHandle * load( const std::string& filename
00277                             , const std::vector<std::string> &searchPaths
00278                             , nvsg::ViewStateHandle *& viewState
00280                             );
00281
00282   private :
00283     void                            calculateNormals( vrml::IndexedFaceSet * pIndexedFaceSet,
00284                                                       const nvsg::IndexSet &triVerts, const nvsg::IndexSet &triFaces,
00285                                                       const nvsg::IndexSet &quadVerts, const nvsg::IndexSet &quadFaces );
00286     void                            determineTexGen( vrml::ElevationGrid * pElevationGrid, nvsg::StateSetHandle *pStateSet );
00287     void                            determineTexGen( vrml::IndexedFaceSet * pIndexedFaceSet, nvsg::StateSetHandle *pStateSet );
00288     template<typename VType>
00289       void                          eraseIndex( unsigned int f, unsigned int i, unsigned int count
00290                                               , bool perVertex, vrml::MFInt32 &index, VType &vec );
00291     vrml::SFNode                    findNode( const vrml::SFNode currentNode, std::string name );
00292     std::vector<unsigned int>       getCombinedKeys( vrml::PositionInterpolator *center
00293                                                    , vrml::OrientationInterpolator *rotation
00294                                                    , vrml::PositionInterpolator *scale
00295                                                    , vrml::PositionInterpolator *translation );
00296     bool                            getNextLine( void );
00297     std::string                   & getNextToken( void );
00298     vrml::SFNode                    getNode( const std::string &nodeName, std::string &token );
00299     void                            ignoreBlock( const std::string &open, const std::string &close
00300                                                , std::string &token );
00301     nvsg::SceneHandle             * import( const std::string &filename );
00302     nvsg::StateSetHandle          * interpretAppearance( vrml::Appearance *pAppearance );
00303     void                            interpretChildren( vrml::MFNode &children, nvsg::Group *pNVSGGroup );
00304     void                            interpretBackground( const vrml::Background *pBackground );
00305     nvsg::BillboardHandle         * interpretBillboard( vrml::Billboard *pVRMLBillboard );
00306     void                            interpretBox( vrml::Box *pBox, std::vector<nvsg::DrawableHandle*> &drawables
00307                                                 , bool textured = false );
00308     void                            interpretColor( vrml::Color * pColor );
00309     void                            interpretColorInterpolator( vrml::ColorInterpolator * pColorInterpolator
00310                                                               , unsigned int colorCount );
00311     void                            interpretCoordinate( vrml::Coordinate * pCoordinate );
00312     void                            interpretCoordinateInterpolator( vrml::CoordinateInterpolator * pCoordinateInterpolator
00313                                                                    , unsigned int pointCount );
00314     nvsg::DirectedLightHandle     * interpretDirectionalLight( vrml::DirectionalLight *pDirectionalLight );
00315     void                            interpretElevationGrid( vrml::ElevationGrid * pElevationGrid,
00316                                                             std::vector<nvsg::DrawableHandle*> &drawables );
00317     void                            interpretGeometry( vrml::Geometry *pGeometry
00318                                                      , std::vector<nvsg::DrawableHandle*> &drawables
00319                                                      , bool textured = false );
00320     nvsg::GroupHandle             * interpretGroup( vrml::Group *pGroup );
00321     nvsg::TextureAttributeHandle  * interpretImageTexture( vrml::ImageTexture *pImageTexture );
00322     void                            interpretIndexedFaceSet( vrml::IndexedFaceSet *pIndexedFaceSet,
00323                                                              std::vector<nvsg::DrawableHandle*> &drawables );
00324     void                            interpretIndexedLineSet( vrml::IndexedLineSet *pIndexedLineSet,
00325                                                              std::vector<nvsg::DrawableHandle*> &drawables );
00326     nvsg::NodeHandle              * interpretInline( vrml::Inline * pInline );
00327     nvsg::LODHandle               * interpretLOD( vrml::LOD *pVRMLLOD );
00328     nvsg::MaterialHandle          * interpretMaterial( vrml::Material * pVRMLMaterial );
00329     void                            interpretNormal( vrml::Normal * pNormal );
00330     void                            interpretNormalInterpolator( vrml::NormalInterpolator * pNormalInterpolator
00331                                                                , unsigned int vectorCount );
00332     void                            interpretOrientationInterpolator( vrml::OrientationInterpolator *pOI );
00333     nvsg::TextureAttributeHandle  * interpretPixelTexture( const vrml::PixelTexture *pPixelTexture );
00334     nvsg::PointLightHandle        * interpretPointLight( vrml::PointLight *pVRMLPointLight );
00335     void                            interpretPointSet( vrml::PointSet *pPointSet
00336                                                      , std::vector<nvsg::DrawableHandle*> &drawables );
00337     void                            interpretPositionInterpolator( vrml::PositionInterpolator * pPositionInterpolator );
00338     nvmath::Vec3f                   interpretSFColor( const vrml::SFColor &c );
00339     nvsg::ObjectHandle            * interpretSFNode( const vrml::SFNode n );
00340     nvmath::Quatf                   interpretSFRotation( const vrml::SFRotation &r );
00341     nvsg::GeoNodeHandle           * interpretShape( vrml::Shape *pShape );
00342     nvsg::SpotLightHandle         * interpretSpotLight( vrml::SpotLight *pVRMLSpotLight );
00343     nvsg::SwitchHandle            * interpretSwitch( vrml::Switch *pVRMLSwitch );
00344     nvsg::TextureAttributeHandle  * interpretTexture( vrml::Texture *pTexture );
00345     void                            interpretTextureTransform( const vrml::TextureTransform *pTextureTransform,
00346                                                                nvsg::TextureAttributeHandle *pTextureAttribute );
00347     nvsg::TransformHandle         * interpretTransform( vrml::Transform *pVRMLTransform );
00348     bool                            interpretURL( const vrml::MFString &url, std::string &fileName );
00349     nvsg::VertexAttributeSetHandle  * interpretVertexAttributeSet( vrml::IndexedFaceSet *pIndexedFaceSet
00350                                                                  , unsigned int vpf
00351                                                                  , unsigned int faceCount
00352                                                                  , nvsg::IndexSet startIndices
00353                                                                  , nvsg::IndexSet faceIndices );
00354     nvsg::ObjectHandle            * interpretViewpoint( const vrml::Viewpoint *pViewpoint );
00355     void                            interpretVRMLTree( void );
00356     bool                            isValidScaling( const vrml::PositionInterpolator *pPositionInterpolator ) const;
00357     bool                            isValidScaling( const vrml::SFVec3f &sfVec3f ) const;
00358     bool                            onIncompatibleValues( int value0, int value1, const std::string &node,
00359                                                           const std::string &field0, const std::string &field1 ) const;
00360     template<typename T>
00361       bool                          onInvalidValue( T value, const std::string &node, const std::string &field ) const;
00362     bool                            onEmptyToken( const std::string &tokenType, const std::string &token ) const;
00363     bool                            onFileNotFound( const vrml::SFString &url ) const;
00364     bool                            onFilesNotFound( bool found, const vrml::MFString &url ) const;
00365     void                            onUnexpectedEndOfFile( bool error ) const;
00366     void                            onUnexpectedToken( const std::string &expected, const std::string &token ) const;
00367     void                            onUnknownToken( const std::string &tokenType, const std::string &token ) const;
00368     bool                            onUndefinedToken( const std::string &tokenType, const std::string &token ) const;
00369     bool                            onUnsupportedToken( const std::string &tokenType, const std::string &token ) const;
00370     vrml::Anchor                  * readAnchor( const std::string &nodeName );
00371     vrml::Appearance              * readAppearance( const std::string &nodeName );
00372     vrml::AudioClip               * readAudioClip( const std::string &nodeName );
00373     vrml::Background              * readBackground( const std::string &nodeName );
00374     vrml::Billboard               * readBillboard( const std::string &nodeName );
00375     vrml::Box                     * readBox( const std::string &nodeName );
00376     vrml::Collision               * readCollision( const std::string &nodeName );
00377     vrml::Color                   * readColor( const std::string &nodeName );
00378     vrml::ColorInterpolator       * readColorInterpolator( const std::string &nodeName );
00379     vrml::Cone                    * readCone( const std::string &nodeName );
00380     vrml::Coordinate              * readCoordinate( const std::string &nodeName );
00381     vrml::CoordinateInterpolator  * readCoordinateInterpolator( const std::string &nodeName );
00382     vrml::Cylinder                * readCylinder( const std::string &nodeName );
00383     vrml::CylinderSensor          * readCylinderSensor( const std::string &nodeName );
00384     vrml::DirectionalLight        * readDirectionalLight( const std::string &nodeName );
00385     vrml::ElevationGrid           * readElevationGrid( const std::string &nodeName );
00386     void                            readEXTERNPROTO( void );
00387     vrml::Extrusion               * readExtrusion( const std::string &nodeName );
00388     vrml::Fog                     * readFog( const std::string &nodeName );
00389     vrml::FontStyle               * readFontStyle( const std::string &nodeName );
00390     vrml::Group                   * readGroup( const std::string &nodeName );
00391     vrml::ImageTexture            * readImageTexture( const std::string &nodeName );
00392     void                            readIndex( std::vector<vrml::SFInt32> &mf );
00393     vrml::IndexedFaceSet          * readIndexedFaceSet( const std::string &nodeName );
00394     vrml::IndexedLineSet          * readIndexedLineSet( const std::string &nodeName );
00395     vrml::Inline                  * readInline( const std::string &nodeName );
00396     vrml::LOD                     * readLOD( const std::string &nodeName );
00397     vrml::Material                * readMaterial( const std::string &nodeName );
00398     void                            readMFNode( vrml::Group * fatherNode );
00399     template<typename SFType>
00400       void                          readMFType( std::vector<SFType> &mf, void (WRLLoader::*readSFType)( SFType &sf, std::string &token ) );
00401     vrml::MovieTexture            * readMovieTexture( const std::string &nodeName );
00402     vrml::NavigationInfo          * readNavigationInfo( const std::string &nodeName );
00403     vrml::Normal                  * readNormal( const std::string &nodeName );
00404     vrml::NormalInterpolator      * readNormalInterpolator( const std::string &nodeName );
00405     vrml::OrientationInterpolator * readOrientationInterpolator( const std::string &nodeName );
00406     vrml::PixelTexture            * readPixelTexture( const std::string &nodeName );
00407     vrml::PlaneSensor             * readPlaneSensor( const std::string &nodeName );
00408     vrml::PointLight              * readPointLight( const std::string &nodeName );
00409     vrml::PointSet                * readPointSet( const std::string &nodeName );
00410     vrml::PositionInterpolator    * readPositionInterpolator( const std::string &nodeName );
00411     void                            readPROTO( void );
00412     vrml::ProximitySensor         * readProximitySensor( const std::string &nodeName );
00413     void                            readROUTE( const vrml::SFNode currentNode );
00414     vrml::ScalarInterpolator      * readScalarInterpolator( const std::string &nodeName );
00415     vrml::Script                  * readScript( const std::string &nodeName );
00416     void                            readSFBool( vrml::SFBool &b );
00417     void                            readSFColor( vrml::SFColor &c, std::string &token );
00418     void                            readSFFloat( vrml::SFFloat &f, std::string &token );
00419     void                            readSFImage( vrml::SFImage &i );
00420     void                            readSFInt8( vrml::SFInt8 &i );
00421     void                            readSFInt32( vrml::SFInt32 &i, std::string &token );
00422     void                            readSFNode( const vrml::SFNode fatherNode, vrml::SFNode &n, std::string &token );
00423     void                            readSFRotation( vrml::SFRotation &r, std::string &token );
00424     void                            readSFString( vrml::SFString &s, std::string &token );
00425     void                            readSFTime( vrml::SFTime &t );
00426     void                            readSFVec2f( vrml::SFVec2f &v, std::string &token );
00427     void                            readSFVec3f( vrml::SFVec3f &v, std::string &token );
00428     vrml::Shape                   * readShape( const std::string &nodeName );
00429     vrml::Sound                   * readSound( const std::string &nodeName );
00430     vrml::Sphere                  * readSphere( const std::string &nodeName );
00431     vrml::SphereSensor            * readSphereSensor( const std::string &nodeName );
00432     vrml::SpotLight               * readSpotLight( const std::string &nodeName );
00433     void                            readStatements( void );
00434     vrml::Switch                  * readSwitch( const std::string &nodeName );
00435     vrml::Text                    * readText( const std::string &nodeName );
00436     vrml::TextureCoordinate       * readTextureCoordinate( const std::string &nodeName );
00437     vrml::TextureTransform        * readTextureTransform( const std::string &nodeName );
00438     vrml::TimeSensor              * readTimeSensor( const std::string &nodeName );
00439     vrml::TouchSensor             * readTouchSensor( const std::string &nodeName );
00440     vrml::Transform               * readTransform( const std::string &nodeName );
00441     vrml::Viewpoint               * readViewpoint( const std::string &nodeName );
00442     vrml::VisibilitySensor        * readVisibilitySensor( const std::string &nodeName );
00443     vrml::WorldInfo               * readWorldInfo( const std::string &nodeName );
00444     template<typename T>
00445       void                          resampleKeyValues( vrml::MFFloat & keys
00446                                                      , std::vector<T> & values
00447                                                      , unsigned int valuesPerKey
00448                                                      , std::vector<unsigned int> & steps
00449                                                      , vrml::SFTime cycleInterval );
00450     void                            setNextToken( void );
00451     bool                            testWRLVersion( const std::string &filename );
00452
00453   private :
00454     std::string                           m_currentString;
00455     std::string                           m_currentToken;
00456     std::map<std::string,vrml::SFNode>    m_defNodes;
00457     bool                                  m_eof;
00458     FILE                                * m_fh;
00459     std::vector<vrml::SFNode>             m_inlines;
00460     char                                * m_line;
00461     unsigned int                          m_lineLength;
00462     unsigned int                          m_lineNumber;
00463     std::string::size_type                m_nextTokenEnd;
00464     std::string::size_type                m_nextTokenStart;
00465     std::vector<vrml::SFNode>             m_openNodes;
00466     std::set<std::string>                 m_PROTONames;
00467     nvsg::GroupHandle                   * m_rootNode;
00468     nvsg::SceneHandle                   * m_scene;
00469     std::vector<std::string>              m_searchPaths;
00470     unsigned int                          m_stepsPerUnit;
00471     vrml::Group                         * m_topLevelGroup;
00472     bool                                  m_strict;
00473     std::string                           m_ungetToken;
00474 };
00475
00476 inline void WRLLoader::deleteThis( void )
00477 {
00478   delete this;
00479 }
00480
00481 inline unsigned int WRLLoader::getStepsPerUnit() const
00482 {
00483   return( m_stepsPerUnit );
00484 }
00485
00486 inline void WRLLoader::setStepsPerUnit( unsigned int stepsPerUnit )
00487 {
00488   m_stepsPerUnit = stepsPerUnit;
00489 }
00490
00491 inline  nvmath::Vec3f WRLLoader::interpretSFColor( const vrml::SFColor &c )
00492 {
00493   return( * (nvmath::Vec3f *) &c );
00494 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


WRLLoadTraverser.h File Reference

#include "nvtraverser/Traverser.h"

Include dependency graph for WRLLoadTraverser.h:

Include dependency graph

Go to the source code of this file.

Classes

class WRLLoadTraverser
Internally used traverser for post-processing a just loaded VRML file. More...

Detailed Description

Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


WRLLoadTraverser.h Source File

WRLLoadTraverser.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00015 #include  "nvtraverser/Traverser.h"
00016
00017
00019 class WRLLoadTraverser : public nvtraverser::ExclusiveTraverser
00020 {
00021   public:
00023     WRLLoadTraverser();
00024
00026     virtual ~WRLLoadTraverser(void);
00027
00028   protected:
00030
00032     virtual void  doApply( nvsg::NodeHandle * root );
00033
00035
00037     virtual void  handleAnimatedTransform( nvsg::AnimatedTransform * p );
00038
00040
00042     virtual void  handleBillboard( nvsg::Billboard *p );
00043
00045
00047     virtual void  handleGroup( nvsg::Group *p );
00048
00050
00052     virtual void  handleTransform( nvsg::Transform *p );
00053
00054   private:
00055     void removeEmptyGroups( nvsg::Group * grp );
00056     void processGroup( nvsg::Group * p );
00057     void transformLightSource( const nvmath::Trafo &trafo, nvsg::LightSource * lightSource );
00058
00059   private:
00060     std::vector<nvsg::LightSourceHandle *> m_lights;
00061 };
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Annotated Index

NVSGSDK Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
addReference | Convenient helper functor that can be used in STL algorithms to add a reference to reference counted objects
Allocator | Internal manager for memory allocations
AlphaTestAttribute | StateAttribute that defines the Alpha test
AnalyzeResult | Base class of the analyzing results determined with the AnalyzeTraverser
AnalyzeTraverser | Traverser that analyzes a tree and reports about potential deficiencies
AnimatedTransform | Class representing an animated Transform
AnimatedVertexAttributeSet | Provides functionality to work with animated vertex attribute data
Animation | Class defining the common interface of an animation
AnimationManipulator | This Manipulator controls the camera animation
AppTraverser | AppTraverser Class
BalanceTraverser | Balance a flat tree into a somewhat more balanced tree
BaseRenderElement | Helper class to serve as a base class for the render list elements, like RenderElement, LightsElement, or ClipPlanesElement
BellFilter | ScaleFilter functor providing bell filter functionality
Billboard | Class that adds billboard properties to a Group
Bit | Template class for easy definition of a single-bit bitmask
BlendAttribute | StateAttribute that determines the blending modes to use
Bone | An internal helper class for SkinnedTriangles
bone_t | The bone_t structure specifies how a bone is stored in a .NBF file
BoxFilter | ScaleFilter functor providing box filter functionality
Boxnt | Represents an axis-aligned box
BSplineFilter | ScaleFilter functor providing BSpline filter functionality
CallbackServer | CallBackServer for associating CallBacks with objects
Camera | Abstract base class for parallel and perspective cameras
CgFx | A StateAttribute to apply render effects that are compliant to the Cg 1.4 standard
CgFxContext | CgFxContext wraps a CGcontext and maintains its state machine configuration
CgFxEffect | Abstracts a render effect to be applied to a specific geometry
ChangeCallback | Abstract class for defining a CallBack on an object
Chunk | Chunk of memory for our low level memory managment of fixed size objects
ClipPlanesElement | Helper class to hold the clip planes valid for a number of PrimitiveSets
CombinableResult | AnalyzeResult indicating that a number of Objects can be combined
CombineTraverser | Traverser that combines a number of Objects, if appropriate
CPUSkinningProcessor | CPUSkinningProcessor Class
CullData | Class holding culling information of an object and it's children
CullTraverser | Base class for culling parts of a scene
DALData | Device Abstraction Link Data
DALDataCreator | Represents the interface required for a creator of DALData
DALHost | Represents an object capable to host a Device Abstraction Link
DenormalizedNormalsResult | AnalyzeResult indicating a VertexAttributeSet with denormalized normals
DepthAttribute | StateAttribute that determines the depth settings to use
DestrippingTraverser | Traverser to destripify stripped primitives
DirectedLight | LightSource representing a directed light
Drawable | The abstract base class of all drawable objects
EliminateTraverser | Traverser that eliminates a number of Objects, if appropriate
EmptyResult | AnalyzeResult indicating an empty object
EquivalenceResult | AnalyzeResult indicating equivalent objects
ExclusiveModelViewTraverser | Traverser that can handle the model view transform stack
ExclusiveTraverser | Base class providing an interface for read-write traversing of a given scene graph
ExtractGeometryTraverser | Traverser that can handle the model view transform stack
Face | Simple helper class for Lines, Quads, and Triangles
FaceAttribute | PrimitiveAttribute specific for Drawables with faces, like Triangles or QuadStrips
FileMapping | Helper class to ease efficient reading and writing of large files
FixedAllocator | Manages allocation requests for objects of a certain size only
FlightCameraManipulator | Simulate flight like camera-mouse interaction
FlipbookAnimation | Class representing a flipbook animation
FramedAnimation | Template class of an Animation that holds a complete data set for each frame
FrustumCullTraverser | CullTraverser culling on frustum information
geometrySet_t | The geometrySet_t structure specifies how a geometry set is stored in a .NBF file
GeoNode | Leaf Node to maintain geometry
GLContext | Wrapper for OpenGL functions to provide caching, extension handling, and, in debug mode, error handling per context
GLFunctions | The GLFunctions class holds the OpenGL extension function pointers
GLMFCRAWnd | OpenGL render area window
GLObjects | The GLObjects class is a container of OpenGL objects
GLTexImageFmt | GLTexImageFmt specifies the format and data type of a texture image
GLTraverser | RenderTraverser using OpenGL
GLUploadTraverser | UploadTraverser using OpenGL
GLWinRenderArea | RenderArea class for MS Windows OpenGL
GPUSkinningProcessor | GPUSkinningProcessor Class
Group | Provides grouping of Node objects
Handle | Controls access to the the handled object
Handle< T, Handle< U, V > > | Specialization template for Handle-derived Handle types
Handle< T, NullType > | Specialized stand-alone Handle
HighlightBox | A HighlightObject that realizes a bounding box around a Drawable
HighlightEdges | A HighlightObject that realizes a wireframe drawing of the highlighted PrimitiveSet
HighlightElement | Helper class to hold highlight information used in the render lists
HighlightObject | Abstract base class for highlighting objects
IAllocator | An allocator interface
IdentityResult | AnalyzeResult indicating identity transformations
IdentityToGroupTraverser | Traverser that replaces identity transforms by groups
ILTexLoader | A Texture Loader that encapsulates DevIL so it can be used with the NVSG PlugIn mechanism
ILTexSaver | A Texture Saver that encapsulates DevIL so it can be used with the NVSG PlugIn mechanism
Image | Helper structure to hold the data of an image
Incarnation | This class abstracts an incarnation count
IndependentPrimitiveSet | Abstract base class for PrimitiveSet objects with independent primitives
IndexMesh | IndexSet specialization used with a MeshedPrimitiveSet
indexSet_t | The indexSet_t structure specifies how an index set is stored in a .NBF file
Intersection | Intersection class
KeyFramedAnimation | Abstract base class for key-framed Animations of type T
KeyInput | Keyboard input helper class to store keyboard press and release events
keyVariant_t | The keyVariant_t structure specifies how a pair of a VariantKey and a StateVariant is stored in a .NBF file
Lanczos3Filter | ScaleFilter functor providing lanczos3 filter functionality
LightingAttribute | StateAttribute indicating whether lighting should be disabled
LightsElement | Helper class to hold the vector of lights that are active while traversing the tree
LightSource | Abstract base class for all light sources
LinearInterpolatedAnimation | An KeyFramedAnimation class that performs linear interpolation
LineAttribute | PrimitiveAttribute specific for Drawables with lines, like Lines or LineStrips
Lines | IndependentPrimitiveSet for lines
LineStrips | StrippedPrimitiveSet for line strips
LOD | Distance-based level of detail class
Log | Logging test results
Manipulator | Base class for all kinds of manipulators
Map | Abstract base class for Map objects
MapArray | Class to hold an array of Map objects
MapElement | Class to hold a single Map
MapList | Class to hold a list of two-dimensional maps
MapMatrix | Class to hold a matrix of Map objects
MapObject | Abstract base class to position one or more Map objects
Material | StateAttribute that describes material properties
Matnnt | Matrix class of fixed size and type
MemFunTbl | Member Function Table template
MeshedPrimitiveSet | Abstract base class for PrimitiveSet objects with points organized as meshes
meshSet_t | The meshSet_t structure specifies how an mesh set is stored in a .NBF file
MissingResult | AnalyzeResult indicating non-complete objects
MouseInput | Mouse input helper class to store mouse events
NBFAlphaTestAttribute | The NBFAlphaTestAttribute structure represents an alpha test state attribute in the NBF format
NBFAnimatedTransform | The NBFAnimatedTransform structure represents an animated transform group node
NBFAnimatedVertexAttributeSet | The NBFAnimatedVertexAttributeSet structure represents a set of animated vertex attributes
NBFAnimation | The NBFAnimation structure represents the common anchor of all animation structures
NBFBillboard | The NBFBillboard structure represents a billboard group node
NBFBlendAttribute | The NBFBlendAttribute structure represents a blend function
NBFCamera | The NBFCamera represents a camera
NBFCgFx | The NBFCgFx structure represents an effect attribute
NBFDepthAttribute | The NBFDepthAttribute structure represents depth buffer settings
NBFDirectedLight |
NBFDrawable | The NBFDrawable represents any kind of a drawable object
NBFFaceAttribute | The NBFFaceAttribute structure represents a render mode
NBFFlipbookAnimation | The NBFFlipbookAnimation structure represents an animated group node
NBFFramedAnimation | The NBFFramedAnimation structure represents a framed animation
NBFFramedIndexAnimation | The NBFFramedIndexAnimation structure represents a framed animation that will be applied to uint_t objects
NBFFramedTrafoAnimation | The NBFFramedTrafoAnimation structure represents a framed animation that will be applied to trafo_t objects
NBFFramedVertexAttributeAnimation | The NBFFramedVertexAttributeAnimation structure represents a framed animation that will be applied to vertexAttrib_t objects
NBFGeoNode | The NBFGeoNode structure represents a geometry node
NBFGroup | The NBFGroup structure represents a group node
NBFHeader | The NBFHeader structure represents the NBF header format
NBFIndependentPrimitiveSet | The NBFIndependentPrimitiveSet structure represents a set of independent primitives
NBFIndexAnimation | The NBFIndexAnimation represents an animation that will be applied to uint_t objects
NBFInterpolatedAnimation | The NBFInterpolatedAnimation structure represents a interpolated animation
NBFInterpolatedTrafoAnimation | The NBFInterpolatedTrafoAnimation structure represents a interpolated animation that will be applied to trafo_t objects
NBFInterpolatedVertexAttributeAnimation | The NBFInterpolatedVertexAttributeAnimation structure represents a interpolated animation that will be applied to vertexAttrib_t objects
NBFLightingAttribute | The NBFLightingAttribute structure represents a render mode
NBFLightSource | The NBFLightSource structure represents a light source node
NBFLineAttribute | The NBFLineAttribute structure represents a render mode
NBFLoader | A Scene Loader for nbf files
NBFLOD | The NBFLOD structure represents a 'Level Of Detail' group node
NBFMaterial | The NBFMaterial structure represents a material
NBFMeshedPrimitiveSet | The NBFMeshedPrimitiveSet structure represents a mesh set
NBFNode | The NBFNode structure represents a general node
NBFObject | The NBFObject structure represents general object data
NBFParallelCamera | The NBFParallelCamera represents a parallel camera
NBFPerspectiveCamera | The NBFPerspectiveCamera represents a perspective camera
NBFPointAttribute | The NBFPointAttribute structure represents a render mode
NBFPointLight |
NBFPrimitiveSet | The NBFPrimitiveSet structure represents a geometry with an NBFVertexAttributeSet
NBFSaver | A scene saver capable to save a NVSG scene to a "NBF" (Nvsg Binary File format) file
NBFSaveTraverser | A Traverser to traverse a scene on saving to "NBF" binary file format
NBFScene | The NBFScene structure represents a scene in the context of computer graphics
NBFSkin | The NBFSkin structure represents a set of skin information for a vertex attribute
NBFSkinnedTriangles | The NBFSkinnedTriangles structure represents skin animated triangles
NBFSpotLight |
NBFStateAttribute | The NBFStateAttribute structure represents a state attribute
NBFStatePass | The NBFStatePass structure represents a set of heterogeneous NBFStateAttributes
NBFStateSet | The NBFStateSet structure represents a set of pairs of VariantKeys and StateVariants
NBFStateVariant | The NBFStateVariant structure represents a set of StatePasses
NBFStrippedPrimitiveSet | The NBFStrippedPrimitiveSet structure represents a strip set
NBFSwitch | The NBFSwitch structure represents a switch group node
NBFTextureAttribute | The NBFTextureAttribute structure represents a texture attribute
NBFTextureAttributeItem | The NBFTextureAttributeItem structure represents a single texture object
NBFTrafoAnimation | The NBFTrafoAnimation represents an animation that will be applied to trafo_t objects
NBFTransform | The NBFTransform structure represents a transform group node
NBFUnlitColorAttribute | The NBFUnlitColorAttribute structure represents the color for unlit objects
NBFVertexAttributeAnimation | The NBFVertexAttributeAnimation represents an animation that will be applied to vertexAttrib_t objects
NBFVertexAttributeSet | The NBFVertexAttributeSet structure represents a set of vertex attributes
NBFViewState | The NBFViewState represents an optional view state used to render the scene
NBFVolumeNode | The NBFVolumeNode structure represents a volume node
Node | Serves as base class for all tree nodes
NodeHintsCullTraverser | CullTraverser that culls based on NodeHints information
NormalizeTraverser | Traverser that normalizes all normals
NullNormalsResult | AnalyzeResult indicating a VertexAttributeSet with null normals
NVBLoader | A Scene Loader for nvb files
NVBLoadTraverser | Internally used traverser for post-processing a just loaded NVB file
NVNVB | Internally used class for loading NVB files
NVSGException |
NVSGLight | The NVSGLight structure specifies the data layout for an effect light parameter
NVSGLoader | A Scene Loader for nvsg files
NVSGMaterial | The NVSGMaterial structure specifies the data layout for an effect material parameter
NVSGSaver | A Scene Saver for nvsg files
NVSGSaveTraverser | A Traverser to traverse a scene on saving to nvsg file format
NVSGScene | The NVSGScene structure specifies some global scene relevant data
NVSGTexImageFmt | Internal data structure used to describe formats
Object | Serves as base class for all traversable objects
OBJSaver | A Scene Saver for obj files
OptimizeTraverser | Base for Traversers that perform some optimizations on a scene
OwnedObject | Helper class to hold a vector of owners of an Object
ParallelCamera | Class describing a parallel (non-perspective) Camera
Path | Class that represents a path through the tree
PerspectiveCamera | Class describing a perspective Camera
plane_t | The plane_t structure specifies how a pair of a bool and a Plane3f is stored in a .NBF file
Planent | Plane class
PlugIn | Plug-in base class
PlugInCallback | PlugInCallback base class
PlugInCallback::DegenerateGeometryInfo | Information structure used for warning PICW_DEGENERATE_GEOMETRY
PlugInCallback::EmptyTokenInfo | Information structure used for warning PICW_EMPTY_TOKEN
PlugInCallback::FileAccessFailedInfo | Information structure used for error PICE_FILE_ACCESS_ERROR
PlugInCallback::FileMappingFailedInfo | Information structure used for error PICE_FILE_MAPPING_ERROR
PlugInCallback::IncompatibleFileInfo | Information structure used for error PICE_INCOMPATIBLE_FILE
PlugInCallback::IncompatibleValueInfo | Information structure used for warning PICW_INCOMPATIBLE_VALUES
PlugInCallback::InvalidFileInfo | Information structure used for error PICE_INVALID_FILE
PlugInCallback::InvalidValueInfo | Information structure used for warning PICW_INVALID_VALUE
PlugInCallback::UndefinedTokenInfo | Information structure used for warning PICW_UNDEFINED_TOKEN
PlugInCallback::UnexpectedTokenInfo | Information structure used for error PICE_UNEXPECTED_TOKEN
PlugInCallback::UnknownTokenInfo | Information structure used for error PICE_UNKNOWN_TOKEN
PlugInCallback::UnsupportedTokenInfo | Information structure used for warning PICW_UNSUPPORTED_TOKEN
PlugInServer | Plug-in management
PLYLoader | A Scene Loader for PLY files
PointAttribute | PrimitiveAttribute specific for Points
PointLight | LightSource representing a point light
Points | IndependentPrimitiveSet for points
PrimitiveAttribute | Base class for all primitive related StateAttribute classes
PrimitiveSet | Base class for Drawable objects holding a VertexAttributeSet
ProblemInfo | Class that holds the problem information
QuadMeshes | MeshedPrimitiveSet for quad meshes
Quads | IndependentPrimitiveSet for quads
QuadStrips | StrippedPrimitiveSet for quad strips
Quatt | Quaternion class
RayIntersectTraverser | RayIntersectTraverser
RCIPtr | A smart pointer template for reference counted objects
RCObject | Provides an interface for reference counted objects
RCObject_AutoPtr | AutoPtr for reference counted objects
RCPtr | A smart pointer template to manage reference counted objects
RCVector | A reference counted vector
ReadMapping | Helper class to ease efficient reading of large files
RedundantLODRangesResult | AnalyzeResult indicating LODs with redundant ranges
RegVal | Template class for easy access to the Registry
removeReference | Convenient helper functor that can be used in STL algorithms
RenderArea | The RenderArea is the place where the actual drawing takes place
RenderElement | Helper class to hold all the state informations valid for a number of PrimitiveSets
RenderElementCompareBackToFront | Comparison functor to sort RenderElements from back to front
RenderElementCompareFrontToBack | Comparison functor to sort RenderElements from front to back
RenderElementCompareStateAttributes | Comparison functor to sort RenderElements by material
RenderTraverser | Pure virtual render traverser class
sampler_t | The sampler_t structure specifies how a sampler parameter is stored in a .NBF file
ScaleFilter | Scale Filter Functor
Scene | Container class to hold all scene related information
SceneLoader | Pure virtual base class for NVSG scene loader plug-ins
SceneSaver | Pure virtual base class for NVSG scene saver plug-ins
SearchTraverser | Traverser for searching all objects of one class type
Shape | Abstract base class for shaped geometries like Boxes, Spheres, etc
SharedModelViewTraverser | Traverser that can handle the model view transform stack
SharedTraverser | Base class providing an interface for read-only traversing of a given scene graph
ShortStrippedResult | AnalyzeResult indicating a StrippedPrimitiveSet with very short strips
SingleChildResult | AnalyzeResult indicating a Group with a single child
Singleton | A Singleton framework
Skin | Provides functionality to work with skinned vertex attribute data
skin_t | The skin_t structure specifies how a skin is stored in a .NBF file
SkinnedTriangles | Class representing a skinned Triangles
SkinnedTriangles::Skin | Internal helper class for SkinnedTriangles
SmoothTraverser | Traverser that can smooth some drawables
Spherent | Sphere class
SpotLight | LightSource representing a spot light
sstr_t | The sstr_t structure specifies how a small string is stored in a .NBF file
StateAttribute | Abstract base class of all attribute objects
StatePass | Container class to hold a number of StateAttribute objects
StateSet | Container class to hold a number of StateVariant objects
StateVariant | Container class to hold a number of StatePass objects
str_t | The str_t structure specifies how a string is stored in a .NBF file
StrippedPrimitiveSet | Abstract base class for PrimitiveSet objects with points organized as strips
StrippingTraverser | Traverser to convert Triangles to TriStrips, and Quads to QuadStrips
StrTokenizer | Separate a string into tokens
Switch | Switch node
switchMask_t | The switchMask_t structure specifies how a SwitchMask is stored in a .NBF file
SWMRSync | Single write, multiple read synchronization class
texBinding_t | The texBinding_t structure specifies how a texture binding is stored in a .NBF file
texCoordSet_t | The texCoordSet_t structure specifies how a texture coordinate set is stored in a .NBF file
texImage_t | The texImage_t structure specifies how a texture image is stored in a .NBF file
TextureAttribute | Texture attribute
TextureAttributeItem | Texture attribute item
TextureAttributeItemData | Data of a texture attribute item that is worth sharing
TextureImage | A texture image abstraction class
TextureLoader | Pure virtual base class for texture loader plugins
TextureSaver | Pure virtual base class for texture saver plugins
Trace | Trace class template
traceConsoleDebugOutput | Output to console _AND_ attached debugger
traceConsoleOutput | Output to console
traceDebugOutput | Output to attached debugger
traceFileConsoleOutput | Output to log file _AND_ console
traceFileDebugOutput | Output to log file _AND_ attached debugger
traceFileOutput | Output to file
TraceFunctor | Uses the function given as template argument to print out a given string
Trackball | Trackball class for simulating a virtual trackball
TrackballCameraManipulator | Simulate a trackball-like camera mouse interaction
TrackballTransformManipulator | Simulate a trackball like object mouse interaction
Trafo | Transformation class
trafo_t | The trafo_t structure specifies how a transformation is stored in a .NBF file
Transform | Transform node
TransformElement | Helper class to hold transformation information used in the render lists
TransformManipulator | Base class for all kinds of transform manipulators
TransformStack | Utility class to hold a stack of concatenated transformation matrices
Traverser | Virtual base class providing the common interface part of ExclusiveTraverser and SharedTraverser
TriangleFilter | ScaleFilter functor providing triangle filter functionality
Triangles | IndependentPrimitiveSet for triangles
TriangulateTraverser | Traverser that converts all flavors of quads to triangles
TriFans | StrippedPrimitiveSet for quad strips
TriStrips | StrippedPrimitiveSet for triangle strips
tweak_t | The tweak_t structure specifies how a tweakable parameter is stored in a .NBF file
Type2EnumType | Converts a given type into a symbolic constant representing a NVSG type
UnifyTraverser | OptimizeTraverser that can unify identical objects in a scene
UnlitColorAttribute | StateAttribute specifying the color in case there is no lighting
UPIID | Unique Plug Interface ID
UPITID | Unique Plug Interface Type ID
Validated | The Validated class adds a validation state to some data
VariantIterator | Helper class used for iterating the StateVariant objects in a StateSet
Vecnt | Vector class of fixed size and type
vertexAttrib_t | The vertexAttrib_t structure specifies how vertex attributes are stored in a .NBF file
VertexAttribute | Class to hold the data of one vertex attribute
VertexAttributeSet | Provides an interface to deal with vertex attribute data
VertexUnifyTraverser | Traverser that can unifies vertices
ViewState | The ViewState class encapsulates the view-specific states
VNVector | A helper class for use in animation
VolLoader | A Texture Loader for Volume datasets of type *.dat.raw
VolLoader::FileInfo | Helper structure to hold information for a VolumeTexture file
VolSaver | TextureSaver plug-in for saving volume textures in the .raw/.dat format
VolumeBrick | Class to represent one brick of a volume
VolumeNode | Class to hold a volume
VolumeTexture | A class representing a VolumeTexture
WalkCameraManipulator | Simulate a walk-through camera-mouse interaction
WriteMapping | Helper class to ease efficient writing of large files
WRLLoader | A Scene loader for wrl files
WRLLoadTraverser | Internally used traverser for post-processing a just loaded VRML file
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


addReference Struct Reference

Convenient helper functor that can be used in STL algorithms to add a reference to reference counted objects. More...

#include <RCObject.h>

List of all members.

Public Member Functions

template<typename RCOBJPTR> RCOBJPTR operator() (RCOBJPTR pRCObject)
Function call operator for one argument, being the pointer to an object.

template<typename AnyType, typename RCOBJPTR> const std::pair< AnyType,
RCOBJPTR > & 		operator() (std::pair< AnyType, RCOBJPTR > &p)
Function call operator for a pair of arguments.

Detailed Description

Convenient helper functor that can be used in STL algorithms to add a reference to reference counted objects.

With this helper functor it's easy and efficient to add a reference to each object contained in a STL container. To copy a container of reference counted objects and increase their reference count you could do something similar to the following:

   for ( iter=src.begin() ; iter!=src.end() ; ++iter )
   {
     dst.push_back( *iter );
     (*iter)->addRef();
   }
or, equivalently but more efficiently, using this functor:
   transform( src.begin(), src.end(), inserter( dst, dst.begin()), addReference() );

Member Function Documentation

RCOBJPTR operator() ( RCOBJPTR pRCObject )

Function call operator for one argument, being the pointer to an object.

The member function addRef() of an RCObject is called on the argument.

Returns:
the argument for usage in the algorithm
Parameters:
pRCObject pointer to reference counted object

const std::pair< AnyType, RCOBJPTR > & operator() ( std::pair< AnyType, RCOBJPTR > & p )

Function call operator for a pair of arguments.

The member function addRef() of an RCObject is called on the second element of the pair of arguments.

Returns:
the argument for usage in the algorithm
Parameters:
p pointer to a pair of any argument and a reference counted object

The documentation for this struct was generated from the following file:
  • RCObject.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

addReference Member List

This is the complete list of members for addReference, including all inherited members.
operator()(RCOBJPTR pRCObject) | addReference
operator()(std::pair< AnyType, RCOBJPTR > &p) | addReference
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Allocator Class Reference

Internal manager for memory allocations. More...

#include <Allocator.h>

Collaboration diagram for Allocator:

[legend]
List of all members.

Public Member Functions

Allocator ()
Default constructor.

~Allocator ()
Destructor.

void * | alloc (size_t size)
Allocate continuous memory of size size.

void * | alloc (size_t size, const char *src, unsigned int ln)
Allocate continuous memory of size size in debug mode.

void | dealloc (void *p, size_t size)
Deallocate previously allocated memory.

Detailed Description

Internal manager for memory allocations.

This class is used as a Singleton by IAllocator, which is the base of all RCObject classes. It manages the efficient allocation of small objects by using an array of FixedAllocator objects, one for each small size up to maxBlockSize. Allocations larger than that size are redirected to the standard allocation ::new.

Constructor & Destructor Documentation

Allocator ( )

Default constructor.

Initializes the array of FixedAllocator objects.

~Allocator ( )

Destructor.

In debug mode warnings on not deleted objects are emitted.

Member Function Documentation

void * alloc ( size_t size ) [inline]

Allocate continuous memory of size size.

Forwards either to the FixedAllocator of the specified size, or to the global new operator.

Parameters:
size size of memory to allocate

void * alloc | ( | size_t | size,
 |  | const char * | src,
 |  | unsigned int | ln
 | ) | [inline]

Allocate continuous memory of size size in debug mode.

Forwards either to the FixedAllocator of the specified size, or to the global new operator. In addition, it stores information for memory leak detection.

Parameters:
size | size of memory to allocate
src | source file name where this memory is allocated
ln | line in the source file

void dealloc | ( | void * | p,
 |  | size_t | size
 | ) | [inline]

Deallocate previously allocated memory.

Forwards either to the FixedAllocator of the specified size, or to the global delete operator. In debug mode, the corresponding information stored by alloc is erased.

Parameters:
p | pointer to the memory to deallocate
size | size of the allocated memory

The documentation for this class was generated from the following file:
  • Allocator.h
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


Member List

Allocator Member List

This is the complete list of members for Allocator, including all inherited members.
alloc(size_t size) | Allocator | [inline]
alloc(size_t size, const char *src, unsigned int ln) | Allocator | [inline]
Allocator() | Allocator |
dealloc(void *p, size_t size) | Allocator | [inline]
~Allocator() | Allocator |
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


AlphaTestAttribute Class Reference

StateAttribute that defines the Alpha test. More...

#include <AlphaTestAttribute.h>

Inheritance diagram for AlphaTestAttribute:

[legend]
Collaboration diagram for AlphaTestAttribute:

[legend]
List of all members.

Public Member Functions

NVSG_API | AlphaTestAttribute ()
Default-constructs a AlphaTestAttribute.

NVSG_API | AlphaTestAttribute (const StateAttribute &rhs)
Constructs a AlphaTestAttribute from a StateAttribute.

NVSG_API | AlphaTestAttribute (const AlphaTestAttribute &rhs)
Constructs a AlphaTestAttribute as a copy from another AlphaTestAttribute.

virtual NVSG_API | ~AlphaTestAttribute ()
Destructs a AlphaTestAttribute.

NVSG_API void | setAlphaFunction (AlphaFunction func)
Set the comparison function.

NVSG_API AlphaFunction | getAlphaFunction () const
Get the compare function.

NVSG_API void | setThreshold (float threshold)
Set the threshold value.

NVSG_API float | getThreshold () const
Get the threshold value.

NVSG_API bool | getEnabledDuringMultiSampleAlpha () const
Get the "enabled during MultiSampleAlpha" flag.

NVSG_API void | setEnabledDuringMultiSampleAlpha (bool state)
Set the "enabled during MultiSampleAlpha" flag.

virtual NVSG_API bool | isTransparent () const
Query the transparency status of this AlphaTestAttribute.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another AlphaTestAttribute.

NVSG_API AlphaTestAttribute & | operator= (const AlphaTestAttribute &rhs)
Assignment operator.

Detailed Description

StateAttribute that defines the Alpha test.

Namespace: nvsg
Remarks:
An AlphaTestAttribute defines an equation that can be used to cull or draw fragments based on the alpha value of that fragment. AlphaTestAttribute reduces the alpha test to a simple pass fail based on the supplied AlphaFunction and threshold value. If the fragment passes the test, it is drawn - otherwise it is culled.
See also:
BlendAttribute, LineAttribute, PointAttribute, StateAttribute,

Constructor & Destructor Documentation

NVSG_API AlphaTestAttribute ( )

Default-constructs a AlphaTestAttribute.

Remarks:
A default-constructed AlphaTestAttribute is initialized with AlphaFunction to AF_ALWAYS and threshold to 0.0 - allowing all fragments to be drawn.

NVSG_API AlphaTestAttribute ( const StateAttribute & rhs ) [explicit]

Constructs a AlphaTestAttribute from a StateAttribute.

Parameters:
rhs StateAttribute to construct the AlphaTestAttribute from.
Remarks:
A AlphaTestAttribute constructed from a StateAttribute is initialized with CompareFunc AF_ALWAYS and threshold 0.0.

NVSG_API AlphaTestAttribute ( const AlphaTestAttribute & rhs )

Constructs a AlphaTestAttribute as a copy from another AlphaTestAttribute.

Parameters:
rhs Source AlphaTestAttribute.

virtual NVSG_API ~AlphaTestAttribute ( ) [virtual]

Destructs a AlphaTestAttribute.

Member Function Documentation

NVSG_API void setAlphaFunction ( AlphaFunction func )

Set the comparison function.

Parameters:
func The conditional for the comparison equation.
Remarks:
This function controls whether alpha values will cause certain fragments to be culled or drawn. If the equation: (fragment.a AlphaFunction threshold) == true, the fragment is drawn.
See also:
AlphaFunction

AlphaFunction getAlphaFunction ( ) const [inline]

Get the compare function.

Returns:
nvsg::AlphaFunction indicating the compare function.
See also:
setAlphaFunction

NVSG_API void setThreshold ( float threshold )

Set the threshold value.

Parameters:
threshold The threshold value used as described in setAlphaFunction.
See also:
getThreshold

float getThreshold ( ) const [inline]

Get the threshold value.

Returns:
float indicating the current threshold value
See also:
setThreshold

bool getEnabledDuringMultiSampleAlpha ( ) const [inline]

Get the "enabled during MultiSampleAlpha" flag.

Returns:
bool indicating whether this StateAttribute should be left enabled or set to disabled when using MultiSampleAlpha Coverage for transparency.
See also:
setAffectsMultiSampleAlpha

NVSG_API void setEnabledDuringMultiSampleAlpha ( bool state )

Set the "enabled during MultiSampleAlpha" flag.

Parameters:
state boolean indicating whether this StateAttribute should be left enabled or set to disabled when using MultiSampleAlpha Coverage for transparency. Disabling AlphaFunc during MultiSample can provide improved image quality (with reduced performance) in certain circumstances - specifically where AlphaFunc is being used as a performance transparency mode.
See also:
getEnabledDuringMultiSampleAlpha

virtual NVSG_API bool isTransparent ( ) const [virtual]

Query the transparency status of this AlphaTestAttribute.

Returns:
false, the AlphaTestAttribute always returns false.
Remarks:
An AlphaTestAttribute always returns false so that it is not sorted with the rest of the scene, as this is not necessary for AlphaFunc.
See also:
StateAttribute::isTransparent

Reimplemented from StateAttribute.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another AlphaTestAttribute.

Parameters:
p | Pointer to the constant AlphaTestAttribute to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true
deepCompare | Optional parameter to perform a deep comparsion; default is false
Returns:
true if the AlphaTestAttribute p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as StateAttribute, they are considered to be equivalent if they have the same nvsg::AlphaFunction and the same threshold values.
Note:
The behaviour is undefined if p is not a AlphaTestAttribute nor derived from one.
See also:
StateAttribute, getAlphaFunction

Reimplemented from Object.

NVSG_API AlphaTestAttribute& operator= ( const AlphaTestAttribute & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant AlphaTestAttribute to copy from
Returns:
A reference to the assigned AlphaTestAttribute
Remarks:
The assignment operator calls the assignment operator of StateAttribute and copies the AlphaTestAttribute specific data then.
See also:
PrimitiveAttribute

The documentation for this class was generated from the following file:
  • AlphaTestAttribute.h
Generated on Tue Jan 15 10:28:58 2008 for NVSGSDK by NVIDIA


Member List

AlphaTestAttribute Member List

This is the complete list of members for AlphaTestAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
AlphaTestAttribute() | AlphaTestAttribute |
AlphaTestAttribute(const StateAttribute &rhs) | AlphaTestAttribute | [explicit]
AlphaTestAttribute(const AlphaTestAttribute &rhs) | AlphaTestAttribute |
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAlphaFunction() const | AlphaTestAttribute | [inline]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getEnabledDuringMultiSampleAlpha() const | AlphaTestAttribute | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getThreshold() const | AlphaTestAttribute | [inline]
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | AlphaTestAttribute | [virtual]
isTransparent() const | AlphaTestAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const AlphaTestAttribute &rhs) | AlphaTestAttribute |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAlphaFunction(AlphaFunction func) | AlphaTestAttribute |
setAnnotation(const std::string &anno) | Object |
setEnabledDuringMultiSampleAlpha(bool state) | AlphaTestAttribute |
setName(const std::string &name) | Object |
setThreshold(float threshold) | AlphaTestAttribute |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~AlphaTestAttribute() | AlphaTestAttribute | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:28:58 2008 for NVSGSDK by NVIDIA


AnalyzeResult Class Reference

Base class of the analyzing results determined with the AnalyzeTraverser. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for AnalyzeResult:

[legend]
List of all members.

Public Member Functions

virtual | ~AnalyzeResult ()
Virtual Destructor.

Public Attributes

unsigned int | objectCode
The code of objects, this result refers to.

unsigned int | objectCount
The number of objects of this type.

Detailed Description

Base class of the analyzing results determined with the AnalyzeTraverser.

Namespace: nvsg
Remarks:
The AnalyzeResult holds the objectCode of the object that this result refers to, and the number of objects that have been encountered in the scene graph.
See also:
AnalyzeTraverser, CombinableResult, DenormalizedNormalsResult, EmptyResult, EquivalenceResult, IdentityResult, MissingResult, NullNormalsResult, SingleChildResult, ShortStrippedResult

Constructor & Destructor Documentation

virtual ~AnalyzeResult ( ) [inline, virtual]

Virtual Destructor.

Member Data Documentation

unsigned int objectCode

The code of objects, this result refers to.

unsigned int objectCount

The number of objects of this type.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


Member List

AnalyzeResult Member List

This is the complete list of members for AnalyzeResult, including all inherited members.
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


AnalyzeTraverser Class Reference

Traverser that analyzes a tree and reports about potential deficiencies. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for AnalyzeTraverser:

[legend]
Collaboration diagram for AnalyzeTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | AnalyzeTraverser (void)
Default Constructor.

NVSG_API unsigned int | getAnalysis (std::vector< AnalyzeResult * > &results) const
Get the analysis results of the latest traversal.

Protected Member Functions

virtual NVSG_API | ~AnalyzeTraverser (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Override of the doApply method.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Analyze an nvsg::AnimatedTransform.

virtual NVSG_API void | handleAnimatedVertexAttributeSet (const nvsg::AnimatedVertexAttributeSet *p)
Analyze an nvsg::AnimatedVertexAttributeSet.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Analyze a nvsg::Billboard.

virtual NVSG_API void | handleBlendAttribute (const nvsg::BlendAttribute *p)
Analyze a nvsg::BlendAttribute.

virtual NVSG_API void | handleCgFx (const nvsg::CgFx *p)
Analyze a nvsg::CgFx.

virtual NVSG_API void | handleDepthAttribute (const nvsg::DepthAttribute *p)
Analyze a nvsg::DepthAttribute.

virtual NVSG_API void | handleDirectedLight (const nvsg::DirectedLight *p)
Analyze a nvsg::DirectedLight.

virtual NVSG_API void | handleFaceAttribute (const nvsg::FaceAttribute *p)
Analyze a nvsg::FaceAttribute.

virtual NVSG_API void | handleFlipbookAnimation (const nvsg::FlipbookAnimation *p)
Analyze a nvsg::FlipbookAnimation.

virtual NVSG_API void | handleFramedIndexAnimation (const nvsg::FramedAnimation< unsigned int > *p)
Analyze a nvsg::FramedAnimation of type unsigned int.

virtual NVSG_API void | handleFramedTrafoAnimation (const nvsg::FramedAnimation< nvmath::Trafo > *p)
Analyze a nvsg::FramedAnimation of type nvmath::Trafo.

virtual NVSG_API void | handleFramedVertexAttributeAnimation (const nvsg::FramedAnimation< nvsg::VertexAttribute > *p)
Analyze a nvsg::FramedAnimation of type nvsg::VertexAttribute.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Analyze a nvsg::GeoNode.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Analyze a nvsg::Group.

virtual NVSG_API void | handleLinearInterpolatedTrafoAnimation (const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p)
Analyze a nvsg::LinearInterpolatedAnimation of type nvmath::Trafo.

virtual NVSG_API void | handleLinearInterpolatedVertexAttributeAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p)
Analyze a nvsg::LinearInterpolatedAnimation of type nvsg::VertexAttribute.

virtual NVSG_API void | handleLineAttribute (const nvsg::LineAttribute *p)
Analyze a nvsg::LineAttribute.

virtual NVSG_API void | handleLines (const nvsg::Lines *p)
Analyze a nvsg::Lines.

virtual NVSG_API void | handleLineStrips (const nvsg::LineStrips *p)
Analyze a nvsg::LineStrips.

virtual NVSG_API void | handleLOD (const nvsg::LOD *p)
Analyze a nvsg::LOD.

virtual NVSG_API void | handleMaterial (const nvsg::Material *p)
Analyze a nvsg::Material.

virtual NVSG_API void | handlePointAttribute (const nvsg::PointAttribute *p)
Analyze a nvsg::PointAttribute.

virtual NVSG_API void | handlePointLight (const nvsg::PointLight *p)
Analyze a nvsg::PointLight.

virtual NVSG_API void | handlePoints (const nvsg::Points *p)
Analyze a nvsg::Points.

virtual NVSG_API void | handleQuadMeshes (const nvsg::QuadMeshes *p)
Analyze a nvsg::QuadMeshes.

virtual NVSG_API void | handleQuads (const nvsg::Quads *p)
Analyze a nvsg::Quads.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *p)
Analyze a nvsg::QuadStrips.

virtual NVSG_API void | handleShape (const nvsg::Shape *p)
Analyze a nvsg::Shape.

virtual NVSG_API void | handleSkin (const nvsg::Skin *p)
Analyze a nvsg::Skin.

virtual NVSG_API void | handleSkinnedTriangles (const nvsg::SkinnedTriangles *p)
Analyze a nvsg::SkinnedTriangles.

virtual NVSG_API void | handleSpotLight (const nvsg::SpotLight *p)
Analyze a nvsg::SpotLight.

virtual NVSG_API void | handleStatePass (const nvsg::StatePass *p)
Analyze a nvsg::StatePass.

virtual NVSG_API void | handleStateSet (const nvsg::StateSet *p)
Analyze a nvsg::StateSet.

virtual NVSG_API void | handleStateVariant (const nvsg::StateVariant *p)
Analyze a nvsg::StateVariant.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *p)
Analyze a nvsg::Switch.

virtual NVSG_API void | handleTextureAttribute (const nvsg::TextureAttribute *p)
Analyze a nvsg::TextureAttribute.

virtual NVSG_API void | handleTextureAttributeItem (const nvsg::TextureAttributeItem *p, unsigned int tu)
Analyze a nvsg::TextureAttributeItem.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Analyze a nvsg::Transform.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *p)
Analyze a nvsg::Triangles.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *p)
Analyze a nvsg::TriFans.

virtual NVSG_API void | handleTriStrips (const nvsg::TriStrips *p)
Analyze a nvsg::TriStrips.

virtual NVSG_API void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *p)
Analyze a nvsg::VertexAttributeSet.

Detailed Description

Traverser that analyzes a tree and reports about potential deficiencies.

Namespace: nvsg
Remarks:
The AnalyzeTraverser is a scene graph analyzing tool. It can give you hints on potential problems in your scene graph.
Example
To get the results of the AnalyzeTraverser on a given Scene, do something like that:
    AnalyzeTraverser * analyzeTraverser = new AnalyzeTraverser;
    analyzeTraverser->addRef();
    std::vector<AnalyzeResult *> results;
    analyzeTraverser->doApply( pScene );
    unsigned int numberOfResults = analyzeTraverser->getAnalysis( results );
    for ( unsigned int i=0 ; i<numberOfResult ; i++ )
    {
      if ( dynamic_cast<EmptyResult *>( results[i] ) != NULL )
      {
        EmptyResult * emptyResult = dynamic_cast<EmptyResult *>( results[i] );
        // handle empty results
      }
      else if ( dynamic_cast<EquivalenceResult *>( results[i] ) != NULL )
      {
        EquivalenceResult * equivalenceResult = dynamic_cast<EquivalenceResult *>( results[i] );
        // handle equivalence results
      }
      else if ( ... )
      // handle other known results
      // ...
      else
      {
        // handle any unknown AnalyzeResult
      }
      // delete the result after interpretation
      delete results[i];
    }
    analyzeTraverser->removeRef();
See also:
AnalyzeResult, Traverser

Constructor & Destructor Documentation

NVSG_API AnalyzeTraverser ( void )

Default Constructor.

virtual NVSG_API ~AnalyzeTraverser ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the AnalyzeTraverser is decremented to zero.

Member Function Documentation

NVSG_API unsigned int getAnalysis ( std::vector< AnalyzeResult * > & results ) const

Get the analysis results of the latest traversal.

Parameters:
results A reference to the vector pointers to an AnalyzeResult object to fill.
Returns:
The number of AnalyzeResult objects generated.
Remarks:
On return, each element of the vector results holds a pointer to an AnalyzeResult. Those objects are owned by the requester, then. There can be multiple AnalyzeResult objects of the same type, but referring to different types of objects in the Scene.
See also:
AnalyzeResult

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Override of the doApply method.

Parameters:
root A pointer to the read-locked root node of the tree to analyze.
Remarks:
The doApply method is the traversal entry point of a Traverser. The local data is cleared and Traverser::doApply() is called to start traversal.
See also:
nvsg::Scene, Traverser

Reimplemented from SharedTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Analyze an nvsg::AnimatedTransform.

Parameters:
p A pointer to the read-locked nvsg::AnimatedTransform to analyze.
Remarks:
An nvsg::AnimatedTransform is tested for emptiness (no children), equivalence with any previously encountered nvsg::AnimatedTransform, and for a missing nvsg::Animation.
See also:
nvsg::AnimatedTransform, EmptyResult, EquivalenceResult, MissingResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleAnimatedVertexAttributeSet ( const nvsg::AnimatedVertexAttributeSet * p ) [protected, virtual]

Analyze an nvsg::AnimatedVertexAttributeSet.

Parameters:
p A pointer to the read-locked nvsg::AnimatedVertexAttributeSet to analyze.
Remarks:
An nvsg::AnimatedVertexAttributeSet is tested for emptiness (no vertices), equivalence with any previously encountered nvsg::AnimatedVertexAttributSet, and if there are any unnormalized normals.
See also:
nvsg::AnimatedVertexAttributeSet, EmptyResult, EquivalenceResult, NullNormalsResult, DenormalizedNormalsResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Analyze a nvsg::Billboard.

Parameters:
p A pointer to the read-locked nvsg::Billboard to analyze.
Remarks:
A nvsg::Billboard is tested for emptiness (no children), and equivalence with any previously encountered nvsg::Billboard.
See also:
nvsg::Billboard, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleBlendAttribute ( const nvsg::BlendAttribute * p ) [protected, virtual]

Analyze a nvsg::BlendAttribute.

Parameters:
p A pointer to the read-locked nvsg::BlendAttribute to analyze.
Remarks:
A nvsg::BlendAttribute is tested for equivalence with any previously encountered nvsg::BlendAttribute.
See also:
nvsg::BlendAttribute, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Analyze a nvsg::CgFx.

Parameters:
p A pointer to the read-locked nvsg::CgFx to analyze.
Remarks:
A nvsg::CgFx is tested for equivalence with any previously encountered nvsg::CgFx.
See also:
nvsg::CgFx, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleDepthAttribute ( const nvsg::DepthAttribute * p ) [protected, virtual]

Analyze a nvsg::DepthAttribute.

Parameters:
p A pointer to the read-locked nvsg::DepthAttribute to analyze.
Remarks:
A nvsg::DepthAttribute is tested for equivalence with any previously encountered nvsg::DepthAttribute.
See also:
nvsg::DepthAttribute, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleDirectedLight ( const nvsg::DirectedLight * p ) [protected, virtual]

Analyze a nvsg::DirectedLight.

Parameters:
p A pointer to the read-locked nvsg::DirectedLight to analyze.
Remarks:
A nvsg::DirectedLight is tested for equivalence with any previously encountered nvsg::DirectedLight.
See also:
nvsg::DirectedLight, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFaceAttribute ( const nvsg::FaceAttribute * p ) [protected, virtual]

Analyze a nvsg::FaceAttribute.

Parameters:
p A pointer to the read-locked nvsg::FaceAttribute to analyze.
Remarks:
A nvsg::FaceAttribute is tested for equivalence with any previously encountered nvsg::FaceAttribute.
See also:
nvsg::FaceAttribute, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFlipbookAnimation ( const nvsg::FlipbookAnimation * p ) [protected, virtual]

Analyze a nvsg::FlipbookAnimation.

Parameters:
p A pointer to the read-locked nvsg::FlipbookAnimation to analyze.
Remarks:
A nvsg::FlipbookAnimation is tested for emptiness (no children), equivalence with any previously encountered nvsg::FlipbookAnimation, and for a missing nvsg::Animation.
See also:
nvsg::AnimatedTransform, EmptyResult, EquivalenceResult, MissingResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFramedIndexAnimation ( const nvsg::FramedAnimation< unsigned int > * p ) [protected, virtual]

Analyze a nvsg::FramedAnimation of type unsigned int.

Parameters:
p A pointer to the read-locked nvsg::FramedAnimation of type unsigned int to analyze.
Remarks:
A nvsg::FramedAnimation of type unsigned int is tested for emptiness (no frames) and for equivalence with any previously encountered nvsg::FramedAnimation of type unsigned int.
See also:
nvsg::FramedAnimation, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFramedTrafoAnimation ( const nvsg::FramedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Analyze a nvsg::FramedAnimation of type nvmath::Trafo.

Parameters:
p A pointer to the read-locked nvsg::FramedAnimation of type nvmath::Trafo to analyze.
Remarks:
A nvsg::FramedAnimation of type nvmath::Trafo is tested for emptiness (no frames) and for equivalence with any previously encountered nvsg::FramedAnimation of type nvmath::Trafo.
See also:
nvsg::FramedAnimation, nvmath::Trafo, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFramedVertexAttributeAnimation ( const nvsg::FramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Analyze a nvsg::FramedAnimation of type nvsg::VertexAttribute.

Parameters:
p A pointer to the read-locked nvsg::FramedAnimation of type nvsg::VertexAttribute to analyze.
Remarks:
A nvsg::FramedAnimation of type nvsg::VertexAttribute is tested for emptiness (no frames) and for equivalence with any previously encountered nvsg::FramedAnimation of type nvsg::VertexAttribute.
See also:
nvsg::FramedAnimation, nvsg::VertexAttribute, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Analyze a nvsg::GeoNode.

Parameters:
p A pointer to the read-locked nvsg::GeoNode to analyze.
Remarks:
A nvsg::GeoNode is tested for emptiness (no geometries) and for equivalence with any previously encountered nvsg::GeoNode.
See also:
nvsg::GeoNode, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Analyze a nvsg::Group.

Parameters:
p A pointer to the read-locked nvsg::Group to analyze.
Remarks:
A nvsg::Group is tested for emptiness (no children), for equivalence with any previously encountered nvsg::Group, and for holding a single child only.
See also:
nvsg::Group, EmptyResult, EquivalenceResult, SingleChildResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLinearInterpolatedTrafoAnimation ( const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Analyze a nvsg::LinearInterpolatedAnimation of type nvmath::Trafo.

Parameters:
p A pointer to the read-locked nvsg::LinearInterpolatedAnimation of type nvmath::Trafo to analyze.
Remarks:
A nvsg::LinearInterpolatedAnimation of type nvmath::Trafo is tested for emptiness (no keys) and for equivalence with any previously encountered nvsg::LinearInterpolatedAnimation of type nvmath::Trafo.
See also:
nvsg::LinearInterpolatedAnimation, nvmath::Trafo, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLinearInterpolatedVertexAttributeAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Analyze a nvsg::LinearInterpolatedAnimation of type nvsg::VertexAttribute.

Parameters:
p A pointer to the read-locked nvsg::LinearInterpolatedAnimation of type nvsg::VertexAttribute to analyze.
Remarks:
A nvsg::LinearInterpolatedAnimation of type nvsg::VertexAttribute is tested for emptiness (no keys) and for equivalence with any previously encountered nvsg::LinearInterpolatedAnimation of type nvsg::VertexAttribute.
See also:
nvsg::LinearInterpolatedAnimation, nvsg::VertexAttribute, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLineAttribute ( const nvsg::LineAttribute * p ) [protected, virtual]

Analyze a nvsg::LineAttribute.

Parameters:
p A pointer to the read-locked nvsg::LineAttribute to analyze.
Remarks:
A nvsg::LineAttribute is tested for equivalence with any previously encountered nvsg::LineAttribute.
See also:
nvsg::LineAttribute, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Analyze a nvsg::Lines.

Parameters:
p A pointer to the read-locked nvsg::Lines to analyze.
Remarks:
A nvsg::Lines is tested for emptiness (no indices) and for equivalence with any previously encountered nvsg::Lines.
See also:
nvsg::Lines, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Analyze a nvsg::LineStrips.

Parameters:
p A pointer to the read-locked nvsg::LineStrips to analyze.
Remarks:
A nvsg::LineStrips is tested for emptiness (no strips) and for equivalence with any previously encountered nvsg::LineStrips.
See also:
nvsg::LineStrips, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Analyze a nvsg::LOD.

Parameters:
p A pointer to the read-locked nvsg::LOD to analyze.
Remarks:
A nvsg::LOD is tested for emptiness (no children), for equivalence with any previously encountered nvsg::LOD, and for holding a single child only.
See also:
nvsg::LOD, EmptyResult, EquivalenceResult, RedundantLODRangesResult, SingleChildResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleMaterial ( const nvsg::Material * p ) [protected, virtual]

Analyze a nvsg::Material.

Parameters:
p A pointer to the read-locked nvsg::Material to analyze.
Remarks:
A nvsg::Material is tested for equivalence with any previously encountered nvsg::Material.
See also:
nvsg::Material, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePointAttribute ( const nvsg::PointAttribute * p ) [protected, virtual]

Analyze a nvsg::PointAttribute.

Parameters:
p A pointer to the read-locked nvsg::PointAttribute to analyze.
Remarks:
A nvsg::PointAttribute is tested for equivalence with any previously encountered nvsg::PointAttribute.
See also:
nvsg::PointAttribute, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePointLight ( const nvsg::PointLight * p ) [protected, virtual]

Analyze a nvsg::PointLight.

Parameters:
p A pointer to the read-locked nvsg::PointLight to analyze.
Remarks:
A nvsg::PointLight is tested for equivalence with any previously encountered nvsg::PointLight.
See also:
nvsg::PointLight, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Analyze a nvsg::Points.

Parameters:
p A pointer to the read-locked nvsg::Points to analyze.
Remarks:
A nvsg::Points is tested for emptiness (no indices) and for equivalence with any previously encountered nvsg::Points.
See also:
nvsg::Points, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Analyze a nvsg::QuadMeshes.

Parameters:
p A pointer to the read-locked nvsg::QuadMeshes to analyze.
Remarks:
A nvsg::QuadMeshes is tested for emptiness (no meshes) and for equivalence with any previously encountered nvsg::QuadMeshes.
See also:
nvsg::QuadMeshes, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Analyze a nvsg::Quads.

Parameters:
p A pointer to the read-locked nvsg::Quads to analyze.
Remarks:
A nvsg::Quads is tested for emptiness (no indices) and for equivalence with any previously encountered nvsg::Quads.
See also:
nvsg::Quads, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Analyze a nvsg::QuadStrips.

Parameters:
p A pointer to the read-locked nvsg::QuadStrips to analyze.
Remarks:
A nvsg::QuadStrips is tested for emptiness (no strips), for equivalence with any previously encountered nvsg::Quads, and for holding strips of length up to only four.
See also:
nvsg::QuadStrips, EmptyResult, EquivalenceResult, ShortStrippedResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleShape ( const nvsg::Shape * p ) [protected, virtual]

Analyze a nvsg::Shape.

Parameters:
p A pointer to the read-locked nvsg::Shape to analyze.
Remarks:
A nvsg::Shape is tested for emptiness (no primitive sets) and for equivalence with any previously encountered nvsg::Shape.
See also:
nvsg::Shape, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSkin ( const nvsg::Skin * p ) [protected, virtual]

Analyze a nvsg::Skin.

Parameters:
p A pointer to the read-locked nvsg::Skin to analyze.
Remarks:
A nvsg::Skin is tested for emptiness (no joints) and equivalence with any previously encountered nvsg::Skin.
See also:
nvsg::Skin, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Analyze a nvsg::SkinnedTriangles.

Parameters:
p A pointer to the read-locked nvsg::SkinnedTriangles to analyze.
Remarks:
A nvsg::SkinnedTriangles is tested for emptiness (no skins) and for equivalence with any previously encountered nvsg::SkinnedTriangles.
See also:
nvsg::SkinnedTriangles, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSpotLight ( const nvsg::SpotLight * p ) [protected, virtual]

Analyze a nvsg::SpotLight.

Parameters:
p A pointer to the read-locked nvsg::SpotLight to analyze.
Remarks:
A nvsg::SpotLight is tested for equivalence with any previously encountered nvsg::SpotLight.
See also:
nvsg::SpotLight, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Analyze a nvsg::StatePass.

Parameters:
p A pointer to the read-locked nvsg::StatePass to analyze.
Remarks:
A nvsg::StatePass is tested for emptiness (no attributes) and for equivalence with any previously encountered nvsg::StatePass.
See also:
nvsg::StatePass, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Analyze a nvsg::StateSet.

Parameters:
p A pointer to the read-locked nvsg::StateSet to analyze.
Remarks:
A nvsg::StateSet is tested for emptiness (no variants) and for equivalence with any previously encountered nvsg::StateSet.
See also:
nvsg::StateSet, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleStateVariant ( const nvsg::StateVariant * p ) [protected, virtual]

Analyze a nvsg::StateVariant.

Parameters:
p A pointer to the read-locked nvsg::StateVariant to analyze.
Remarks:
A nvsg::StateVariant is tested for emptiness (no passes) and for equivalence with any previously encountered nvsg::StateVariant.
See also:
nvsg::StateVariant, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Analyze a nvsg::Switch.

Parameters:
p A pointer to the read-locked nvsg::Switch to analyze.
Remarks:
A nvsg::Switch is tested for emptiness (no children) and for equivalence with any previously encountered nvsg::Switch.
See also:
nvsg::Switch, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTextureAttribute ( const nvsg::TextureAttribute * p ) [protected, virtual]

Analyze a nvsg::TextureAttribute.

Parameters:
p A pointer to the read-locked nvsg::TextureAttribute to analyze.
Remarks:
A nvsg::TextureAttribute is tested for emptiness (no items) and for equivalence with any previously encountered nvsg::TextureAttribute.
See also:
nvsg::TextureAttribute, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | p,
 |  | unsigned int | tu
 | ) | [protected, virtual]

Analyze a nvsg::TextureAttributeItem.

Parameters:
p | A pointer to the read-locked nvsg::TextureAttributeItem to analyze.
tu | The texture unit, this nvsg::TextureAttributeItem is bound to.
Remarks:
A nvsg::TextureAttributeItem is tested for equivalence with any previously encountered nvsg::TextureAttributeItem.
See also:
nvsg::TextureAttributeItem, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Analyze a nvsg::Transform.

Parameters:
p A pointer to the read-locked nvsg::Transform to analyze.
Remarks:
A nvsg::Transform is tested for emptiness (no children), for equivalence with any previously encountered nvsg::Transform, and for being the identity transform.
See also:
nvsg::Transform, EmptyResult, EquivalenceResult, IdentityResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Analyze a nvsg::Triangles.

Parameters:
p A pointer to the read-locked nvsg::Triangles to analyze.
Remarks:
A nvsg::Triangles is tested for emptiness (no indices) and for equivalence with any previously encountered nvsg::Triangles.
See also:
nvsg::Triangles, EmptyResult, EquivalenceResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Analyze a nvsg::TriFans.

Parameters:
p A pointer to the read-locked nvsg::TriFans to analyze.
Remarks:
A nvsg::TriFans is tested for emptiness (no strips), for equivalence with any previously encountered nvsg::TriFans, and for holding fans of length up to only three.
See also:
nvsg::TriFans, EmptyResult, EquivalenceResult, ShortStrippedResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Analyze a nvsg::TriStrips.

Parameters:
p A pointer to the read-locked nvsg::TriStrips to analyze.
Remarks:
A nvsg::TriStrips is tested for emptiness (no strips), for equivalence with any previously encountered nvsg::TriStrips, and for holding strips of length up to only three.
See also:
nvsg::TriStrips, EmptyResult, EquivalenceResult, ShortStrippedResult

Reimplemented from SharedTraverser.

virtual NVSG_API void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

Analyze a nvsg::VertexAttributeSet.

Parameters:
p A pointer to the read-locked nvsg::VertexAttributeSet to analyze.
Remarks:
A nvsg::VertexAttributeSet is tested for emptiness (no vertices), for equivalence with any previously encountered nvsg::VertexAttributeSet, and for holding denormalized normals.
See also:
nvsg::VertexAttributeSet, EmptyResult, EquivalenceResult, DenormalizedNormalsResult, NullNormalsResult

Reimplemented from SharedTraverser.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:27 2008 for NVSGSDK by NVIDIA


Member List

AnalyzeTraverser Member List

This is the complete list of members for AnalyzeTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
AnalyzeTraverser(void) | AnalyzeTraverser |
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | AnalyzeTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
getAnalysis(std::vector< AnalyzeResult * > &results) const | AnalyzeTraverser |
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | AnalyzeTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *p) | AnalyzeTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | AnalyzeTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | AnalyzeTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | AnalyzeTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | AnalyzeTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | AnalyzeTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | AnalyzeTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *p) | AnalyzeTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *p) | AnalyzeTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | AnalyzeTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | AnalyzeTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | AnalyzeTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | AnalyzeTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | AnalyzeTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | AnalyzeTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | AnalyzeTraverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | AnalyzeTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | AnalyzeTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | AnalyzeTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | AnalyzeTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | AnalyzeTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | AnalyzeTraverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | AnalyzeTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | AnalyzeTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | AnalyzeTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | AnalyzeTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | AnalyzeTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *p) | AnalyzeTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | AnalyzeTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | AnalyzeTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | AnalyzeTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | AnalyzeTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | AnalyzeTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | AnalyzeTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | AnalyzeTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, unsigned int tu) | AnalyzeTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | AnalyzeTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | AnalyzeTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | AnalyzeTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | AnalyzeTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | AnalyzeTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *vnode) | SharedTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~AnalyzeTraverser(void) | AnalyzeTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:27 2008 for NVSGSDK by NVIDIA


AnimatedTransform Class Reference

Class representing an animated Transform. More...

#include <AnimatedTransform.h>

Inheritance diagram for AnimatedTransform:

[legend]
Collaboration diagram for AnimatedTransform:

[legend]
List of all members.

Public Member Functions

NVSG_API | AnimatedTransform ()
Default-constructs a AnimatedTransform.

NVSG_API | AnimatedTransform (const AnimatedTransform &rhs)
Constructs a AnimatedTransform as a copy of another AnimatedTransform.

virtual NVSG_API | ~AnimatedTransform ()
virtual NVSG_API const nvmath::Trafo & | getTrafo (void) const
Get the current transformation represented by this AnimatedTransform.

virtual NVSG_API void | setTrafo (const nvmath::Trafo &trafo)
Set the current transformation for this AnimatedTransform.

NVSG_API TrafoAnimationHandle * | getAnimation () const
Get a pointer to the constant Animation.

NVSG_API void | setAnimation (TrafoAnimationHandle *animation)
Set the Animation.

virtual NVSG_API bool | determineAnimationContainment () const
Determine the animation containment of this object.

NVSG_API AnimatedTransform & | operator= (const AnimatedTransform &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another AnimatedTransform.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

virtual NVSG_API bool | invalidateIncarnation ()
Overwrite to invalidate the bounding sphere.

Detailed Description

Class representing an animated Transform.

Namespace: nvsg
Remarks:
An AnimatedTransform is a Transform that also holds an Animation of nvmath::Trafo objects. The nvmath::Trafo to use is determined from the Animation of each frame.
See also:
Animation, nvmath::Trafo, Transform

Constructor & Destructor Documentation

NVSG_API AnimatedTransform ( )

Default-constructs a AnimatedTransform.

NVSG_API AnimatedTransform ( const AnimatedTransform & rhs )

Constructs a AnimatedTransform as a copy of another AnimatedTransform.

virtual NVSG_API ~AnimatedTransform ( ) [virtual]

Destructs a AnimatedTransform

Member Function Documentation

const nvmath::Trafo & getTrafo ( void ) const [inline, virtual]

Get the current transformation represented by this AnimatedTransform.

Returns:
A reference to the constant nvmath::Trafo, representing the current transformation.
See also:
nvmath::Trafo, setTrafo

Reimplemented from Transform.

void setTrafo ( const nvmath::Trafo & trafo ) [inline, virtual]

Set the current transformation for this AnimatedTransform.

Parameters:
trafo A reference to the constant nvmath::Trafo to use.
Remarks:
The current transformation is replaced by trafo.
See also:
nvmath::Trafo, getTrafo

Reimplemented from Transform.

TrafoAnimationHandle * getAnimation ( ) const [inline]

Get a pointer to the constant Animation.

Returns:
A pointer to the constant Animation, or NULL if there is none
See also:
Animation, nvmath::Trafo

NVSG_API void setAnimation ( TrafoAnimationHandle * animation )

Set the Animation.

Parameters:
animation Pointer to the constant Animation to set
Remarks:
The reference count of the Animation animation is incremented and the reference count of any previous Animation is decremented. If these two Animation objects hold a different number of frames, the number of frames is invalidated. The current frame is reset to zero.
Note:
The behavior is undefined if animation is not a valid pointer.
See also:
Animation, nvmath::Trafo, invalidateAnimationContainment, addRef, removeRef

bool determineAnimationContainment ( ) const [inline, virtual]

Determine the animation containment of this object.

Returns:
true.
Remarks:
An AnimatedTransform always contains an animation.

Reimplemented from Group.

NVSG_API AnimatedTransform& operator= ( const AnimatedTransform & rhs )

Assignment operator.

Parameters:
rhs Reference to a constant AnimatedTransform to copy from
Returns:
A reference to the assigned AnimatedTransform
Remarks:
The assignment operator first calls the assignment operator of Transform. Then the reference count of the current Animation is decremented, the Animation of rhs is cloned, and it's reference count is incremented.
See also:
Animation, Transform, addRef, removeRef

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another AnimatedTransform.

Parameters:
p | Pointer to the constant AnimatedTransform to test for equivalence with
ignoreNames | Optional parameter to ignore the names of the objects; default is true
deepCompare | Optional parameter to perform a deep comparsion; default is false
Returns:
true if the AnimatedTransform p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Transform objects, their Animation objects are tested for equivalence. If deepCompare is false, they are considered to be equivalent if they are the same pointers. Otherwise, a full equivalence test is performed.
Note:
The behavior is undefined if p is not an AnimatedTransform nor derived from one.
See also:
Animation, Object, Transform

Reimplemented from Transform.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and is marked as invalid. Then it is validated and the Incarnation of the Animation is requested to continue validation down the tree hierarchy.
See also:
Incarnation

Reimplemented from Group.

virtual NVSG_API bool invalidateIncarnation ( ) [virtual]

Overwrite to invalidate the bounding sphere.

Returns:
true, if the incarnation was valid before, otherwise false.
Remarks:
If the incarnation was valid, the bounding sphere is invalidated.

Reimplemented from Node.

The documentation for this class was generated from the following file:
  • AnimatedTransform.h
Generated on Tue Jan 15 10:28:58 2008 for NVSGSDK by NVIDIA


Member List

AnimatedTransform Member List

This is the complete list of members for AnimatedTransform, including all inherited members.
activateClipPlane(unsigned int index) | Group |
addChild(NodeHandle *child, unsigned int position=~0) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addLightSource(LightSourceHandle *lsHdl) | Group |
AnimatedTransform() | AnimatedTransform |
AnimatedTransform(const AnimatedTransform &rhs) | AnimatedTransform |
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const | Transform | [protected, virtual]
calculateBoundingSphere() const | Transform | [protected, virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
deactivateClipPlane(unsigned int index) | Group |
decrementJointCount() | Transform | [protected]
determineAnimationContainment() const | AnimatedTransform | [inline, virtual]
determineCgFxContainment() const | Group | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineLightContainment() const | Group | [protected, virtual]
determineLODContainment() const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
determineVolumeNodeContainment() const | Group | [protected, virtual]
enterCS() const | Object | [inline, protected]
getAnimation() const | AnimatedTransform | [inline]
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getChild(unsigned int position) const | Group | [inline]
getChildPositions(NodeHandle *node, std::vector< unsigned int > &positions) const | Group |
getClipPlane(unsigned int index) const | Group | [inline]
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getLightSource(unsigned int index) const | Group | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfLightSources() const | Group | [inline]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getTrafo(void) const | AnimatedTransform | [inline, virtual]
getUserData() const | Object | [inline]
Group() | Group |
Group(const Node &rhs) | Group | [explicit]
Group(const Group &rhs) | Group |
hasChild(NodeHandle *node) const | Group | [inline]
hasLightSource(LightSourceHandle *lsHdl) const | Group | [inline]
incrementJointCount() | Transform | [protected]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCaches(NodeHandle *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | AnimatedTransform | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isClipPlaneActive(unsigned int index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | AnimatedTransform | [virtual]
isJoint() const | Transform | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const AnimatedTransform &rhs) | AnimatedTransform |
nvsg::Transform::operator=(const Transform &rhs) | Transform |
nvsg::Group::operator=(const Group &rhs) | Group |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
postAddChild(unsigned int position) | Group | [protected, virtual]
postRemoveChild(unsigned int position) | Group | [protected, virtual]
preAddChild(unsigned int position) | Group | [protected, virtual]
preRemoveChild(unsigned int position) | Group | [protected, virtual]
removeChild(NodeHandle *child) | Group |
removeChild(unsigned int position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeLightSource(unsigned int index) | Group |
replaceChild(NodeHandle *newChild, NodeHandle *oldChild) | Group |
replaceChild(NodeHandle *newChild, unsigned int position) | Group |
replaceLightSource(unsigned int index, LightSourceHandle *lsHdl) | Group |
replaceLightSource(LightSourceHandle *newHdl, LightSourceHandle *oldHdl) | Group |
setAnimation(TrafoAnimationHandle *animation) | AnimatedTransform |
setAnnotation(const std::string &anno) | Object |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setTrafo(const nvmath::Trafo &trafo) | AnimatedTransform | [inline, virtual]
setUserData(const void *userData) | Object | [inline]
Transform(void) | Transform |
Transform(const Group &rhs) | Transform |
Transform(const Transform &rhs) | Transform |
validateIncarnation() const | AnimatedTransform | [virtual]
~AnimatedTransform() | AnimatedTransform | [virtual]
~Group() | Group | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
~Transform(void) | Transform | [virtual]
Generated on Tue Jan 15 10:28:58 2008 for NVSGSDK by NVIDIA


AnimatedVertexAttributeSet Class Reference

Provides functionality to work with animated vertex attribute data. More...

#include <AnimatedVertexAttributeSet.h>

Inheritance diagram for AnimatedVertexAttributeSet:

[legend]
Collaboration diagram for AnimatedVertexAttributeSet:

[legend]
List of all members.

Public Member Functions

NVSG_API | AnimatedVertexAttributeSet ()
Default constructor.

NVSG_API | AnimatedVertexAttributeSet (const VertexAttributeSet &rhs)
Partial copy constructor.

NVSG_API | AnimatedVertexAttributeSet (const AnimatedVertexAttributeSet &rhs)
Copy constructor.

virtual NVSG_API | ~AnimatedVertexAttributeSet ()
Destructor.

NVSG_API AnimatedVertexAttributeSet & | operator= (const AnimatedVertexAttributeSet &rhs)
Assignment operator.

virtual NVSG_API bool | isCompatible (const VertexAttributeSet *p) const
Test for compatibility with an other VertexAttributeSet.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other AnimatedVertexAttributeSet.

virtual NVSG_API void | setVertexData (unsigned int attrib, unsigned int size, unsigned int type, const void *data, unsigned int count)
Overwrite of setVertexData in VertexAttributeSet.

virtual NVSG_API void | setVertexData (unsigned int attrib, unsigned int pos, unsigned int size, unsigned int type, const void *data, unsigned int count)
Overwrite of setVertexData in VertexAttributeSet.

virtual NVSG_API void | setVertexData (unsigned int attrib, const unsigned int *to, const unsigned int *from, unsigned int size, unsigned int type, const void *data, unsigned int count)
Overwrite of setVertexData in VertexAttributeSet.

virtual NVSG_API void | removeVertexData (unsigned int attrib)
Overwrite of removeVertexData in VertexAttributeSet.

virtual NVSG_API const void * | getVertexData (unsigned int attrib) const
Overwrite of getVertexData in VertexAttributeSet.

virtual NVSG_API unsigned int | getSizeOfVertexData (unsigned int attrib) const
Overwrite of getSizeOfVertexData in VertexAttribute.

virtual NVSG_API unsigned int | getTypeOfVertexData (unsigned int attrib) const
Overwrite of getSizeOfVertexData in VertexAttributeSet.

virtual NVSG_API unsigned int | getNumberOfVertexData (unsigned int attrib) const
Overwrite to getNumberOfVertexData in VertexAttributeSet.

virtual NVSG_API bool | validateIncarnation () const
Validate the incarnation.

NVSG_API VertexAttributeAnimationHandle * | getAnimation (unsigned int attrib) const
Get the animation of a specified VertexAttribute.

NVSG_API void | setAnimation (unsigned int attrib, VertexAttributeAnimationHandle *animation)
Set the animation of a specified VertexAttribute.

NVSG_API void | setNormalize (unsigned int attrib, bool normalize)
Set the normalize flag for a specified VertexAttribute.

NVSG_API bool | getNormalize (unsigned int attrib) const
Get the normalize flag for a specified VertexAttribute.

NVSG_API unsigned int | getNormalizeFlags () const
Get the normalize flags of all VertexAttributes as a bit mask.

virtual NVSG_API bool | containsAnimation () const
Determine if this AnimatedVertexAttributeSet contains any animation.

virtual NVSG_API bool | invalidateIncarnation ()
Overwrite to release cached data and invalidate the bounding sphere.

Detailed Description

Provides functionality to work with animated vertex attribute data.

Remarks:
An AnimatedVertexAttributeSet holds a set of pointers to VertexAttributeAnimationHandle, one for each animated vertex attribute. The values for a specified animation frame are copied into corresponding vertex attribute data of the base class. Vertex attributes without an animation are not changed there. That way, for example vertices and normals of a VertexAttributeSet can be animated while any texture coordinates are kept constant.
See also:
VertexAttributeData, VertexAttribute, Animation, FramedAnimation, InterpolatedAnimation

Constructor & Destructor Documentation

NVSG_API AnimatedVertexAttributeSet ( )

Default constructor.

Remarks:
Creates an empty AnimatedVertexAttributeSet, without any animations.

NVSG_API AnimatedVertexAttributeSet ( const VertexAttributeSet & rhs )

Partial copy constructor.

Parameters:
rhs VertexAttributeSet to copy from.
Remarks:
Creates an AnimatedVertexAttributeSet without any animations by copying the VertexAttributeSet-specific data from rhs.

NVSG_API AnimatedVertexAttributeSet ( const AnimatedVertexAttributeSet & rhs )

Copy constructor.

Parameters:
rhs AnimatedVertexAttributeSet to copy from.
Remarks:
Creates an AnimatedVertexAttributeSet by copying the data from rhs. Any animations in rhs are referenced in the resulting AnimatedVertexAttributeSet.

virtual NVSG_API ~AnimatedVertexAttributeSet ( ) [virtual]

Destructor.

Remarks:
Any Animation in that AnimatedVertexAttributeSet is dereferenced once.
See also:
Animation

Member Function Documentation

NVSG_API AnimatedVertexAttributeSet& operator= ( const AnimatedVertexAttributeSet & rhs )

Assignment operator.

Parameters:
rhs AnimatedVertexAttributeSet to assign.
Returns:
A reference to this.
Remarks:
Any animations in rhs are referenced once.
See also:
Animation

virtual NVSG_API bool isCompatible ( const VertexAttributeSet * p ) const [virtual]

Test for compatibility with an other VertexAttributeSet.

Parameters:
p A pointer to the other VertexAttributeSet.
Returns:
true, if this and p are compatible, otherwise false.
Remarks:
An AnimatedVertexAttributeSet is compatible with an other, if they are compatible as VertexAttributeSets, and the same VertexAttributes are animated with compatible Animations.

Reimplemented from VertexAttributeSet.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other AnimatedVertexAttributeSet.

Parameters:
p | A pointer to an Object to test for equivalence with.
ignoreNames | true, if names are to be ignored in the equivalence test, otherwise false.
deepCompare | true, if a deep compare should be done, otherwise false.
Returns:
true, if this and p are equivalent, otherwise false.
Remarks:
An Object p is considered to be equivalent to the AnimatedVertexAttributeSet this, if it also is an AnimatedVertexAttributeSet, is equivalent as a VertexAttributeSet, have the same normalize flags, and, if deepCompare is true, have animations on the same vertex attributes and those are pairwise equivalent, or, if deepCompare is false, have the exact same animations on the vertex attributes.
See also:
Animation, VertexAttribute

Reimplemented from VertexAttributeSet.

virtual NVSG_API void setVertexData | ( | unsigned int | attrib,
 |  | unsigned int | size,
 |  | unsigned int | type,
 |  | const void * | data,
 |  | unsigned int | count
 | ) | [virtual]

Overwrite of setVertexData in VertexAttributeSet.

Parameters:
attrib | Index to identify the vertex attribute. NVSG_POSITION, NVSG_NORMAL, NVSG_COLOR, NVSG_SECONDARY_COLOR, NVSG_FOG_COORD, NVSG_TEXCOORD0 - NVSG_TEXCOORD7, and NVSG_ATTR0 - NVSG_ATTR15 are allowed indices.
size | Specifies the number of coordinates per vertex; must be 1, 2, 3, or 4.
type | Specifies the data type of each coordinate in the input data array. In general, sympbolic constants NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted.
data | Specifies the start address of the input data array.
count | Specifies the number of vertex data to copy.
Remarks:
If there's an animation defined for the specified attribute, the data is also set into the current step of the animation.
See also:
VertexAttributeSet, removeVertexData

Reimplemented from VertexAttributeSet.

virtual NVSG_API void setVertexData | ( | unsigned int | attrib,
 |  | unsigned int | pos,
 |  | unsigned int | size,
 |  | unsigned int | type,
 |  | const void * | data,
 |  | unsigned int | count
 | ) | [virtual]

Overwrite of setVertexData in VertexAttributeSet.

Parameters:
attrib | Index to identify the vertex attribute. NVSG_POSITION, NVSG_NORMAL, NVSG_COLOR, NVSG_SECONDARY_COLOR, NVSG_FOG_COORD, NVSG_TEXCOORD0 - NVSG_TEXCOORD7, and NVSG_ATTR0 - NVSG_ATTR15 are allowed indices.
pos | Marks the position of the first vertex inside the already specified array of vertex data, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of vertex data.
size | Specifies the number of coordinates per vertex; must be 1, 2, 3, or 4.
type | Specifies the data type of each coordinate in the input data array. In general, sympbolic constants NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted.
data | Specifies the start address of the input data array.
count | Specifies the number of vertex data to copy.
Remarks:
If there's an animation defined for the specified attribute, the data is also set into the current step of the animation.
See also:
VertexAttributeSet, removeVertexData

Reimplemented from VertexAttributeSet.

virtual NVSG_API void setVertexData | ( | unsigned int | attrib,
 |  | const unsigned int * | to,
 |  | const unsigned int * | from,
 |  | unsigned int | size,
 |  | unsigned int | type,
 |  | const void * | data,
 |  | unsigned int | count
 | ) | [virtual]

Overwrite of setVertexData in VertexAttributeSet.

Parameters:
attrib | Index to identify the vertex attribute. NVSG_POSITION, NVSG_NORMAL, NVSG_COLOR, NVSG_SECONDARY_COLOR, NVSG_FOG_COORD, NVSG_TEXCOORD0 - NVSG_TEXCOORD7, and NVSG_ATTR0 - NVSG_ATTR15 are allowed indices.
to | Specifies the start address of the index array, that will be taken to reference the respective vertex data to be re-specified. If NULL is passed here, the input vertex data will be appended to the array of vertex data that previously was specified.
from | Specifies the start address of the index array, that will be taken to reference the input vertex data to overwrite the previously specified vertex data.
size | Specifies the number of coordinates per vertex; must be 1, 2, 3, or 4.
type | Specifies the data type of each coordinate in the input data array. In general, sympbolic constants NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted.
data | Specifies the start address of the input data array.
count | Specifies the number of vertex data to copy.
Remarks:
If there's an animation defined for the specified attribute, the data is also set into the current step of the animation.
See also:
VertexAttributeSet, removeVertexData

Reimplemented from VertexAttributeSet.

virtual NVSG_API void removeVertexData ( unsigned int attrib ) [virtual]

Overwrite of removeVertexData in VertexAttributeSet.

Parameters:
attrib Specifies the vertex attribute for which to remove previously copied vertex data.
Remarks:
If there's an animation defined for the specified attribute, the data of the current step is removed.
See also:
VertexAttributeSet, setVertexData

Reimplemented from VertexAttributeSet.

virtual NVSG_API const void* getVertexData ( unsigned int attrib ) const [virtual]

Overwrite of getVertexData in VertexAttributeSet.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns a type-less pointer to the vertex data that was assigned to the vertex attribute indicated by attrib prior to this call. If for this vertex attribute no vertex data was specified before, the function returns NULL.
Remarks:
If there's an animation defined for the specified attribute, the VertexAttribute data from the current animation step is returned.
See also:
getSizeOfVertexData, getTypeOfVertexData, getNumberOfVertexData

Reimplemented from VertexAttributeSet.

virtual NVSG_API unsigned int getSizeOfVertexData ( unsigned int attrib ) const [virtual]

Overwrite of getSizeOfVertexData in VertexAttribute.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns the number of coordinates per vertex stored for the indicated attribute. This number can be 1, 2, 3, or 4. If no vertex data was specified for this vertex attribute before, the function returns 0.
Remarks:
If there's an animation defined for the specified attribute, the size of the VertexAttribute data from the current animation step is returned.
See also:
getVertexData, getTypeOfVertexData, getNumberOfVertexData

Reimplemented from VertexAttributeSet.

virtual NVSG_API unsigned int getTypeOfVertexData ( unsigned int attrib ) const [virtual]

Overwrite of getSizeOfVertexData in VertexAttributeSet.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns a symbolic constant indicating the type of each coordinate in the vertex array stored for the specified vertex attribute. If no vertex data was specified for this vertex attribute before, the function returns NVSG_UNSUPPORTED_TYPE.
Remarks:
The function returns the per-coordinate type specifier that was used with a corresponding call to setVertexData. Use getSizeOfVertexData to query the number of coordinates for each vertex stored. You can use the nvsg::sizeOfType convenient function to determine the size in bytes of the type returned by this function.

If there's an animation defined for the specified attribute, the type of the VertexAttribute data from the current animation step is returned.

See also:
getVertexData, getSizeOfVertexData, getNumberOfVertexData

Reimplemented from VertexAttributeSet.

virtual NVSG_API unsigned int getNumberOfVertexData ( unsigned int attrib ) const [virtual]

Overwrite to getNumberOfVertexData in VertexAttributeSet.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns the number of data elements stored for the indicated vertex attribute.
Remarks:
If there's an animation defined for the specified attribute, the number of data elements of the VertexAttribute data from the current animation step is returned.
See also:
getVertexData, getSieOfVertexData, getTypeOfVertexData

Reimplemented from VertexAttributeSet.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the incarnation.

Returns:
true, if the incarnation was invalid, otherwise false.
Remarks:
This function is called from the framework when the Incarnation is requested. Then it is validated and if it was invalid, incarnation of each attached animation is validated.

Reimplemented from Object.

VertexAttributeAnimationHandle * getAnimation ( unsigned int attrib ) const [inline]

Get the animation of a specified VertexAttribute.

Parameters:
attrib The identifier of the VertexAttribute.
Returns:
A pointer to the VertexAttributeAnimationHandle attached to the VertexAttribute attrib, or NULL, if there is none.
See also:
Animation, VertexAttribute, setAnimation

NVSG_API void setAnimation | ( | unsigned int | attrib,
 |  | VertexAttributeAnimationHandle * | animation
 | ) |

Set the animation of a specified VertexAttribute.

Parameters:
attrib | The identifier of the VertexAttribute.
animation | A pointer to the VertexAttributeAnimationHandle to use.
Remarks:
If animation is not NULL, it's reference count is incremented. If there is an animation attached to the VertexAttribute specified by \ attrib, it's reference count is decremented. animation is stored as the animation of the VertexAttribute attrib, if the current frame is set, the corresponding values are copied from the new animation into the VertexAttribute, and the incarnation of this AnimatedVertexAttributeSet is invalidated.
See also:
getAnimation

NVSG_API void setNormalize | ( | unsigned int | attrib,
 |  | bool | normalize
 | ) |

Set the normalize flag for a specified VertexAttribute.

Parameters:
attrib | The identifier of the VertexAttribute.
normalize | true, if this VertexAttribute should be normalized, otherwise false.
Remarks:
Some animations perform some kind of interpolation between two or more key frame values. If the normalize flag is set for such a VertexAttribute, the resulting values are normalized. This is necessary for normals, for example.
See also:
getNormalize

bool getNormalize ( unsigned int attrib ) const [inline]

Get the normalize flag for a specified VertexAttribute.

Parameters:
attrib The identifier of the VertexAttribute.
Returns:
true, if the normalize flag for the VertexAttribute specified by attrib is set, otherwise false.
See also:
setNormalize

unsigned int getNormalizeFlags ( ) const [inline]

Get the normalize flags of all VertexAttributes as a bit mask.

Returns:
The normalize flags of all VertexAttributes as a bit mask.
See also:
getNormalize, setNormalize

virtual NVSG_API bool containsAnimation ( ) const [virtual]

Determine if this AnimatedVertexAttributeSet contains any animation.

Returns:
true, if at least one VertexAttribute is animated; otherwise false.

Reimplemented from VertexAttributeSet.

virtual NVSG_API bool invalidateIncarnation ( ) [virtual]

Overwrite to release cached data and invalidate the bounding sphere.

Returns:
true, if the incarnation was valid before, otherwise false.
Remarks:
If the incarnation was valid, any cached data is released, and the bounding sphere is also invalidated.

Reimplemented from OwnedObject< PrimitiveSetHandle >.

The documentation for this class was generated from the following file:
  • AnimatedVertexAttributeSet.h
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


Member List

AnimatedVertexAttributeSet Member List

This is the complete list of members for AnimatedVertexAttributeSet, including all inherited members.
addOwner(typename PrimitiveSetHandle::ObjectType *obj) | OwnedObject< PrimitiveSetHandle > | [protected]
AnimatedVertexAttributeSet() | AnimatedVertexAttributeSet |
AnimatedVertexAttributeSet(const VertexAttributeSet &rhs) | AnimatedVertexAttributeSet |
AnimatedVertexAttributeSet(const AnimatedVertexAttributeSet &rhs) | AnimatedVertexAttributeSet |
ConstOwnerIterator typedef | OwnedObject< PrimitiveSetHandle > | [protected]
containsAnimation() const | AnimatedVertexAttributeSet | [virtual]
enterCS() const | Object | [inline, protected]
generateTexCoords(VertexAttributeSet *vas, TextureCoordType tct, const nvmath::Sphere3f &sphere, unsigned int tu=0) | VertexAttributeSet | [related]
getAnimation(unsigned int attrib) const | AnimatedVertexAttributeSet | [inline]
getAnnotation() const | Object |
getColors() const | VertexAttributeSet | [inline]
getDataID(void) const | VertexAttributeSet | [virtual]
getFogCoords() const | VertexAttributeSet | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNormalize(unsigned int attrib) const | AnimatedVertexAttributeSet | [inline]
getNormalizeFlags() const | AnimatedVertexAttributeSet | [inline]
getNormals() const | VertexAttributeSet | [inline]
getNumberOfColors() const | VertexAttributeSet | [inline]
getNumberOfFogCoords() const | VertexAttributeSet | [inline]
getNumberOfNormals() const | VertexAttributeSet | [inline]
getNumberOfOwners() const | OwnedObject< PrimitiveSetHandle > |
getNumberOfSecondaryColors() const | VertexAttributeSet | [inline]
getNumberOfTexCoords(unsigned int unit) const | VertexAttributeSet | [inline]
getNumberOfVertexData(unsigned int attrib) const | AnimatedVertexAttributeSet | [virtual]
getNumberOfVertices() const | VertexAttributeSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< PrimitiveSetHandle > |
getSecondaryColors() const | VertexAttributeSet | [inline]
getSizeOfColors() const | VertexAttributeSet | [inline]
getSizeOfTexCoords(unsigned int unit) const | VertexAttributeSet | [inline]
getSizeOfVertexData(unsigned int attrib) const | AnimatedVertexAttributeSet | [virtual]
getTexCoords(unsigned int unit) const | VertexAttributeSet | [inline]
getTypeOfColors() const | VertexAttributeSet | [inline]
getTypeOfFogCoords() const | VertexAttributeSet | [inline]
getTypeOfSecondaryColors() const | VertexAttributeSet | [inline]
getTypeOfTexCoords(unsigned int unit) const | VertexAttributeSet | [inline]
getTypeOfVertexData(unsigned int attrib) const | AnimatedVertexAttributeSet | [virtual]
getUserData() const | Object | [inline]
getVertexData(unsigned int attrib) const | AnimatedVertexAttributeSet | [virtual]
getVertices() const | VertexAttributeSet | [inline]
invalidateBoundingVolumes() | VertexAttributeSet | [protected]
invalidateIncarnation() | AnimatedVertexAttributeSet | [virtual]
isCompatible(const VertexAttributeSet *p) const | AnimatedVertexAttributeSet | [virtual]
isDataShared(void) const | VertexAttributeSet | [virtual]
isEnabled(unsigned int attrib) const | VertexAttributeSet | [inline]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | AnimatedVertexAttributeSet | [virtual]
isNormalizeEnabled(unsigned int attrib) const | VertexAttributeSet | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
NVSG_ATTR0 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR1 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR10 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR11 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR12 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR13 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR14 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR15 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR2 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR3 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR4 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR5 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR6 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR7 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR8 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR9 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_COLOR enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_FOG_COORD enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_NORMAL enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_POSITION enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_SECONDARY_COLOR enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD0 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD1 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD2 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD3 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD4 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD5 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD6 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD7 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_UNUSED_1 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_UNUSED_2 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_VERTEX_ATTRIB_COUNT enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_VERTEX_WEIGHT enum value (defined in VertexAttributeSet) | VertexAttributeSet |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const AnimatedVertexAttributeSet &rhs) | AnimatedVertexAttributeSet |
nvsg::VertexAttributeSet::operator=(const VertexAttributeSet &rhs) | VertexAttributeSet |
nvsg::OwnedObject< PrimitiveSetHandle >::operator=(const OwnedObject< PrimitiveSetHandle > &rhs) | OwnedObject< PrimitiveSetHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< PrimitiveSetHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< PrimitiveSetHandle > | [protected]
OwnedObject(const OwnedObject< PrimitiveSetHandle > &rhs) | OwnedObject< PrimitiveSetHandle > | [protected]
OwnerIterator typedef | OwnedObject< PrimitiveSetHandle > | [protected]
ownersBegin() const | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersBegin() | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersEnd() const | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersEnd() | OwnedObject< PrimitiveSetHandle > | [inline, protected]
releaseCachedData() | VertexAttributeSet | [protected]
removeOwner(typename PrimitiveSetHandle::ObjectType *obj) | OwnedObject< PrimitiveSetHandle > | [protected]
removeVertexData(unsigned int attrib) | AnimatedVertexAttributeSet | [virtual]
setAnimation(unsigned int attrib, VertexAttributeAnimationHandle *animation) | AnimatedVertexAttributeSet |
setAnnotation(const std::string &anno) | Object |
setColors(const nvmath::Vecnt< N, T > *colors, unsigned int count) | VertexAttributeSet | [inline]
setColors(unsigned int pos, const nvmath::Vecnt< N, T > *colors, unsigned int count) | VertexAttributeSet | [inline]
setEnabled(unsigned int attrib, bool enable) | VertexAttributeSet | [inline]
setFogCoords(const T *coords, unsigned int count) | VertexAttributeSet | [inline]
setFogCoords(unsigned int pos, T *coords, unsigned int count) | VertexAttributeSet | [inline]
setName(const std::string &name) | Object |
setNormalize(unsigned int attrib, bool normalize) | AnimatedVertexAttributeSet |
setNormalizeEnabled(unsigned int attrib, bool enable) | VertexAttributeSet | [inline]
setNormals(const nvmath::Vec3f *normals, unsigned int count) | VertexAttributeSet | [inline]
setNormals(unsigned int pos, const nvmath::Vec3f *normals, unsigned int count) | VertexAttributeSet | [inline]
setSecondaryColors(const nvmath::Vecnt< 3, T > *colors, unsigned int count) | VertexAttributeSet | [inline]
setSecondaryColors(unsigned int pos, const nvmath::Vecnt< 3, T > *colors, unsigned int count) | VertexAttributeSet | [inline]
setTexCoords(unsigned int unit, const nvmath::Vecnt< N, T > *coords, unsigned int count) | VertexAttributeSet | [inline]
setTexCoords(unsigned int unit, unsigned int pos, const nvmath::Vecnt< N, T > *coords, unsigned int count) | VertexAttributeSet | [inline]
setUserData(const void *userData) | Object | [inline]
setVertexData(unsigned int attrib, unsigned int size, unsigned int type, const void *data, unsigned int count) | AnimatedVertexAttributeSet | [virtual]
setVertexData(unsigned int attrib, unsigned int pos, unsigned int size, unsigned int type, const void *data, unsigned int count) | AnimatedVertexAttributeSet | [virtual]
setVertexData(unsigned int attrib, const unsigned int *to, const unsigned int *from, unsigned int size, unsigned int type, const void *data, unsigned int count) | AnimatedVertexAttributeSet | [virtual]
setVertices(const nvmath::Vec3f *vertices, unsigned int count) | VertexAttributeSet | [inline]
setVertices(unsigned int pos, const nvmath::Vec3f *vertices, unsigned int count) | VertexAttributeSet | [inline]
swapVertexData(unsigned int attrib, VertexAttribute &rhs) | VertexAttributeSet | [virtual]
validateIncarnation() const | AnimatedVertexAttributeSet | [virtual]
VertexAttributeSet() | VertexAttributeSet |
VertexAttributeSet(const VertexAttributeSet &rhs) | VertexAttributeSet |
~AnimatedVertexAttributeSet() | AnimatedVertexAttributeSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< PrimitiveSetHandle > | [protected]
~VertexAttributeSet(void) | VertexAttributeSet | [virtual]
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


TemplateAnimation class Reference

Animation Class Template Reference

Class defining the common interface of an animation. More...

#include <Animation.h>

Inheritance diagram for Animation:

[legend]
List of all members.

Public Member Functions

virtual | ~Animation ()
Destructor of an Animation.

virtual const T & | getCurrentValue () const=0
Get the current value of this Animation.

virtual T | getStepValue (unsigned int step) const=0
Get the value of this Animation at the specified step.

virtual void | replaceStep (unsigned int step, const T &value)=0
Interface to replace a specified step with a given value.

T | getFrameValue (unsigned int frame) const
Get the value of this Animation at the specified frame.

virtual bool | isCompatible (const Animation< T > *p) const=0
Interface for testing for compatibility with an other Animation.

virtual bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other Animation.

Protected Member Functions

Animation (void)
Protected constructor to prevent explicit creation.

Animation< T > & | operator= (const Animation< T > &rhs)
Protected assignment operator.

Detailed Description

template<typename T>
class nvsg::Animation< T >

Class defining the common interface of an animation.

Namespace: nvsg
Remarks:
An Animation is a pure virtual template class derived from Object, and defines the common interface of an animation.
See also:
FramedAnimation, InterpolatedAnimation

Constructor & Destructor Documentation

~Animation ( ) [inline, virtual]

Destructor of an Animation.

See also:
addRef, removeRef

Animation ( void ) [inline, protected]

Protected constructor to prevent explicit creation.

Remarks:
Because Animation is an abstract class, its constructor is never used explicitly, but rather in the constructor of derived classes.
See also:
FramedAnimation, InterpolatedAnimation

Member Function Documentation

virtual const T& getCurrentValue ( ) const [pure virtual]

Get the current value of this Animation.

Returns:
The current value of this Animation.
Remarks:
The current value is used in the current animation step.
See also:
getCurrentStep

Implemented in FramedAnimation, KeyFramedAnimation, and LinearInterpolatedAnimation.

virtual T getStepValue ( unsigned int step ) const [pure virtual]

Get the value of this Animation at the specified step.

Parameters:
step The step index of the Animation to get the value at.
Returns:
The value of this Animation at the specified step.
See also:
getCurrentValue, getCurrentStep, getFrameValue

Implemented in FramedAnimation, KeyFramedAnimation, and LinearInterpolatedAnimation.

virtual void replaceStep | ( | unsigned int | step,
 |  | const T & | value
 | ) | [pure virtual]

Interface to replace a specified step with a given value.

Parameters:
step | The animation step to replace.
value | The value to use at the animation step step.
See also:
getStepValue, getFrameValue

Implemented in FramedAnimation, and KeyFramedAnimation.

T getFrameValue ( unsigned int frame ) const [inline]

Get the value of this Animation at the specified frame.

Parameters:
frame The frame index of the Animation to get the value at.
Returns:
The value of this Animation at the specified step.
See also:
getStepValue

virtual bool isCompatible ( const Animation< T > * p ) const [pure virtual]

Interface for testing for compatibility with an other Animation.

Parameters:
p A pointer to the other Animation.
Returns:
true if this and p are compatible, otherwise false.

Implemented in FramedAnimation, and KeyFramedAnimation.

bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [inline, virtual]

Test for equivalence with an other Animation.

Parameters:
p | A pointer to an Object to test for equivalence with.
ignoreNames | true, if names are to be ignored in the equivalence test, otherwise false.
deepCompare | true, if a deep compare should be done, otherwise false.
Returns:
true, if this and p are equivalent, otherwise false.
Remarks:
An Object p is considered to be equivalent to the Animation this, if it is also an Animation of type T, and it is equivalent to this as an Object.

Reimplemented in FramedAnimation, and KeyFramedAnimation.

Animation< T > & operator= ( const Animation< T > & rhs ) [inline, protected]

Protected assignment operator.

Parameters:
rhs Reference of the constant Animation to copy from
Returns:
A reference to the assigned Animation.
Remarks:
The assignment operator just calls the assignment operator of Object.
See also:
Object

The documentation for this class was generated from the following file:
  • Animation.h
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


Member List

Animation Member List

This is the complete list of members for Animation, including all inherited members.
Animation(void) | Animation | [inline, protected]
getCurrentValue() const=0 | Animation | [pure virtual]
getFrameValue(unsigned int frame) const | Animation | [inline]
getStepValue(unsigned int step) const=0 | Animation | [pure virtual]
isCompatible(const Animation< T > *p) const=0 | Animation | [pure virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Animation | [inline, virtual]
operator=(const Animation< T > &rhs) | Animation | [inline, protected]
replaceStep(unsigned int step, const T &value)=0 | Animation | [pure virtual]
~Animation() | Animation | [inline, virtual]
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


AnimationManipulator Class Reference

This Manipulator controls the camera animation. More...

#include <AnimationManipulator.h>

Inheritance diagram for AnimationManipulator:

[legend]
Collaboration diagram for AnimationManipulator:

[legend]
List of all members.

Public Member Functions

NVSG_API | AnimationManipulator ()
Default constructor.

virtual NVSG_API | ~AnimationManipulator ()
Default Destructor.

virtual NVSG_API bool | updateFrame ()
Apply changes for the next frame.

virtual NVSG_API bool | isActive ()
Give feedback of the activeness of the manipulator.

NVSG_API void | setCameraAnimation (nvsg::TrafoAnimationHandle *animation)
Set the camera animation.

NVSG_API void | nextFrame ()
Jump to the next animation frame.

NVSG_API void | previousFrame ()
Jump to the previous animation frame.

Protected Attributes

nvsg::TrafoAnimationHandle * m_cameraAnimation
Camera animation information.

unsigned int | m_currentTick
Wall clock tick.

int | m_delta
Steps to do on next/previous.

Detailed Description

This Manipulator controls the camera animation.

Namespace: nvui
Remarks:
This Manipulator is a special Manipulator that sets the animation data (frame number) in the current nvsg::ViewState and nvsg::Camera objects.
If you use this manipulator, your application must use a mechanism such as using OnIdle() that calls updateFrame(). If updateFrame() returns true, you should call triggerRedraw of the render area so the updated frame will be drawn. You will find some code samples in the description of the Manipulator class. Also, the SimpleViewer tutorial source code shows how to use a manipulator with MFC, the ConsoleViewer tutorial source code shows the details on how to use a manipulator, and the ManipSampleViewer tutorial source code shows how to derive a new Manipulator class.
See also:
Manipulator

Constructor & Destructor Documentation

NVSG_API AnimationManipulator ( )

Default constructor.

Remarks:
Initialize the AnimationManipulator object.

virtual NVSG_API ~AnimationManipulator ( ) [virtual]

Default Destructor.

Remarks:
The destructor cleans up the AnimationManipulator object and takes care of incrementing the reference count of the nvsg::Animation<nvmath::Trafo> object.

Member Function Documentation

virtual NVSG_API bool updateFrame ( ) [virtual]

Apply changes for the next frame.

Returns:
If there is a change regarding the last frame this function returns true.
Remarks:
This function updates the nvsg::Camera and the nvsg::ViewState regarding m_currentFrame. The application should call this function from your idle handler, for examle. If it returns with a positive result - true - the application should call RenderArea::triggerRedraw.
Example
This is a piece of code that demonstrates the usage with MFC. The AnimationManipulator needs a method to draw constantly. In MFC - OnIdle() it is enough to return TRUE. The application can also use a kind of animation thread to provide continuous redraw.
  m_pAnimManip->nextFrame();
  if (m_pAnimManip->updateFrame())
  {
    m_pRA->triggerRedraw();
  }
  return TRUE;  // Return TRUE, continues redraw - we are not done
                // we need to draw the next frame.
                // See the return values of OnIdle() in the MSDN documentation
See also the sample code in the Manipulator class description and the ManipSampleViewer, SimpleViewer and ConsoleViewer tutorial source code.
See also:
nextFrame, previousFrame RenderArea::triggerRedraw

Implements Manipulator.

virtual NVSG_API bool isActive ( ) [inline, virtual]

Give feedback of the activeness of the manipulator.

Returns:
This Manipulator returns false all the time.
Remarks:
The animation manipulator is not an interactive manipulator since there is no direct user interaction via an input device. So it is considered to be inactive all the time.

Implements Manipulator.

NVSG_API void setCameraAnimation ( nvsg::TrafoAnimationHandle * animation )

Set the camera animation.

Parameters:
animation Pointer to an Animation object. NULL is a valid value to reset the camera animation.
Remarks:
This function sets the current camera animation. If there is already a valid camera animation defined in this Manipulator the reference count of the old camera animation object will be decremented, and the reference count of the new camera animation object will be incremented.
One can use NULL to force the Manipulator to not use any camera animation.
See also:
nvsg::Animation

void nextFrame ( ) [inline]

Jump to the next animation frame.

Remarks:
Simply set the counter to the next frame in the row. If the last frame is reached and this function is called, the frame counter will be set back to the first frame of the animation. So the application can loop through the animation by simply calling nextFrame.
See also:
previousFrame

void previousFrame ( ) [inline]

Jump to the previous animation frame.

Remarks:
Simply set the counter to the previous frame in the row. If the first frame is reached and this function is called, the frame counter will be set back to the last frame of the animation. So the application can loop through the animation by simply calling previousFrame.
See also:
nextFrame

Member Data Documentation

nvsg::TrafoAnimationHandle* m_cameraAnimation [protected]

Camera animation information.

unsigned int m_currentTick [protected]

Wall clock tick.

int m_delta [protected]

Steps to do on next/previous.

The documentation for this class was generated from the following file:
  • AnimationManipulator.h
Generated on Tue Jan 15 10:29:40 2008 for NVSGSDK by NVIDIA


Member List

AnimationManipulator Member List

This is the complete list of members for AnimationManipulator, including all inherited members.
AnimationManipulator() | AnimationManipulator |
isActive() | AnimationManipulator | [inline, virtual]
m_cameraAnimation | AnimationManipulator | [protected]
m_currentTick | AnimationManipulator | [protected]
m_delta | AnimationManipulator | [protected]
m_renderArea | Manipulator | [protected]
Manipulator() | Manipulator |
nextFrame() | AnimationManipulator | [inline]
previousFrame() | AnimationManipulator | [inline]
setCameraAnimation(nvsg::TrafoAnimationHandle *animation) | AnimationManipulator |
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
updateFrame() | AnimationManipulator | [virtual]
~AnimationManipulator() | AnimationManipulator | [virtual]
~Manipulator() | Manipulator | [virtual]
Generated on Tue Jan 15 10:29:40 2008 for NVSGSDK by NVIDIA


AppTraverser Class Reference

AppTraverser Class. More...

#include <AppTraverser.h>

Inheritance diagram for AppTraverser:

[legend]
Collaboration diagram for AppTraverser:

[legend]
List of all members.

Public Types

enum SkinningProcessorType {
SKINNING_PROCESSOR_NONE, SKINNING_PROCESSOR_CPU, SKINNING_PROCESSOR_GPUG80GL, SKINNING_PROCESSOR_CUDA,
SKINNING_PROCESSOR_USER
}

Public Member Functions

NVSG_API | AppTraverser ()
Default constructor.

NVSG_API bool | isSkinningProcessorSupported (SkinningProcessorType type)
Check if a particular skinning processor is supported.

NVSG_API bool | setSkinningProcessor (SkinningProcessorType type)
Set the skinning processor, by type.

NVSG_API SkinningProcessor * | getSkinningProcessor ()
Get a pointer to the current skinning processor.

NVSG_API void | setSkinningProcessor (SkinningProcessor *a)
Set the skinning processor by pointer.

NVSG_API void | forceTraversal ()
Force traversal on the next frame.

Protected Member Functions

virtual NVSG_API | ~AppTraverser ()
Default destructor.

virtual NVSG_API bool | needsTraversal (nvsg::NodeHandle *root) const
Determines if the AppTraverser really should traverse the tree.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
doApply override

virtual NVSG_API void | handleAnimatedTransform (nvsg::AnimatedTransform *at)
Provide special treatment of an AnimatedTransform node.

virtual NVSG_API void | handleCgFx (nvsg::CgFx *cgfx)
Handler function for a CgFx.

virtual NVSG_API void | handleFramedIndexAnimation (nvsg::FramedAnimation< unsigned int > *anim)
Handler function for a FramedAnimation<unsigned int>.

virtual NVSG_API void | handleFramedTrafoAnimation (nvsg::FramedAnimation< nvmath::Trafo > *trafo)
Handler function for a FramedAnimation<nvmath::Trafo>.

virtual NVSG_API void | handleFramedVertexAttributeAnimation (nvsg::FramedAnimation< nvsg::VertexAttribute > *p)
Handler function for a FramedAnimation<VertexAttribute>.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *gnode)
Handler function for a GeoNode.

virtual NVSG_API void | handleLinearInterpolatedTrafoAnimation (nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo)
Handler function for a LinearInterpolatedAnimation<nvmath::Trafo>.

virtual NVSG_API void | handleLinearInterpolatedVertexAttributeAnimation (nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p)
Handler function for a LinearInterpolatedAnimation<VertexAttribute>.

virtual NVSG_API void | handleSkinnedTriangles (nvsg::SkinnedTriangles *triangles)
Handler function for a SkinnedTriangles.

virtual NVSG_API void | handleTransform (nvsg::Transform *p)
Provide special treatment of a Transform node.

virtual NVSG_API void | handleVolumeNode (nvsg::VolumeNode *vnode)
Handler function for a VolumeNode.

virtual NVSG_API bool | preTraverseTransform (const nvmath::Trafo *p)
Handle a Transform before traversing it.

virtual NVSG_API void | postTraverseTransform (const nvmath::Trafo *p)
Handle a Transform after traversing it.

virtual NVSG_API void | traversePrimitiveSet (nvsg::PrimitiveSet *pset)
Handle each PrimitiveSet on traversal.

Protected Attributes

bool | m_bApplyingCgFx
Flag that signals if a CgFX effect needs to be handled (tangentspace calculation).

unsigned int | m_animationFrame
Current animation frame.

Detailed Description

AppTraverser Class.

This class provides the mechanism to apply changes and update the scene graph. (The 'apply' step of the application.) Use an AppTraverser derived class as a unique entry point for manipulating nodes in the scene, such as data from gadgets, animations, and interactions.

Note:
The current implementation takes care of the animation frames, camera clip planes highlighting, etc...

Needs a valid ViewState. Call setViewState prior to apply().

Constructor & Destructor Documentation

NVSG_API AppTraverser ( )

Default constructor.

virtual NVSG_API ~AppTraverser ( ) [protected, virtual]

Default destructor.

Member Function Documentation

virtual NVSG_API bool needsTraversal ( nvsg::NodeHandle * root ) const [protected, virtual]

Determines if the AppTraverser really should traverse the tree.

Depending on some internal data, the traversal is recognized to be necessary. The AppTraverser needs to traverse if the ViewState, the Scene, or the animation frame changed.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

doApply override

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleAnimatedTransform ( nvsg::AnimatedTransform * at ) [protected, virtual]

Provide special treatment of an AnimatedTransform node.

An AnimatedTransform is handled as a Transform.

Reimplemented from ExclusiveModelViewTraverser.

virtual NVSG_API void handleCgFx ( nvsg::CgFx * cgfx ) [protected, virtual]

Handler function for a CgFx.

Parameters:
cgfx A pointer to the write-locked CgFx being traversed.
Remarks:
This function is called from the framework whenever a CgFx is encountered on traversal. The CgFx cgfx is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleFramedIndexAnimation ( nvsg::FramedAnimation< unsigned int > * anim ) [protected, virtual]

Handler function for a FramedAnimation<unsigned int>.

Parameters:
anim A pointer to the write-locked FramedAnimation<unsigned int> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<unsigned int> is encountered on traversal. The FramedAnimation<unsigned int> anim is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleFramedTrafoAnimation ( nvsg::FramedAnimation< nvmath::Trafo > * trafo ) [protected, virtual]

Handler function for a FramedAnimation<nvmath::Trafo>.

Parameters:
trafo A pointer to the write-locked FramedAnimation<nvmath::Trafo> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<nvmath::Trafo> is encountered on traversal. The FramedAnimation<nvmath::Trafo> trafo is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleFramedVertexAttributeAnimation ( nvsg::FramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Handler function for a FramedAnimation<VertexAttribute>.

Parameters:
p A pointer to the write-locked FramedAnimation<VertexAttribute> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<VertexAttribute> is encountered on traversal. The FramedAnimation<VertexAttribute> p is already write-locked.
The base implementation just does nothing
See also:
handleLinearInterpolatedVertexAttributeAnimation

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * gnode ) [protected, virtual]

Handler function for a GeoNode.

Parameters:
gnode A pointer to the write-locked GeoNode being traversed.
Remarks:
This function is called from the framework whenever a GeoNode is encountered on traversal. The GeoNode gnode is already write-locked.
The base implementation just calls Traverser::traverseGeoNode().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGeoNode

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLinearInterpolatedTrafoAnimation ( nvsg::LinearInterpolatedAnimation< nvmath::Trafo > * trafo ) [protected, virtual]

Handler function for a LinearInterpolatedAnimation<nvmath::Trafo>.

Parameters:
trafo A pointer to the write-locked LinearInterpolatedAnimation<nvmath::Trafo> being traversed.
Remarks:
This function is called from the framework whenever a LinearInterpolatedAnimation<nvmath::Trafo> is encountered on traversal. The LinearInterpolatedAnimation<nvmath::Trafo> trafo is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLinearInterpolatedVertexAttributeAnimation ( nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Handler function for a LinearInterpolatedAnimation<VertexAttribute>.

Parameters:
p A pointer to the write-locked LinearInterpolatedAnimation<VertexAttribute> being traversed.
Remarks:
This function is called from the framework whenever a LinearInterpolatedAnimation<VertexAttribute> is encountered on traversal. The LinearInterpolatedAnimation<VertexAttribute> p is already write-locked.
The base implementation just does nothing
See also:
handleFramedVertexAttributeAnimation

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleSkinnedTriangles ( nvsg::SkinnedTriangles * triangles ) [protected, virtual]

Handler function for a SkinnedTriangles.

Parameters:
triangles A pointer to the write-locked Triangles being traversed.
Remarks:
This function is called from the framework whenever a SkinnedTriangles is encountered on traversal. The SkinnedTriangles triangles is already write-locked.
The base implementation first traverses each TrafoAnimation of each bone of each skin, and then calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTransform ( nvsg::Transform * p ) [protected, virtual]

Provide special treatment of a Transform node.

On a Transform the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Reimplemented from ExclusiveModelViewTraverser.

virtual NVSG_API void handleVolumeNode ( nvsg::VolumeNode * vnode ) [protected, virtual]

Handler function for a VolumeNode.

Parameters:
vnode A pointer to the write-locked VolumeNode being traversed.
Remarks:
This function is called from the framework whenever a VolumeNode is encountered on traversal. The VolumeNode vnode is already write-locked.
The base implementation just calls Traverser::traverseVolumeNode().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseVolumeNode

Reimplemented from ExclusiveTraverser.

virtual NVSG_API bool preTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handle a Transform before traversing it.

The information on the current transform is stored, then ModelViewTraverser::preTraverseTransform() is called for further pre traversal processing.

Parameters:
p Trafo of node to handle pre-traversal

Reimplemented from ExclusiveModelViewTraverser.

virtual NVSG_API void postTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handle a Transform after traversing it.

After calling ModelViewTraverser::postTraverseTransform() for other post traversal processing on that Transform, transformation informations are restored from what was current before traversing that Transform.

Parameters:
p Trafo of node to handle post-traversal

Reimplemented from ExclusiveModelViewTraverser.

virtual NVSG_API void traversePrimitiveSet ( nvsg::PrimitiveSet * pset ) [protected, virtual]

Handle each PrimitiveSet on traversal.

Parameters:
pset A pointer to the write-locked PrimitiveSet currently traversed.
Remarks:
For each PrimitiveSet (like Triangles, Quads,...) this function is called. If pset holds a Skin and a SkinningProcessor is currently active, pset is added as a skinned PrimitiveSet to that SkinningProcessor for later usage.
See also:
SkinningProcessor

Reimplemented from ExclusiveTraverser.

NVSG_API bool isSkinningProcessorSupported ( SkinningProcessorType type )

Check if a particular skinning processor is supported.

Check current hardware to see if a particular skinning processor is supported.

Remarks:
Note that most "processors" require a current Rendering ctext for their detection routines to function correctly. Therefore, in order to check whether a particular skinning processor is supported, the application should retrieve the AppTraverser from the RenderArea, once the RenderArea has been created, and then call this routine on the skinning processor in question. This will ensure that an appropriate context is available.
See also:
RenderArea::getAppTraverser

NVSG_API bool setSkinningProcessor ( SkinningProcessorType type )

Set the skinning processor, by type.

Note:
Always deletes the old processor before setting a new one.
Returns:
true if processor was supported, false otherwise

NVSG_API SkinningProcessor* getSkinningProcessor ( )

Get a pointer to the current skinning processor.

NVSG_API void setSkinningProcessor ( SkinningProcessor * a )

Set the skinning processor by pointer.

This can be used to set custom skinning processors.

Parameters:
a The new skinning processor to use, or NULL. If the parameter is NULL, then no skinning processor will be used, and therefore skinning will not be performed.
Remarks:
The skinning processors are reference counted in this routine.

void forceTraversal ( ) [inline]

Force traversal on the next frame.

Remarks:
The AppTraverser tries to traverse the scene as seldom as possible. In some circumstances it might be necessary to force a traversal. That can be done with this function.
See also:
needsTraversal

Member Data Documentation

bool m_bApplyingCgFx [protected]

Flag that signals if a CgFX effect needs to be handled (tangentspace calculation).

unsigned int m_animationFrame [protected]

Current animation frame.

The documentation for this class was generated from the following file:
  • AppTraverser.h
Generated on Tue Jan 15 10:29:27 2008 for NVSGSDK by NVIDIA


Member List

AppTraverser Member List

This is the complete list of members for AppTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
AppTraverser() | AppTraverser |
doApply(nvsg::NodeHandle *root) | AppTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveModelViewTraverser() | ExclusiveModelViewTraverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
forceTraversal() | AppTraverser | [inline]
getSkinningProcessor() | AppTraverser |
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *at) | AppTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *p) | ExclusiveModelViewTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | AppTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | AppTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | AppTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | AppTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | AppTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | AppTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | AppTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveModelViewTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | AppTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *p) | AppTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | AppTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isSkinningProcessorSupported(SkinningProcessorType type) | AppTraverser |
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveModelViewTraverser | [protected, virtual]
m_animationFrame | AppTraverser | [protected]
m_bApplyingCgFx | AppTraverser | [protected]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedCamera | ExclusiveModelViewTraverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | ExclusiveModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
needsTraversal(nvsg::NodeHandle *root) const | AppTraverser | [protected, virtual]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | AppTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | AppTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setSkinningProcessor(SkinningProcessorType type) | AppTraverser |
setSkinningProcessor(SkinningProcessor *a) | AppTraverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SKINNING_PROCESSOR_CPU enum value (defined in AppTraverser) | AppTraverser |
SKINNING_PROCESSOR_CUDA enum value (defined in AppTraverser) | AppTraverser |
SKINNING_PROCESSOR_GPUG80GL enum value (defined in AppTraverser) | AppTraverser |
SKINNING_PROCESSOR_NONE enum value (defined in AppTraverser) | AppTraverser |
SKINNING_PROCESSOR_USER enum value (defined in AppTraverser) | AppTraverser |
SkinningProcessorType enum name (defined in AppTraverser) | AppTraverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | AppTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~AppTraverser() | AppTraverser | [protected, virtual]
~ExclusiveModelViewTraverser() | ExclusiveModelViewTraverser | [protected, virtual]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:27 2008 for NVSGSDK by NVIDIA


BalanceTraverser Class Reference

Balance a flat tree into a somewhat more balanced tree. More...

#include <BalanceTraverser.h>

Inheritance diagram for BalanceTraverser:

[legend]
Collaboration diagram for BalanceTraverser:

[legend]
List of all members.

Public Types

enum | { BT_CHILDREN = BIT0, BT_VERTICES = BIT1, BT_ALL_TARGETS_MASK = ( BT_CHILDREN | BT_VERTICES ) }

Public Member Functions

NVSG_API | BalanceTraverser (void)
Constructor.

NVSG_API unsigned int | getBalanceTargets () const
Get the bitmask describing the targets to balance.

NVSG_API void | setBalanceTargets (unsigned int mask)
Set the bitmask describing the targets to balance.

NVSG_API unsigned int | getMaximalNumberOfChildren () const
Get the maximal number of children allowed for a Group or Transform.

NVSG_API void | setMaximalNumberOfChildren (unsigned int mnoc)
Set the maximal number of children allowed for a Group or Transform.

NVSG_API unsigned int | getMaximalNumberOfVertices () const
Get the maximal number of vertices allowed for a PrimitiveSet.

NVSG_API void | setMaximalNumberOfVertices (unsigned int mnov)
Set the maximal number of vertices allowed for a PrimitiveSet.

Protected Member Functions

virtual NVSG_API | ~BalanceTraverser (void)
Protected destructor to prevent instantiation of an BalanceTraverser on stack.

virtual NVSG_API void | handleAnimatedTransform (nvsg::AnimatedTransform *p)
Balance all children beneath this AnimatedTransform.

virtual NVSG_API void | handleBillboard (nvsg::Billboard *p)
Balance all children beneath this Billboard.

virtual NVSG_API void | handleFlipbookAnimation (nvsg::FlipbookAnimation *p)
Balance all children beneath this FlipbookAnimation.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *p)
Balance all PrimitiveSets of this GeoNode.

virtual NVSG_API void | handleGroup (nvsg::Group *p)
Balance all children beneath this Group.

virtual NVSG_API void | handleLines (nvsg::Lines *p)
Balance this IndependentPrimitiveSet of type Lines.

virtual NVSG_API void | handleLineStrips (nvsg::LineStrips *p)
Balance this StrippedPrimitiveSet of type LineStrips.

virtual NVSG_API void | handleLOD (nvsg::LOD *p)
The children of an LOD are not balanced, but all it's levels are traversed for balancing.

virtual NVSG_API void | handlePoints (nvsg::Points *p)
Balance this IndependentPrimitiveSet of type Points.

virtual NVSG_API void | handleQuadMeshes (nvsg::QuadMeshes *p)
Balance this MeshedPrimitiveSet of type QuadMeshes.

virtual NVSG_API void | handleQuadStrips (nvsg::QuadStrips *p)
Balance this StrippedPrimitiveSet of type QuadStrips.

virtual NVSG_API void | handleQuads (nvsg::Quads *p)
Balance this IndependentPrimitiveSet of type Quads.

virtual NVSG_API void | handleSwitch (nvsg::Switch *p)
The children of a Switch are not balanced, but all it's children are traversed for balancing.

virtual NVSG_API void | handleTransform (nvsg::Transform *p)
Balance all children beneath this Transform.

virtual NVSG_API void | handleTriangles (nvsg::Triangles *p)
Balance this IndependentPrimitiveSet of type Triangles.

virtual NVSG_API void | handleTriFans (nvsg::TriFans *p)
Balance this StrippedPrimitiveSet of type TriFans.

virtual NVSG_API void | handleTriStrips (nvsg::TriStrips *p)
Balance this StrippedPrimitiveSet of type TriStrips.

Detailed Description

Balance a flat tree into a somewhat more balanced tree.

Remarks:
There are a number of different balancing operations available:
  • Balance by children: If a Group or Transform holds more than a specified number of children (default: 12), those children are sorted in some kind of octree, thus introducing additional Groups, holding the children of each octel. If such a new Group holds too many children on its own, this balancing is done recursively on that Group.
  • Balance by vertices: If a PrimitiveSet holds more than a specified number of vertices (default: 65536), the primitives of that PrimitiveSet are sorted in some type of octree, thus introducing additional PrimitiveSets, that replace the original one. If such a new PrimitiveSet holds too many vertices on its own, this balancing is done recursively on that PrimitiveSet.
See also:
ExclusiveModelViewTraverser

Member Enumeration Documentation

anonymous enum

Enumeration values:
BT_CHILDREN | BalanceTarget children: balance by the number of children.
BT_VERTICES | BalanceTarget vertices: balance by the number of vertices.

Constructor & Destructor Documentation

NVSG_API BalanceTraverser ( void )

Constructor.

virtual NVSG_API ~BalanceTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of an BalanceTraverser on stack.

Member Function Documentation

unsigned int getBalanceTargets ( ) const [inline]

Get the bitmask describing the targets to balance.

Returns:
A bitmask describing the targets to balance.

void setBalanceTargets ( unsigned int mask ) [inline]

Set the bitmask describing the targets to balance.

Parameters:
mask The bitmask describing the targets to balance.

unsigned int getMaximalNumberOfChildren ( ) const [inline]

Get the maximal number of children allowed for a Group or Transform.

Returns:
The maximal number of children allowed for a Group or Transform.

void setMaximalNumberOfChildren ( unsigned int mnoc ) [inline]

Set the maximal number of children allowed for a Group or Transform.

Parameters:
mnoc The maximal number of children allowed for a Group or Transform.

unsigned int getMaximalNumberOfVertices ( ) const [inline]

Get the maximal number of vertices allowed for a PrimitiveSet.

Returns:
The maximal number of vertices allowed for a PrimitiveSet.

void setMaximalNumberOfVertices ( unsigned int mnov ) [inline]

Set the maximal number of vertices allowed for a PrimitiveSet.

Returns:
mnov The maximal number of vertices allowed for a PrimitiveSet.

virtual NVSG_API void handleAnimatedTransform ( nvsg::AnimatedTransform * p ) [protected, virtual]

Balance all children beneath this AnimatedTransform.

Reimplemented from ExclusiveModelViewTraverser.

virtual NVSG_API void handleBillboard ( nvsg::Billboard * p ) [protected, virtual]

Balance all children beneath this Billboard.

Reimplemented from ExclusiveModelViewTraverser.

virtual NVSG_API void handleFlipbookAnimation ( nvsg::FlipbookAnimation * p ) [protected, virtual]

Balance all children beneath this FlipbookAnimation.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * p ) [protected, virtual]

Balance all PrimitiveSets of this GeoNode.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGroup ( nvsg::Group * p ) [protected, virtual]

Balance all children beneath this Group.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLines ( nvsg::Lines * p ) [protected, virtual]

Balance this IndependentPrimitiveSet of type Lines.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLineStrips ( nvsg::LineStrips * p ) [protected, virtual]

Balance this StrippedPrimitiveSet of type LineStrips.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLOD ( nvsg::LOD * p ) [protected, virtual]

The children of an LOD are not balanced, but all it's levels are traversed for balancing.

Reimplemented from ExclusiveModelViewTraverser.

virtual NVSG_API void handlePoints ( nvsg::Points * p ) [protected, virtual]

Balance this IndependentPrimitiveSet of type Points.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadMeshes ( nvsg::QuadMeshes * p ) [protected, virtual]

Balance this MeshedPrimitiveSet of type QuadMeshes.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadStrips ( nvsg::QuadStrips * p ) [protected, virtual]

Balance this StrippedPrimitiveSet of type QuadStrips.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuads ( nvsg::Quads * p ) [protected, virtual]

Balance this IndependentPrimitiveSet of type Quads.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleSwitch ( nvsg::Switch * p ) [protected, virtual]

The children of a Switch are not balanced, but all it's children are traversed for balancing.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTransform ( nvsg::Transform * p ) [protected, virtual]

Balance all children beneath this Transform.

Reimplemented from ExclusiveModelViewTraverser.

virtual NVSG_API void handleTriangles ( nvsg::Triangles * p ) [protected, virtual]

Balance this IndependentPrimitiveSet of type Triangles.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriFans ( nvsg::TriFans * p ) [protected, virtual]

Balance this StrippedPrimitiveSet of type TriFans.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriStrips ( nvsg::TriStrips * p ) [protected, virtual]

Balance this StrippedPrimitiveSet of type TriStrips.

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • BalanceTraverser.h
Generated on Tue Jan 15 10:29:27 2008 for NVSGSDK by NVIDIA


Member List

BalanceTraverser Member List

This is the complete list of members for BalanceTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
BalanceTraverser(void) | BalanceTraverser |
BT_ALL_TARGETS_MASK enum value (defined in BalanceTraverser) | BalanceTraverser |
BT_CHILDREN enum value | BalanceTraverser |
BT_VERTICES enum value | BalanceTraverser |
doApply(nvsg::NodeHandle *root) | ExclusiveTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveModelViewTraverser() | ExclusiveModelViewTraverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getBalanceTargets() const | BalanceTraverser | [inline]
getMaximalNumberOfChildren() const | BalanceTraverser | [inline]
getMaximalNumberOfVertices() const | BalanceTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *p) | BalanceTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *p) | BalanceTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *p) | BalanceTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *p) | BalanceTraverser | [protected, virtual]
handleGroup(nvsg::Group *p) | BalanceTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *p) | BalanceTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *p) | BalanceTraverser | [protected, virtual]
handleLOD(nvsg::LOD *p) | BalanceTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *p) | BalanceTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *p) | BalanceTraverser | [protected, virtual]
handleQuads(nvsg::Quads *p) | BalanceTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *p) | BalanceTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *p) | BalanceTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *p) | BalanceTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *p) | BalanceTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *p) | BalanceTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *p) | BalanceTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveModelViewTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedCamera | ExclusiveModelViewTraverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | ExclusiveModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | ExclusiveModelViewTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | ExclusiveModelViewTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setBalanceTargets(unsigned int mask) | BalanceTraverser | [inline]
setMaximalNumberOfChildren(unsigned int mnoc) | BalanceTraverser | [inline]
setMaximalNumberOfVertices(unsigned int mnov) | BalanceTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~BalanceTraverser(void) | BalanceTraverser | [protected, virtual]
~ExclusiveModelViewTraverser() | ExclusiveModelViewTraverser | [protected, virtual]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:27 2008 for NVSGSDK by NVIDIA


BaseRenderElement Class Reference

Helper class to serve as a base class for the render list elements, like RenderElement, LightsElement, or ClipPlanesElement. More...

#include <BaseRenderElement.h>

Inheritance diagram for BaseRenderElement:

[legend]
List of all members.

Public Member Functions

void | addRef ()
Increments the BaseRenderElement's reference count.

void | removeRef ()
Decrements the BaseRenderElement's reference count.

unsigned int | getRefCnt () const
Get the current reference count of a BaseRenderElement.

Protected Member Functions

BaseRenderElement ()
Protected default constructor to prevent explicit instantiation.

BaseRenderElement (const BaseRenderElement &rhs)
Protected copy constructor to prevent explicit instantiation.

virtual | ~BaseRenderElement ()
Destructor of a BaseRenderElement.

Detailed Description

Helper class to serve as a base class for the render list elements, like RenderElement, LightsElement, or ClipPlanesElement.

Remarks:
This class provides the reference counting for the render list elements.
See also:
ClipPlanesElement, HighlightElement, LightsElement, RenderElement, TransformElement

Constructor & Destructor Documentation

BaseRenderElement ( ) [inline, protected]

Protected default constructor to prevent explicit instantiation.

Remarks:
Initializes the reference count to zero.
Note:
A BaseRenderElement is intended to serve as a base class only. That is, a BaseRenderElement can be instantiated only as an object of a class derived from BaseRenderElement.

BaseRenderElement ( const BaseRenderElement & rhs ) [inline, protected]

Protected copy constructor to prevent explicit instantiation.

Remarks:
A new BaseRenderElement is created, and hence, the reference count will be initialized to zero because no one but the creator is currently referencing this object.
Note:
A BaseRenderElement is intended to serve as a base class only. That is, a BaseRenderElement can be instantiated only as an object of a class derived from BaseRenderElement.

~BaseRenderElement ( ) [inline, protected, virtual]

Destructor of a BaseRenderElement.

Remarks:
A BaseRenderElement will be automatically deleted when its reference count changes from one to zero.
See also:
removeRef

Member Function Documentation

void addRef ( ) [inline]

Increments the BaseRenderElement's reference count.

Remarks:
For user code to ensure that the data of a reference counted object is valid as long as it uses the object, it should first increment the objects reference count. After usage, client code should decrement the objects reference count to avoid resource leaks.
Note:
The reference count of a newly created BaseRenderElement initially is zero.
See also:
removeRef

void removeRef ( ) [inline]

Decrements the BaseRenderElement's reference count.

Remarks:
It is prohibited to explicitly delete a BaseRenderElement. The object will be automatically deleted, if the reference count changes from one to zero.
See also:
addRef

unsigned int getRefCnt ( ) const [inline]

Get the current reference count of a BaseRenderElement.

Returns:
The current reference count of the BaseRenderElement.
Remarks:
This function is available in the debug build only!

The documentation for this class was generated from the following file:
  • BaseRenderElement.h
Generated on Tue Jan 15 10:29:27 2008 for NVSGSDK by NVIDIA


Member List

BaseRenderElement Member List

This is the complete list of members for BaseRenderElement, including all inherited members.
addRef() | BaseRenderElement | [inline]
BaseRenderElement() | BaseRenderElement | [inline, protected]
BaseRenderElement(const BaseRenderElement &rhs) | BaseRenderElement | [inline, protected]
getRefCnt() const | BaseRenderElement | [inline]
removeRef() | BaseRenderElement | [inline]
~BaseRenderElement() | BaseRenderElement | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:27 2008 for NVSGSDK by NVIDIA


BellFilter Class Reference

ScaleFilter functor providing bell filter functionality. More...

#include <TextureImage.h>

Inheritance diagram for BellFilter:

[legend]
Collaboration diagram for BellFilter:

[legend]
List of all members.

Public Member Functions

NVSG_API float | getSupportWidth (void) const
Get the support width of the BellFilter.

NVSG_API float | operator() (float t) const
Weight calculation operator.

Detailed Description

ScaleFilter functor providing bell filter functionality.

A BellFilter has a support width of 1.5. For distances t between source and destination texel in the half open interval [0.0,0.5), the weight is ( 0.75 - t^2 ), if t is in the half open interval [0.5,1.5), the weight is ( 0.5 * ( 1.5 - t )^2 ), otherwise 0.0.

Member Function Documentation

float getSupportWidth ( void ) const [inline, virtual]

Get the support width of the BellFilter.

Returns:
the support width of the BellFilter is 1.5.

Implements ScaleFilter.

NVSG_API float operator() ( float t ) const [virtual]

Weight calculation operator.

Returns:
( 0.75 - t^2 ), if t is in the interval [0.0,0.5), ( 0.5 * ( 1.5 - t )^2 ) if t is in the interval [0.5,1.5), otherwise 0.0.

Implements ScaleFilter.

The documentation for this class was generated from the following file:
  • TextureImage.h
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Member List

BellFilter Member List

This is the complete list of members for BellFilter, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
getSupportWidth(void) const | BellFilter | [inline, virtual]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator()(float t) const | BellFilter | [virtual]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Billboard Class Reference

Class that adds billboard properties to a Group. More...

#include <Billboard.h>

Inheritance diagram for Billboard:

[legend]
Collaboration diagram for Billboard:

[legend]
List of all members.

Public Types

enum | Alignment { BA_AXIS, BA_VIEWER, BA_SCREEN }
Enumeration type to describe the alignment of a Billboard. More...

Public Member Functions

NVSG_API | Billboard ()
Default-constructs a Billboard.

NVSG_API | Billboard (const Group &rhs)
Constructs a Billboard from a Group.

NVSG_API | Billboard (const Billboard &rhs)
Copy-constructs a Billboard from another Billboard.

virtual NVSG_API | ~Billboard ()
Destructs a Billboard.

NVSG_API nvmath::Trafo | getTrafo (const Camera &cam, const nvmath::Mat44f &worldToModel) const
Get the current Trafo of the Billboard.

NVSG_API Alignment | getAlignment () const
Get the alignment type of the Billboard.

NVSG_API void | setAlignment (Alignment ba)
Set the Billboard alignment type.

NVSG_API const nvmath::Vec3f & | getRotationAxis () const
Get the rotation axis.

NVSG_API void | setRotationAxis (const nvmath::Vec3f &axis)
Set the rotation axis.

NVSG_API Billboard & | operator= (const Billboard &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another Billboard.

Detailed Description

Class that adds billboard properties to a Group.

Namespace: nvsg
Remarks:
The Billboard is a special transforming Group that performs a rotation either around and rotationAxis, or around the camera's upVector, such that the contents of the Group is either always oriented towards the viewer or screen aligned.
See also:
Group, Transform

Member Enumeration Documentation

enum Alignment

Enumeration type to describe the alignment of a Billboard.

Enumeration values:
BA_AXIS | Axis aligned Billboard: rotate around a specified axis.
BA_VIEWER | Viewer aligned Billboard: align the Billboard to always face the viewer.
BA_SCREEN | Screen aligned Billboard: keep the Billboard aligned to the screen.

Constructor & Destructor Documentation

NVSG_API Billboard ( )

Default-constructs a Billboard.

Remarks:
. The Billboard initially has the y-axis as rotation axis and is not screen aligned.

NVSG_API Billboard ( const Group & rhs ) [explicit]

Constructs a Billboard from a Group.

Parameters:
rhs Source Group.
Remarks:
. The Billboard initially has the y-axis as rotation axis and is not screen aligned.

NVSG_API Billboard ( const Billboard & rhs )

Copy-constructs a Billboard from another Billboard.

Parameters:
rhs Source Billboard.

virtual NVSG_API ~Billboard ( ) [virtual]

Destructs a Billboard.

Member Function Documentation

NVSG_API nvmath::Trafo getTrafo | ( | const Camera & | cam,
 |  | const nvmath::Mat44f & | worldToModel
 | ) | const

Get the current Trafo of the Billboard.

Parameters:
cam | Specifies the read-only Camera to use in aligning the Billboard.
worldToModel | Specifies the current mapping from world to model.
Returns:
An nvmath::Trafo, that represents the transformation of the Billboard.
Remarks:
Depending on the alignment of the Billboard, a different Trafo is determined.
See also:
getAlignment, setAlignment

Billboard::Alignment getAlignment ( ) const [inline]

Get the alignment type of the Billboard.

Returns:
The enumeration value describing the alignment type.
See also:
Billboard::Alignment, setAlignment

void setAlignment ( Alignment ba ) [inline]

Set the Billboard alignment type.

Parameters:
ba The enumeration value describing the alignment type.
See also:
Billboard::Alignment, getAlignment

const nvmath::Vec3f & getRotationAxis ( ) const [inline]

Get the rotation axis.

Returns:
A reference to the constant rotation axis.
Remarks:
The rotation axis specifies which axis to use to perform the rotation. This axis is defined in the local coordinates of the Billboard. The default is the local y-axis, that is (0.0,1.0,0.0). The rotation axis is used only if the Billboard is not to be screen aligned.
See also:
isViewerAligned, setRotationAxis

void setRotationAxis ( const nvmath::Vec3f & axis ) [inline]

Set the rotation axis.

Parameters:
axis A reference to the constant rotation axis.
Remarks:
The rotation axis specifies which axis to use to perform the rotation. This axis is defined in the local coordinates of the Billboard. The default is the local y-axis, that is (0.0,1.0,0.0). The rotation axis is used only if the Billboard is not to be screen aligned.
See also:
getRotationAxis, setViewerAligned

NVSG_API Billboard& operator= ( const Billboard & rhs )

Assignment operator.

Parameters:
rhs Reference to the constant Billboard to copy from
Returns:
A reference to the assigned Billboard
Remarks:
The assignment operator first calls the assignment operator of Group. Then the rotation axis and the screen alignment flag are copied.
See also:
Group

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another Billboard.

Parameters:
p | Pointer to the constant Billboard to test for equivalence with
ignoreNames | Optional parameter to ignore the names of the objects; default is true
deepCompare | Optional parameter to perform a deep comparison; default is false
Returns:
true if the Billboard p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as a group, they are equivalent if they are both screen aligned, or if they are not screen aligned but have the same rotation axis.
Note:
The behavior is undefined if p is not a Billboard nor derived from one.
See also:
Group, getRotationAxis, isViewerAligned

Reimplemented from Group.

The documentation for this class was generated from the following file:
  • Billboard.h
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


Member List

Billboard Member List

This is the complete list of members for Billboard, including all inherited members.
activateClipPlane(unsigned int index) | Group |
addChild(NodeHandle *child, unsigned int position=~0) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addLightSource(LightSourceHandle *lsHdl) | Group |
Alignment enum name | Billboard |
assertInvalidBoundingSphere() const | Node |
BA_AXIS enum value | Billboard |
BA_SCREEN enum value | Billboard |
BA_VIEWER enum value | Billboard |
Billboard() | Billboard |
Billboard(const Group &rhs) | Billboard | [explicit]
Billboard(const Billboard &rhs) | Billboard |
calculateBoundingBox() const | Group | [protected, virtual]
calculateBoundingSphere() const | Group | [protected, virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
deactivateClipPlane(unsigned int index) | Group |
determineAnimationContainment() const | Group | [protected, virtual]
determineCgFxContainment() const | Group | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineLightContainment() const | Group | [protected, virtual]
determineLODContainment() const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
determineVolumeNodeContainment() const | Group | [protected, virtual]
enterCS() const | Object | [inline, protected]
getAlignment() const | Billboard | [inline]
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getChild(unsigned int position) const | Group | [inline]
getChildPositions(NodeHandle *node, std::vector< unsigned int > &positions) const | Group |
getClipPlane(unsigned int index) const | Group | [inline]
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getLightSource(unsigned int index) const | Group | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfLightSources() const | Group | [inline]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getRotationAxis() const | Billboard | [inline]
getTrafo(const Camera &cam, const nvmath::Mat44f &worldToModel) const | Billboard |
getUserData() const | Object | [inline]
Group() | Group |
Group(const Node &rhs) | Group | [explicit]
Group(const Group &rhs) | Group |
hasChild(NodeHandle *node) const | Group | [inline]
hasLightSource(LightSourceHandle *lsHdl) const | Group | [inline]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCaches(NodeHandle *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isClipPlaneActive(unsigned int index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Billboard | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Billboard &rhs) | Billboard |
nvsg::Group::operator=(const Group &rhs) | Group |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
postAddChild(unsigned int position) | Group | [protected, virtual]
postRemoveChild(unsigned int position) | Group | [protected, virtual]
preAddChild(unsigned int position) | Group | [protected, virtual]
preRemoveChild(unsigned int position) | Group | [protected, virtual]
removeChild(NodeHandle *child) | Group |
removeChild(unsigned int position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeLightSource(unsigned int index) | Group |
replaceChild(NodeHandle *newChild, NodeHandle *oldChild) | Group |
replaceChild(NodeHandle *newChild, unsigned int position) | Group |
replaceLightSource(unsigned int index, LightSourceHandle *lsHdl) | Group |
replaceLightSource(LightSourceHandle *newHdl, LightSourceHandle *oldHdl) | Group |
setAlignment(Alignment ba) | Billboard | [inline]
setAnnotation(const std::string &anno) | Object |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setRotationAxis(const nvmath::Vec3f &axis) | Billboard | [inline]
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Group | [virtual]
~Billboard() | Billboard | [virtual]
~Group() | Group | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


TemplateBit class Reference

Bit Class Template Reference

Template class for easy definition of a single-bit bitmask. More...

#include <BitMask.h>

List of all members.

Public Types

enum { mask = 1<<n }

Detailed Description

template<int n>
class nvutil::Bit< n >

Template class for easy definition of a single-bit bitmask.

The documentation for this class was generated from the following file:
  • BitMask.h
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


Member List

Bit Member List

This is the complete list of members for Bit, including all inherited members.
mask enum value (defined in Bit) Bit
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


BlendAttribute Class Reference

StateAttribute that determines the blending modes to use. More...

#include <BlendAttribute.h>

Inheritance diagram for BlendAttribute:

[legend]
Collaboration diagram for BlendAttribute:

[legend]
List of all members.

Public Member Functions

NVSG_API | BlendAttribute ()
Default-constructs a BlendAttribute.

NVSG_API | BlendAttribute (const StateAttribute &rhs)
Constructs a BlendAttribute from a StateAttribute.

NVSG_API | BlendAttribute (const BlendAttribute &rhs)
Constructs a BlendAttribute as a copy from another BlendAttribute.

virtual NVSG_API | ~BlendAttribute ()
Destructs a BlendAttribute.

NVSG_API void | setBlendFunctions (BlendFunction sourceFunction, BlendFunction destinationFunction)
Set the blending functions for source and destination.

NVSG_API BlendFunction | getSourceFunction () const
Get the source blending function.

NVSG_API BlendFunction | getDestinationFunction () const
Get the destination blending function.

virtual NVSG_API bool | isTransparent () const
Query the transparency status of this BlendAttribute.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another BlendAttribute.

NVSG_API BlendAttribute & | operator= (const BlendAttribute &rhs)
Assignment operator.

Detailed Description

StateAttribute that determines the blending modes to use.

Namespace: nvsg
Remarks:
A BlendAttribute defines a nvsg::BlendFunction for both the source and the destination fragment. Blending can be completely controlled through use of a BlendAttribute.
Note:
A BlendAttribute takes precedence over both the blending of transparent geometries as well as the blending of antialiased lines and points.
See also:
BlendFunction, LineAttribute, PointAttribute, StateAttribute,

Constructor & Destructor Documentation

NVSG_API BlendAttribute ( )

Default-constructs a BlendAttribute.

Remarks:
A default-constructed BlendAttribute is initialized with BF_ONE as source function and BF_ZERO as destination function.

NVSG_API BlendAttribute ( const StateAttribute & rhs ) [explicit]

Constructs a BlendAttribute from a StateAttribute.

Parameters:
rhs StateAttribute to construct the BlendAttribute from.
Remarks:
A BlendAttribute constructed from a StateAttribute is initialized with BF_ONE as source function and BF_ZERO as destination function.

NVSG_API BlendAttribute ( const BlendAttribute & rhs )

Constructs a BlendAttribute as a copy from another BlendAttribute.

Parameters:
rhs Source BlendAttribute.

virtual NVSG_API ~BlendAttribute ( ) [virtual]

Destructs a BlendAttribute.

Member Function Documentation

NVSG_API void setBlendFunctions | ( | BlendFunction | sourceFunction,
 |  | BlendFunction | destinationFunction
 | ) |

Set the blending functions for source and destination.

Parameters:
sourceFunction | Blending function for the source
destinationFunction | Blending function for the destination
Remarks:
This function controls how color values in the fragment being processed (the source) are combined with those already stored in the framebuffer (the destination). The argument sourceFunction indicates how to compute a source blending function; the argument destinationFunction indicates how to compute a destination blending function.
See also:
BlendFunction

BlendFunction getSourceFunction ( ) const [inline]

Get the source blending function.

Returns:
nvsg::BlendFunction indicating the source blending function.
See also:
getDestinationFunction, setBlendFunctions

BlendFunction getDestinationFunction ( ) const [inline]

Get the destination blending function.

Returns:
nvsg::BlendFunction indicating the destination blending function.
See also:
getSourceFunction, setBlendFunctions

virtual NVSG_API bool isTransparent ( ) const [virtual]

Query the transparency status of this BlendAttribute.

Returns:
true, if the BlendAttribute is transparent, otherwise false.
Remarks:
A BlendAttribute is considered to be transparent if the destination function is not BF_ZERO or if the source function is one of the following: BF_DESTINATION_COLOR, BF_ONE_MINUS_DESTINATION_COLOR, BF_DESTINATION_ALPHA, BF_ONE_MINUS_DESTINATION_ALPHA, or BF_SOURCE_ALPHA_SATURATE.
See also:
StateAttribute::isTransparent

Reimplemented from StateAttribute.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another BlendAttribute.

Parameters:
p | Pointer to the constant BlendAttribute to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true
deepCompare | Optional parameter to perform a deep comparsion; default is false
Returns:
true if the BlendAttribute p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as StateAttribute, they are considered to be equivalent if they have the same nvsg::BlendFunction for the source and the destination.
Note:
The behaviour is undefined if p is not a BlendAttribute nor derived from one.
See also:
StateAttribute, getDestinationFunction, getSourceFunction

Reimplemented from Object.

NVSG_API BlendAttribute& operator= ( const BlendAttribute & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant BlendAttribute to copy from
Returns:
A reference to the assigned BlendAttribute
Remarks:
The assignment operator calls the assignment operator of StateAttribute and copies the BlendAttribute specific data then.
See also:
PrimitiveAttribute

The documentation for this class was generated from the following file:
  • BlendAttribute.h
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


Member List

BlendAttribute Member List

This is the complete list of members for BlendAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
BlendAttribute() | BlendAttribute |
BlendAttribute(const StateAttribute &rhs) | BlendAttribute | [explicit]
BlendAttribute(const BlendAttribute &rhs) | BlendAttribute |
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getDestinationFunction() const | BlendAttribute | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getSourceFunction() const | BlendAttribute | [inline]
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | BlendAttribute | [virtual]
isTransparent() const | BlendAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const BlendAttribute &rhs) | BlendAttribute |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setBlendFunctions(BlendFunction sourceFunction, BlendFunction destinationFunction) | BlendAttribute |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~BlendAttribute() | BlendAttribute | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


Bone Class Reference

An internal helper class for SkinnedTriangles. More...

#include <SkinnedTriangles.h>

Collaboration diagram for Bone:

[legend]
List of all members.

Public Member Functions

NVSG_API | Bone ()
Default constructor.

NVSG_API | Bone (const Bone &rhs)
Copy constructor.

NVSG_API | ~Bone ()
Destructor.

NVSG_API TrafoAnimationHandle * | getAnimation () const
Get the Animation of type nvmath::Trafo.

NVSG_API const nvmath::Mat44f & | getMatrix (unsigned int frame) const
Calculate the transformation of an animation frame.

NVSG_API float | getWeight () const
Get the weight of this Bone.

NVSG_API void | setAnimation (TrafoAnimationHandle *animation)
Set the Animation of type nvmath::Trafo.

NVSG_API void | setInverse (const nvmath::Mat44f &inverse)
Set the base inverse.

NVSG_API void | setMatrix (const nvmath::Mat44f &trafo)
Set the transformation to use.

NVSG_API void | setWeight (float weight)
Set the weight.

NVSG_API nvmath::Vec4f | operator() (unsigned int frame, const nvmath::Vec4f &v) const
Function call operator to calculate a vertex.

NVSG_API bool | operator== (const Bone &b) const
Equality operator.

NVSG_API Bone & | operator= (const Bone &rhs)
Assignment operator.

Detailed Description

An internal helper class for SkinnedTriangles.

Namespace: nvsg
Remarks:
Instead of the vertices and normals from Triangles, SkinnedTriangles use a special construction that has a vector of "Bones" per vertex, from which the vertices and normals are calculated. This calculation depends on the animation step. A Bone essentially consists of an Animation of type nvmath::Trafo, an offset, and a weight. Out of these values a vertex is calculated using a vector of Bones.
See also:
Animation, SkinnedTriangles

Constructor & Destructor Documentation

NVSG_API Bone ( )

Default constructor.

Remarks:
The default constructor creates an empty Bone.

NVSG_API Bone ( const Bone & rhs )

Copy constructor.

Parameters:
rhs A reference to the constant Bone to copy from.
Remarks:
The reference count of the animation of rhs is incremented. All the other data is just copied.
See also:
Animation

NVSG_API ~Bone ( )

Destructor.

Remarks:
The reference count of the animation is decremented.
See also:
Animation

Member Function Documentation

TrafoAnimationHandle * getAnimation ( ) const [inline]

Get the Animation of type nvmath::Trafo.

Returns:
A pointer to the constant Animation of type nvmath::Trafo of this Bone.
See also:
Animation, nvmath::Trafo

NVSG_API const nvmath::Mat44f& getMatrix ( unsigned int frame ) const

Calculate the transformation of an animation frame.

Parameters:
frame Index of the frame of the animation to get the transformation.
Returns:
A reference to the constant transformation as an nvmath::Trafo.
Note:
The behavior is undefined if frame is larger than or equal to the number of frames of the Animation of this Bone.
See also:
Animation, nvmath::Mat44f, nvmath::Trafo

float getWeight ( ) const [inline]

Get the weight of this Bone.

Returns:
The weight of this Bone.

NVSG_API void setAnimation ( TrafoAnimationHandle * animation )

Set the Animation of type nvmath::Trafo.

Parameters:
animation A pointer to the constant Animation of type nvmath::Trafo
Remarks:
The reference count of animation is increased, and the reference count of any previously bound Animation of type nvmath::Trafo is decreased.
See also:
Animation, nvmath::Trafo

void setInverse ( const nvmath::Mat44f & inverse ) [inline]

Set the base inverse.

Parameters:
inverse A reference to the constant base inverse transformation to set.
Remarks:
All animation steps are performed relative to this base inverse. Usually it is calculated out of the first animation step.
See also:
nvmath::Mat44f

void setMatrix ( const nvmath::Mat44f & trafo ) [inline]

Set the transformation to use.

Parameters:
trafo A reference to the constant transformation to use
Remarks:
Explicitly sets the transformation to use and invalidates the animation step.
See also:
nvmath::Trafo

void setWeight ( float weight ) [inline]

Set the weight.

Parameters:
weight The weight to use.
Remarks:
The weight is used for this Bones contribution to the vertex calculation. of a Skin.

NVSG_API nvmath::Vec4f operator() | ( | unsigned int | frame,
 |  | const nvmath::Vec4f & | v
 | ) | const

Function call operator to calculate a vertex.

Parameters:
frame | The animation step for the vertex to get.
v | A reference to the constant reference point.
Note:
The behavior is undefined if frame is larger than or equal to the number of frames of the Animation of this Bone.
Returns:
The modified point at the given frame.

bool operator== ( const Bone & b ) const [inline]

Equality operator.

Parameters:
b A reference to the constant Bone to compare with.
Returns:
true, if this and b are equal, otherwise false.
Remarks:
Two Bone objects are considered to be equal if they have the same base inverse, the same weight, and the same Animation of type nvmath::Trafo (not just two equivalent animations).
See also:
Animation, nvmath::Trafo

NVSG_API Bone& operator= ( const Bone & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant Bone to copy from.
Returns:
A reference to the assigned Bone.
Remarks:
The reference count of any previously bound Animation of type nvmath::Trafo is decremented, all the data from rhs is copied, and the reference count of the Animation of type nvmath::Trafo from rhs is incremented.
See also:
Animation, nvmath::Trafo

The documentation for this class was generated from the following file:
  • SkinnedTriangles.h
Generated on Tue Jan 15 10:29:16 2008 for NVSGSDK by NVIDIA


Member List

Bone Member List

This is the complete list of members for Bone, including all inherited members.
Bone() | Bone |
Bone(const Bone &rhs) | Bone |
getAnimation() const | Bone | [inline]
getMatrix(unsigned int frame) const | Bone |
getWeight() const | Bone | [inline]
operator()(unsigned int frame, const nvmath::Vec4f &v) const | Bone |
operator=(const Bone &rhs) | Bone |
operator==(const Bone &b) const | Bone | [inline]
setAnimation(TrafoAnimationHandle *animation) | Bone |
setInverse(const nvmath::Mat44f &inverse) | Bone | [inline]
setMatrix(const nvmath::Mat44f &trafo) | Bone | [inline]
setWeight(float weight) | Bone | [inline]
~Bone() | Bone |
Generated on Tue Jan 15 10:29:16 2008 for NVSGSDK by NVIDIA


bone_t Struct Reference

The bone_t structure specifies how a bone is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

float weight
uint_t animation

Detailed Description

The bone_t structure specifies how a bone is stored in a .NBF file.

Bones need to be considered in conjunction with the skin_t structure.

Member Data Documentation

float weight

Specifies a weight factor to be applied to the initial vertices and normals of the < actual skin.

uint_t animation

Specifies the file offset to the animation to be applied to the initial vertices < and normals of the actual skin.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Member List

bone_t Member List

This is the complete list of members for bone_t, including all inherited members.
animation | bone_t
weight | bone_t
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


BoxFilter Class Reference

ScaleFilter functor providing box filter functionality. More...

#include <TextureImage.h>

Inheritance diagram for BoxFilter:

[legend]
Collaboration diagram for BoxFilter:

[legend]
List of all members.

Public Member Functions

NVSG_API float | getSupportWidth (void) const
Get the support width of the BoxFilter.

NVSG_API float | operator() (float t) const
Weight calculation operator.

Detailed Description

ScaleFilter functor providing box filter functionality.

A BoxFilter has a support width of 0.5. For distances between source and destination texel of up to 0.5, the weight is 1.0, otherwise 0.0.

Member Function Documentation

float getSupportWidth ( void ) const [inline, virtual]

Get the support width of the BoxFilter.

Returns:
the support width of the BoxFilter is 0.5.

Implements ScaleFilter.

float operator() ( float t ) const [inline, virtual]

Weight calculation operator.

Returns:
1.0, if t is less than or equal to 0.5, otherwise 0.0.

Implements ScaleFilter.

The documentation for this class was generated from the following file:
  • TextureImage.h
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Member List

BoxFilter Member List

This is the complete list of members for BoxFilter, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
getSupportWidth(void) const | BoxFilter | [inline, virtual]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator()(float t) const | BoxFilter | [inline, virtual]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


TemplateBoxnt class Reference

Boxnt Class Template Reference

Represents an axis-aligned box. More...

#include <Boxnt.h>

Inheritance diagram for Boxnt:

[legend]
List of all members.

Public Member Functions

Boxnt ()
Default-constructs an axis-aligned box.

Boxnt (const Boxnt &rhs)
Copy-constructs an axis-aligned box.

Boxnt (const Vecnt< n, T > &p0, const Vecnt< n, T > &p1)
Constructs an axis-aligned box out of two points.

const Vecnt< n, T > & | getLower () const
Returns the lower edge of the box.

const Vecnt< n, T > & | getUpper () const
Returns the upper edge of the box.

void | update (const Vecnt< n, T > &point)
Updates the box by a specified point.

Detailed Description

template<unsigned int n, typename T>
class nvmath::Boxnt< n, T >

Represents an axis-aligned box.

Parameters:
n | Specifies the box dimension.
T | Specifies the coordinate type used to represent the box.
Remarks:
This class can be used to represent an axis-aligned minimum bounding box for a set of points in an n-dimensional space.

Constructor & Destructor Documentation

Boxnt ( ) [inline]

Default-constructs an axis-aligned box.

Remarks:
A default-constructed box initially is empty.

Boxnt ( const Boxnt< n, T > & rhs ) [inline]

Copy-constructs an axis-aligned box.

Parameters:
rhs Specifies the master copy.
Remarks:
After instantiation the box has the same extends as the master copy.

Boxnt | ( | const Vecnt< n, T > & | p0,
 |  | const Vecnt< n, T > & | p1
 | ) | [inline]

Constructs an axis-aligned box out of two points.

Parameters:
p0 | Specifies the first point to consider.
p1 | Specifies the second point to consider.

Member Function Documentation

const Vecnt< n, T > & getLower ( ) const [inline]

Returns the lower edge of the box.

Returns:
The lower edge of the axis-aligned box.

const Vecnt< n, T > & getUpper ( ) const [inline]

Returns the upper edge of the box.

Returns:
The upper edge of the axis-aligned box.

void update ( const Vecnt< n, T > & point ) [inline]

Updates the box by a specified point.

Parameters:
point The point by which to update the axis-aligned box.
Remarks:
The function calculates new axis-aligned lower and upper edges from the input point.

The documentation for this class was generated from the following file:
  • Boxnt.h
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


Member List

Boxnt Member List

This is the complete list of members for Boxnt, including all inherited members.
Boxnt() | Boxnt | [inline]
Boxnt(const Boxnt &rhs) | Boxnt | [inline]
Boxnt(const Vecnt< n, T > &p0, const Vecnt< n, T > &p1) | Boxnt | [inline]
getLower() const | Boxnt | [inline]
getUpper() const | Boxnt | [inline]
update(const Vecnt< n, T > &point) | Boxnt | [inline]
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


BSplineFilter Class Reference

ScaleFilter functor providing BSpline filter functionality. More...

#include <TextureImage.h>

Inheritance diagram for BSplineFilter:

[legend]
Collaboration diagram for BSplineFilter:

[legend]
List of all members.

Public Member Functions

NVSG_API float | getSupportWidth (void) const
Get the support width of the BSplineFilter.

NVSG_API float | operator() (float t) const
Weight calculation operator.

Detailed Description

ScaleFilter functor providing BSpline filter functionality.

A BSplineFilter has a support width of 2.0. For distances t between source and destination texel in the half open interval [0.0,1.0), the weight is ( 2.0/3.0 - t^2 + 0.5 * t^3 ), if t is in the half open interval [1.0,2.0), the weight is ( 1.0/6.0 * ( 2.0 - t )^3 ), otherwise 0.0.

Member Function Documentation

float getSupportWidth ( void ) const [inline, virtual]

Get the support width of the BSplineFilter.

Returns:
the support width of the BSplineFilter is 2.0.

Implements ScaleFilter.

NVSG_API float operator() ( float t ) const [virtual]

Weight calculation operator.

Returns:
( 2.0/3.0 - t^2 + 0.5 * t^3 ), if t is in the interval [0.0,1.0), ( 1.0/6.0 * ( 2.0 - t )^3 ) if t is in the interval [1.0,2.0), otherwise 0.0.

Implements ScaleFilter.

The documentation for this class was generated from the following file:
  • TextureImage.h
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Member List

BSplineFilter Member List

This is the complete list of members for BSplineFilter, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
getSupportWidth(void) const | BSplineFilter | [inline, virtual]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator()(float t) const | BSplineFilter | [virtual]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


CallbackServer Class Reference

CallBackServer for associating CallBacks with objects. More...

#include <CallBackServer.h>

List of all members.

Public Member Functions

NVSG_API | CallbackServer ()
Constructs a CallBackServer.

NVSG_API | ~CallbackServer ()
Destructs a CallBackServer.

NVSG_API void | addCallback (ObjectHandle *subjectHandle, ChangeCallback *cb)
Register an ObjectHandle and associated ChangeCallback with the.

NVSG_API void | removeCallback (ObjectHandle *subjectHandle, ChangeCallback *cb)
Un-register an ObjectHandle and associated ChangeCallback with the.

NVSG_API void | changed (ObjectHandle *subjectHandle, const void *userData=NULL) const
Trigger CallBacks on the ObjectHandle.

Detailed Description

CallBackServer for associating CallBacks with objects.

Namespace: nvsg
Remarks:
This class (in conjunction with the ChangeCallBack) provides an interface that allows the user to: -Trigger CallBacks on an Object and/or -Do Object-Object messaging (Subject-Observer pattern)

Constructor & Destructor Documentation

NVSG_API CallbackServer ( )

Constructs a CallBackServer.

NVSG_API ~CallbackServer ( )

Destructs a CallBackServer.

Member Function Documentation

NVSG_API void addCallback | ( | ObjectHandle * | subjectHandle,
 |  | ChangeCallback * | cb
 | ) |

Register an ObjectHandle and associated ChangeCallback with the.

Parameters:
subjectHandle | Handle to the subject Object
cb | Pointer to the CallBack of the Subject
See also:
CallbackServer::changed, CallbackServer::removeCallback
Remarks:
Behavior is undefined if either or both the parameters are NULL

NVSG_API void removeCallback | ( | ObjectHandle * | subjectHandle,
 |  | ChangeCallback * | cb
 | ) |

Un-register an ObjectHandle and associated ChangeCallback with the.

Parameters:
subjectHandle | Handle to the subject Object
cb | Pointer to the CallBack of the Subject
See also:
CallbackServer::changed, CallbackServer::addCallback
Remarks:
Behavior is undefined if either or both the parameters are NULL

NVSG_API void changed | ( | ObjectHandle * | subjectHandle,
 |  | const void * | userData = NULL
 | ) | const

Trigger CallBacks on the ObjectHandle.

Parameters:
subjectHandle | Handle to the subject Object
userData | Pointer to user defined data
See also:
CallbackServer::addCallback, CallbackServer::removeCallback
Remarks:
calling this function will trigger call the CallBack::changed method on all the CallBacks registered for the SubjectHandle in the CallBackServer

The documentation for this class was generated from the following file:
  • CallBackServer.h
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


Member List

CallbackServer Member List

This is the complete list of members for CallbackServer, including all inherited members.
addCallback(ObjectHandle *subjectHandle, ChangeCallback *cb) | CallbackServer
CallbackServer() | CallbackServer
changed(ObjectHandle *subjectHandle, const void *userData=NULL) const | CallbackServer
removeCallback(ObjectHandle *subjectHandle, ChangeCallback *cb) | CallbackServer
~CallbackServer() | CallbackServer
Generated on Tue Jan 15 10:28:59 2008 for NVSGSDK by NVIDIA


Camera Class Reference

Abstract base class for parallel and perspective cameras. More...

#include <Camera.h>

Inheritance diagram for Camera:

[legend]
Collaboration diagram for Camera:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~Camera (void)
Destructs a Camera.

NVSG_API const nvmath::Vec3f & | getPosition (void) const
Get the position of the Camera.

NVSG_API void | setPosition (const nvmath::Vec3f &pos)
Set the position of the Camera.

NVSG_API const nvmath::Quatf & | getOrientation (void) const
Get the orientation of the Camera.

NVSG_API void | setOrientation (const nvmath::Quatf &quat)
Set the orientation of the Camera by a Quaternion.

NVSG_API void | setOrientation (const nvmath::Vec3f &dir, const nvmath::Vec3f &up)
Set the orientation of the Camera by a view direction and an up vector.

NVSG_API nvmath::Vec3f | getDirection (void) const
Get the view direction.

NVSG_API void | setDirection (const nvmath::Vec3f &dir)
Set the viewing direction.

NVSG_API nvmath::Vec3f | getUpVector (void) const
Get the up vector of the Camera.

NVSG_API void | setUpVector (const nvmath::Vec3f &up)
Set the up vector of the Camera.

NVSG_API nvmath::Mat44f | getWorldToViewMatrix (void) const
Get the world-to-view transformation.

NVSG_API nvmath::Mat44f | getViewToWorldMatrix (void) const
Get the view-to-world transformation.

NVSG_API float | getNearDistance (void) const
Get the distance to the near clipping plane.

NVSG_API void | setNearDistance (float nd)
Set the distance to the near clipping plane.

NVSG_API float | getFocusDistance (void) const
Get the distance to the projection plane.

virtual NVSG_API void | setFocusDistance (float fd)
Set the distance to the projection plane.

NVSG_API float | getFarDistance (void) const
Get the distance to the far clipping plane.

NVSG_API void | setFarDistance (float fd)
Set the distance to the far clipping plane.

NVSG_API void | calcNearFarDistances (const nvmath::Sphere3f &sphere)
Calculate the distances to the near and far clipping planes.

NVSG_API bool | isAutoClipPlanes (void) const
Query if automatic clip plane adjustment is on.

NVSG_API void | setAutoClipPlanes (bool on)
Enable/Disable automatic clip plane adjustment.

virtual NVSG_API nvmath::Mat44f | getProjection (void) const=0
Interface for getting the projection matrix of this Camera.

virtual NVSG_API nvmath::Mat44f | getInverseProjection (void) const=0
Interface for getting the inverse projection matrix of this Camera.

NVSG_API const nvmath::Vec2f & | getWindowSize (void) const
Get the window size.

NVSG_API void | setWindowSize (const nvmath::Vec2f &size)
Set the window size.

NVSG_API float | getAspectRatio (void) const
Get the aspect ratio of the Camera window.

NVSG_API void | setAspectRatio (float ar, bool keepWidth=false)
Set the aspect ratio of the Camera window.

NVSG_API const nvmath::Vec2f & | getWindowOffset (void) const
Get the window offset.

NVSG_API void | setWindowOffset (const nvmath::Vec2f &offset)
Set the window offset.

NVSG_API void | getWindowRegion (nvmath::Vec2f &lowerLeft, nvmath::Vec2f &upperRight) const
Get the window region.

NVSG_API void | setWindowRegion (const nvmath::Vec2f &lowerLeft, const nvmath::Vec2f &upperRight)
Set the window region.

NVSG_API unsigned int | getNumberOfHeadLights (void) const
Get the number of headlights attached to this Camera.

NVSG_API LightSourceHandle * | getHeadLight (unsigned int index) const
Returns the camera's headlight at position index.

NVSG_API void | addHeadLight (LightSourceHandle *light)
Adds a LightSource as headlight to this Camera.

NVSG_API void | removeHeadLight (unsigned int index)
Remove a headlight from this Camera.

NVSG_API void | clearHeadLights (void)
Clear the list of headlights.

virtual NVSG_API void | getPickRay (int x, int y, int w, int h, nvmath::Vec3f &rayOrigin, nvmath::Vec3f &rayDir) const=0
Interface for getting a pick ray in world coordinates for a given screen point.

NVSG_API void | move (const nvmath::Vec3f &delta, bool cameraRelative=true)
Move the Camera.

NVSG_API void | orbit (const nvmath::Vec3f &axis, float targetDistance, float angle, bool cameraRelative=true)
Orbit the Camera.

NVSG_API void | rotate (const nvmath::Vec3f &axis, float angle, bool cameraRelative=true)
Rotate the Camera.

NVSG_API void | zoom (float factor)
Zoom by a positive factor.

NVSG_API void | zoom (const nvmath::Sphere3f &sphere, float fovy=-1.0f)
Zoom to fit view to a sphere.

void | moveX (float val)
Convenience function to move to the right or left in Camera space.

void | moveY (float val)
Convenience function to move up or down in Camera space.

void | moveZ (float val)
Convenience function to move backward or forward in Camera space.

void | orbitX (float targetDistance, float angle)
Convenience function to orbit around the x-axis of the Camera.

void | orbitY (float targetDistance, float angle)
Convenience function to orbit around the y-axis of the Camera.

void | orbitZ (float targetDistance, float angle)
Convenience function to orbit around the z-axis of the Camera.

void | rotateX (float angle)
Convenience function to rotate around the x-axis of the Camera.

void | rotateY (float angle)
Convenience function to rotate around the y-axis of the Camera.

void | rotateZ (float angle)
Convenience function to rotate around the z-axis of the Camera.

virtual NVSG_API CullCode | determineCullCode (const nvmath::Sphere3f &sphere) const=0
Interface for determining the CullCode of a Sphere3f relative to the view volume.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

Protected Member Functions

NVSG_API | Camera (void)
Protected constructor to prevent explicit creation.

NVSG_API | Camera (const Camera &rhs)
Protected copy constructor to prevent explicit creation.

NVSG_API Camera & | operator= (const Camera &rhs)
Protected assignment operator.

Detailed Description

Abstract base class for parallel and perspective cameras.

Namespace: nvsg
Remarks:
Besides defining the interface for a camera, a Camera provides some basic functionalities needed or used in all Camera classes.
A Camera has a focus, a near distance, and a far distance. These define planes that are orthogonal to the view direction. The near and far distance bind the volume seen by this Camera. The focus distance is somewhere in between the near and far distance. At that distance the window size is used, defining the sides of the viewing volume. For stereo vision, the focus distance determines the plane in focus.
A Camera holds zero or more LightSource objects as head lights that are positioned relative to the Camera position. These LightSource objects are not part of a Scene, but part of the Camera.
For deriving your own Camera, you have to overload the member functions clone(), getProjection(), getInverseProjection(), and getPickRay(). You can also overload setFocusDistance() and validateIncarnation().
See also:
Object, ParallelCamera, PerspectiveCamera

Constructor & Destructor Documentation

virtual NVSG_API ~Camera ( void ) [virtual]

Destructs a Camera.

NVSG_API Camera ( void ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
Because Camera is an abstract class, its constructor is never used explicitly, but in the constructor of derived classes.
See also:
ParallelCamera, PerspectiveCamera

NVSG_API Camera ( const Camera & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant Camera to copy from
Remarks:
Because Camera is an abstract class, its constructor is never used explicitly, but in the constructor of derived classes.
See also:
ParallelCamera, PerspectiveCamera

Member Function Documentation

const nvmath::Vec3f & getPosition ( void ) const [inline]

Get the position of the Camera.

Returns:
A reference to the constant position of the Camera
Remarks:
The position of the Camera is given in world coordinates. The default position of a Camera is at (0.0,0.0,1.0).
See also:
getDirection, getOrientation, getUpVector, setPosition

NVSG_API void setPosition ( const nvmath::Vec3f & pos )

Set the position of the Camera.

Parameters:
pos A reference to the constant position to set
Remarks:
The position of the Camera is given in world coordinates. The default position of a Camera is at (0.0,0.0,1.0). Setting the position increases the Incarnation of the Camera.
See also:
getPosition, setDirection, setOrientation, setUpVector

const nvmath::Quatf & getOrientation ( void ) const [inline]

Get the orientation of the Camera.

Returns:
A reference to the constant orientation of the Camera
Remarks:
The orientation quaternion describes the rotation of the Camera from its standard orientation. The standard orientation is the negative z-axis (0.0,0.0,-1.0) as the view direction and the y-axis (0.0,1.0,0.0) as the up vector.
See also:
getDirection, getUpVector, setOrientation

NVSG_API void setOrientation ( const nvmath::Quatf & quat )

Set the orientation of the Camera by a Quaternion.

Parameters:
quat A reference to the constant orientation of the Camera.
Remarks:
The orientation of the Camera is the rotation from the default to the desired view direction and up vector. The default view direction is the negative z-axis (0.0,0.0,-1.0), and the default up vector is the y-axis (0.0,1.0,0.0). Setting the orientation is a simple way to set the view direction and the up vector in a consistent way. Setting the orientation increases the Incarnation.
See also:
getOrientation, setDirection, setUpVector

NVSG_API void setOrientation | ( | const nvmath::Vec3f & | dir,
 |  | const nvmath::Vec3f & | up
 | ) |

Set the orientation of the Camera by a view direction and an up vector.

Parameters:
dir | A reference to the constant view direction to set
up | A reference to the constant up vector to set.
Remarks:
Sets the orientation of the Camera by simultaneously setting the view direction and the up vector. The direction and the up vector have to be normalized and orthogonal to each other. Setting the orientation increases the Incarnation.
See also:
getOrientation, setDirection, setUpVector

nvmath::Vec3f getDirection ( void ) const [inline]

Get the view direction.

Returns:
The view direction of the Camera
Remarks:
The view direction is the vector in world space that defines the direction to which the Camera looks. The default view direction is the negative z-axis (0.0,0.0,-1.0).
See also:
getOrientation, getPosition, getUpVector, setDirection

NVSG_API void setDirection ( const nvmath::Vec3f & dir )

Set the viewing direction.

Parameters:
dir A reference to the constant view direction to set
Remarks:
The view direction is the vector in world space that defines the direction to which the Camera looks. The default view direction is the negative z-axis (0.0,0.0,-1.0). Setting the view direction changes the orientation of the Camera and might also change the up vector. Setting the view direction also increases the Incarnation of the Camera.
See also:
getDirection, setOrientation, setPosition, setUpVector

nvmath::Vec3f getUpVector ( void ) const [inline]

Get the up vector of the Camera.

Returns:
The up vector of the Camera
Remarks:
The up vector is the vector in world space that defines the up direction of the Camera. The default up vector is the y-axis (0.0,1.0,0.0).
See also:
getDirection, getOrientation, getPosition, setUpVector

NVSG_API void setUpVector ( const nvmath::Vec3f & up )

Set the up vector of the Camera.

Parameters:
up A reference to the constant up vector to set
Remarks:
The up vector is the vector in world space that defines the up direction of the Camera. The default up vector is the y-axis (0.0,1.0,0.0). Setting the up vector changes the orientation of the Camera and might also change the view direction. Setting the up vector also increases the Incarnation of the Camera.
See also:
getUpVector, setDirection, setOrientation, setPosition

NVSG_API nvmath::Mat44f getWorldToViewMatrix ( void ) const

Get the world-to-view transformation.

Returns:
The world-to-view transformation
Remarks:
Based on the position and orientation of the Camera, the transformation as a nvmath::Mat44f is calculated.
See also:
getOrientation, getPosition, getViewToWorldMatrix

NVSG_API nvmath::Mat44f getViewToWorldMatrix ( void ) const

Get the view-to-world transformation.

Returns:
The view-to-world transformation.
Remarks:
Based on the position and orientation of the Camera, the transformation as a nvmath::Mat44f is calculated.
See also:
getOrientation, getPosition, getWorldToViewMatrix

float getNearDistance ( void ) const [inline]

Get the distance to the near clipping plane.

Returns:
The distance from the Camera to the near clipping plane
Remarks:
The distance to the near clipping plane determines the front plane of the view frustum of this Camera. All objects in front of this plane are clipped.
The near clipping distance has to be positive and less than the far clipping distance. The ratio of far-to-near gives the depth resolution of the Camera. Therefore, near should be as large as possible, while far should be as small as possible.
See also:
calcNearFarDistances, getFarDistance, setNearDistance

void setNearDistance ( float nd ) [inline]

Set the distance to the near clipping plane.

Parameters:
nd The distance from the Camera to the near clipping plane
Remarks:
The distance to the near clipping plane determines the front plane of the view frustum of this Camera. All objects in front of this plane are clipped.
The near clipping distance has to be positive and less than the far clipping distance. The ratio of far-to-near gives the depth resolution of the Camera. Therefore, near should be as large as possible, while far should be as small as possible.
See also:
calcNearFarDistances, getNearDistance, setFarDistance

float getFocusDistance ( void ) const [inline]

Get the distance to the projection plane.

Returns:
The distance from the Camera position to the projection plane.
Remarks:
The focus distance is the orthogonal distance between the Camera and the projection plane. The focus distance should be greater-than or equal-to the near distance and less-than or equal-to the far distance. The default focus distance is 1.0.
See also:
getFarDistance, getNearDistance, setFocusDistance

virtual NVSG_API void setFocusDistance ( float fd ) [virtual]

Set the distance to the projection plane.

Parameters:
fd Distance to the projection plane to set
Remarks:
The focus distance is the orthogonal distance between the Camera and the projection plane. The focus distance should be greater-than or equal-to the near distance and less-than or equal-to the far distance. The default focus distance is 1.0. Setting the focus distance increases the Incarnation of the Camera.
See also:
getFocusDistance, setNearDistance, setFarDistance

Reimplemented in PerspectiveCamera.

float getFarDistance ( void ) const [inline]

Get the distance to the far clipping plane.

Returns:
The distance from the Camera to the far clipping plane
Remarks:
The distance to the far clipping plane determines the back plane of the view frustum of this Camera. All objects behind this plane are clipped.
The far clipping distance has to be greater than the near clipping distance. The ratio of far-to-near gives the depth resolution of the Camera. Therefore, near should be as large as possible, while far should be as small as possible.
See also:
calcNearFarDistances, getNearDistance, setFarDistance

void setFarDistance ( float fd ) [inline]

Set the distance to the far clipping plane.

Parameters:
fd The distance from the Camera to the far clipping plane
Remarks:
The distance to the far clipping plane determines the back plane of the view frustum of this Camera. All objects in behind this plane are clipped.
The far clipping distance has to be greater than the near clipping distance. The ratio of far-to-near gives the depth resolution of the Camera. Therefore, near should be as large as possible, while far should be as small as possible.
See also:
calcNearFarDistances, getFarDistance, setNearDistance

NVSG_API void calcNearFarDistances ( const nvmath::Sphere3f & sphere )

Calculate the distances to the near and far clipping planes.

Parameters:
sphere A reference to the constant sphere, where the clipping planes are to be adjusted to.
Remarks:
Calculates the optimal near and far clipping distances to prevent clipping of the nvmath::Sphere3f sphere without changing the position or orientation of the Camera.
If the sphere is completely "behind" the Camera, nothing is changed. Otherwise, the near and far distances are adjusted. The far distance is adjusted to be at the far end of the sphere. If the sphere is partly "behind" the Camera, the near distance is set to be at the far distance divided by 16384. This gives an acceptable depth resolution, but might clip objects that are close to, and in front of, the Camera that would otherwise be visible. If the sphere is completely in front of the Camera, the near distance is adjusted to be at the near end of the sphere. Behavior is undefined if sphere is empty. This can be checked using nvmath::isEmpty
See also:
getFarDistance, getNearDistance, isAutoClipPlanes

bool isAutoClipPlanes ( void ) const [inline]

Query if automatic clip plane adjustment is on.

Returns:
true, if automatic clip plane adjustment is on, otherwise false.
Remarks:
When automatic clip plane adjustment is true, the framework lets the Camera calculate the clip planes to ensure the whole depth of the scene is visible. If the user has additional information about the scene that might help clipping, this should be turned off.
See also:
calcNearFarDistances, setAutoClipPlane

NVSG_API void setAutoClipPlanes ( bool on )

Enable/Disable automatic clip plane adjustment.

Parameters:
on true enables automatic clip plane adjustment, disables it.
Remarks:
When automatic clip plane adjustment is true, the framework lets the Camera calculate the clip planes to ensure the whole depth of the scene is visible. If the user has additional information about the scene that might help clipping, this should be turned off.
See also:
calcNearFarDistances, isAutoClipPlanes

virtual NVSG_API nvmath::Mat44f getProjection ( void ) const [pure virtual]

Interface for getting the projection matrix of this Camera.

Returns:
The projection transformation
See also:
getInverseProjection, getWorldToViewMatrix, getViewToWorldMatrix

Implemented in ParallelCamera, and PerspectiveCamera.

virtual NVSG_API nvmath::Mat44f getInverseProjection ( void ) const [pure virtual]

Interface for getting the inverse projection matrix of this Camera.

Returns:
The inverse projection transformation
See also:
getProjection, getWorldToViewMatrix, getViewToWorldMatrix

Implemented in ParallelCamera, and PerspectiveCamera.

const nvmath::Vec2f & getWindowSize ( void ) const [inline]

Get the window size.

Returns:
A constant reference to the size of the view window in world space
Remarks:
The window size is the size of the world window that is viewed by this Camera. The size is the size of the view frustum at focus distance from the Camera. It is symmetric about the view direction and it thus defines the aspect ratio of the world window, as well as, for a perspective Camera, the field of view. The default window size is (1.0,1.0).
See also:
setWindowSize

void setWindowSize ( const nvmath::Vec2f & size ) [inline]

Set the window size.

Parameters:
size A constant reference to the size of the view in world space.
Remarks:
The window size is the size of the world window that is viewed by this Camera. The size is the size of the view frustum at focus distance from the Camera. It is symmetric about the view direction and it thus defines the aspect ratio of the world window, as well as, for a perspective Camera, the field of view. The default window size is (1.0,1.0). Setting the window size increases the Incarnation of the Camera.
See also:
getWindowSize

float getAspectRatio ( void ) const [inline]

Get the aspect ratio of the Camera window.

Returns:
The aspect ratio of the Camera window
Remarks:
The aspect ratio is the width over the height of the Camera window.
See also:
getWindowSize, setAspectRatio

NVSG_API void setAspectRatio | ( | float | ar,
 |  | bool | keepWidth = false
 | ) |

Set the aspect ratio of the Camera window.

Parameters:
ar | Aspect ratio (width over height) of the Camera window.
keepWidth | Optional boolean that controls whether the width or the height of the Camera window is modified.
Remarks:
Setting the aspect ratio of the Camera window changes either the width or the height. With keepWidth equal to false (the default), the width is changed. With keepWidth equal to true, the height is changed. Setting the aspect ratio increases the Incarnation of the Camera.
See also:
getAspectRatio, setWindowSize

const nvmath::Vec2f & getWindowOffset ( void ) const [inline]

Get the window offset.

Returns:
A reference to the constant window offset.
Remarks:
The window offset is a value in world space that describes how to offset the view frustum for projection purposes. By default, the offset is (0.0,0.0). That is, the view frustum is symmetric about the view direction. Setting an offset, this view frustum is sheared a bit. This can be used, for example, in full scene antialiasing (FSAA) or stereo rendering.
In FSAA mode, several passes are drawn where the Camera is kept in place, but the window is slightly offset (jittered) each time. This way, a somewhat blurred image is achieved.
In stereo mode, two passes are drawn - once with the Camera shifted half the eye distance to the left, and once to the right. To adjust the view frustum accordingly, it is sheared a bit to the right and to the left, respectively.
See also:
setWindowOffset

void setWindowOffset ( const nvmath::Vec2f & offset ) [inline]

Set the window offset.

Parameters:
offset The window offset.
Remarks:
The window offset is a value in world space that describes how to offset the view frustum for projection purposes. By default, the offset is (0.0,0.0). That is, the view frustum is symmetric about the view direction. Setting an offset, this view frustum is sheared a bit. This can be used, for example, in full scene antialiasing (FSAA) or stereo rendering.
In FSAA mode, several passes are drawn where the Camera is kept in place, but the window is slightly offset (jittered) each time. This way, a somewhat blurred image is achieved.
In stereo mode, two passes are drawn - once with the Camera shifted half the eye distance to the left, and once to the right. To adjust the view frustum accordingly, it is sheared a bit to the right and to the left, respectively.
See also:
getWindowOffset

void getWindowRegion | ( | nvmath::Vec2f & | lowerLeft,
 |  | nvmath::Vec2f & | upperRight
 | ) | const [inline]

Get the window region.

Parameters:
lowerLeft | A reference to the relative position of the lower left of the window region
upperRight | A reference to the relative position of the upper right of the window region
Remarks:
The window region describes a relative part of the viewing window. Usually the view frustum of the Camera is symmetric about the view direction. To describe an asymmetric view frustum, you can use the window region.
The default for the window region is (0.0,0.0) for the lowerLeft, and (1.0,1.0) for the upperRight, thus using the whole view window. To only use the upper left quarter of the complete view frustum, for example, you could specify lowerLeft as (0.0,0.5) and upperRight as (0.5,1.0).
See also:
getWindowSize, setWindowRegion

void setWindowRegion | ( | const nvmath::Vec2f & | lowerLeft,
 |  | const nvmath::Vec2f & | upperRight
 | ) | [inline]

Set the window region.

Parameters:
lowerLeft | A reference to the constant relative position of the lower left of the window region to set
upperRight | A reference to the constant relative position of the upper right of the window region to set
Remarks:
The window region describes a relative part of the viewing window. Usually the view frustum of the Camera is symmetric about the view direction. To describe an asymmetric view frustum, you can use the window region.
The default for the window region is (0.0,0.0) for the lowerLeft, and (1.0,1.0) for the upperRight, thus using the whole view window. To only use the upper left quarter of the complete view frustum, for example, you could specify lowerLeft as (0.0,0.5) and upperRight as (0.5,1.0).
See also:
getWindowRegion, setWindowSize

unsigned int getNumberOfHeadLights ( void ) const [inline]

Get the number of headlights attached to this Camera.

Returns:
The number of headlights attached to this Camera
Remarks:
A Camera can have zero or more headlights that are LightSource objects positioned relative to the Camera position.
See also:
LightSource, getHeadLight

LightSourceHandle * getHeadLight ( unsigned int index ) const [inline]

Returns the camera's headlight at position index.

Parameters:
index Zero-based index of the headlight to get.
Returns:
A pointer to a LightSourceHandle specifying the headlight at position index.
Remarks:
A Camera can have zero or more headlights that are LightSource objects positioned relative to the Camera position.
Note:
The behavior is undefined if there are less than index LightSource objects attached.
See also:
LightSource, getNumberOfHeadLights, addHeadLight

NVSG_API void addHeadLight ( LightSourceHandle * light )

Adds a LightSource as headlight to this Camera.

Parameters:
light A pointer to a LightSourceHandle specifying the LightSource to add as headlight.
Remarks:
A Camera can have zero or more headlights that are LightSource objects positioned relative to the Camera position. The default position and orientation of a headlight is the Camera position and orientation. The LightSource is added at the last position in the list of headlights of this Camera, and its reference count is increased. Adding a headlight increases the Incarnation of the Camera.
See also:
LightSource, getNumberOfHeadLights, getHeadLight, removeHeadLight

NVSG_API void removeHeadLight ( unsigned int index )

Remove a headlight from this Camera.

Parameters:
index Index of headlight to remove.
Remarks:
A Camera can have zero or more headlights that are LightSource objects positioned relative to the Camera position. The LightSorce at position index in the list of headlights is removed, and its reference count is decreased. Removing a headlight increases the Incarnation of the Camera.
Note:
The behavior is undefined if there are less than index LightSource objects attached.
See also:
LightSource, getNumberOfHeadLights, addHeadLight

NVSG_API void clearHeadLights ( void )

Clear the list of headlights.

Remarks:
A Camera can have zero or more headlights that are LightSource objects positioned relative to the Camera position. The reference count of each LightSource in the list of headlights is decreased, and the list is cleared. Clearing the list of headlights increases the Incarnation of the Camera if there was at least one headlight in the list.
See also:
removeHeadeLight, getNumberOfHeadLights

virtual NVSG_API void getPickRay | ( | int | x,
 |  | int | y,
 |  | int | w,
 |  | int | h,
 |  | nvmath::Vec3f & | rayOrigin,
 |  | nvmath::Vec3f & | rayDir
 | ) | const [pure virtual]

Interface for getting a pick ray in world coordinates for a given screen point.

Parameters:
x | x-coordinate of the input screen point
y | y-coordinate of the input screen point
w | Width of the screen window in pixels
h | Height of the screen window in pixels
rayOrigin | Reference to an nvmath::Vec3f to get the ray origin
rayDir | Reference to an nvmath::Vec3f to get the ray direction
Remarks:
The function returns in rayOrigin the origin, and in rayDir the direction of the pick ray calculated from the screen point specified by its x and y coordinate.
Note:
A screen point of (0,0) indicates the lower left of the currently considered screen window.

Implemented in ParallelCamera, and PerspectiveCamera.

NVSG_API void move | ( | const nvmath::Vec3f & | delta,
 |  | bool | cameraRelative = true
 | ) |

Move the Camera.

Parameters:
delta | A reference to the constant delta to move
cameraRelative | Optional boolean controlling Camera relative or world relative movement. Default is Camera relative.
Remarks:
Moves the Camera by delta. If cameraRelative is true (the default), the Camera is moved the corresponding amounts along the local axes. Otherwise delta is just added to the position of the Camera (being in world space).
Moving the Camera increases the Incarnation.
See also:
moveX, moveY, moveZ, orbit, rotate, zoom,

NVSG_API void orbit | ( | const nvmath::Vec3f & | axis,
 |  | float | targetDistance,
 |  | float | angle,
 |  | bool | cameraRelative = true
 | ) |

Orbit the Camera.

Parameters:
axis | A reference to the normalized axis to orbit around in Camera relative coordinates.
targetDistance | Distance to target point to orbit around.
angle | Angle in radians to orbit.
cameraRelative | Optional boolean controlling Camera relative or world relative rotation. Default is Camera relative.
Remarks:
Orbiting a Camera performs a rotation by angle around the point at targetDistance along the view direction, using the axis of rotation. If cameraRelative is true (the default), axis is a vector in Camera local coordinates. This way, the Camera is moved on a great circle around the target point, modifying the view direction to keep that target point. If otherwise cameraRelative is false axis is in world coordinates.
Orbiting the Camera increases the Incarnation.
See also:
move, orbitX, orbitY, orbitZ, rotate,

NVSG_API void rotate | ( | const nvmath::Vec3f & | axis,
 |  | float | angle,
 |  | bool | cameraRelative = true
 | ) |

Rotate the Camera.

Parameters:
axis | A reference to the constant normalized axis to rotate around.
angle | Angle in radians to rotate
cameraRelative | Optional boolean controlling Camera relative or world relative rotation. Default is Camera relative.
Remarks:
Rotates the Camera around its position using axis of rotation by angle radians. If cameraRelative is true (the default), axis is a vector in Camera local coordinates. Otherwise axis is in world coordinates.
Rotating the Camera increases the Incarnation.
See also:
move, orbit, rotateX, rotateY, rotateZ

void zoom ( float factor ) [inline]

Zoom by a positive factor.

Parameters:
factor Factor to use in zooming
Remarks:
Zooming by a factor changes the window size of the Camera. The window size is the size of the world that is viewed at the projection plane. This plane is at a target distance along the view direction and orthogonal to the view direction.
When the factor is less than one, the window size is reduced, and thus the viewport shows less content in the same space. That is, it is zoomed in. When the factor is greater than one, it is zoomed out.
Zooming the Camera increases the Incarnation.
See also:
move, orbit, rotate, zoom

NVSG_API void zoom | ( | const nvmath::Sphere3f & | sphere,
 |  | float | fovy = -1.0f
 | ) |

Zoom to fit view to a sphere.

Parameters:
sphere | A reference to the constant sphere to zoom to.
fovy | Optional parameter describing the field of view. Default keeps the current field of view.
Remarks:
Zooming to a sphere moves the Camera to view the complete sphere. The direction is not changed, but the position and the window size are changed. If the automatic clip plane adjustment is on, the near and far distances are set accordingly.
Zooming the Camera increases the Incarnation. Behavior is undefined if sphere is empty. This can be checked using nvmath::isEmpty
See also:
setAutoClipPlanes, setPosition, setWindowSize

void moveX ( float val ) [inline]

Convenience function to move to the right or left in Camera space.

Parameters:
val Amount to move to the right or left
Remarks:
With positive val the Camera is moved to the right; with negative val it is moved to the left.
See also:
move

void moveY ( float val ) [inline]

Convenience function to move up or down in Camera space.

Parameters:
val Amount to move up or down
Remarks:
With positive val the Camera is moved up; with negative val it is moved down.
See also:
move

void moveZ ( float val ) [inline]

Convenience function to move backward or forward in Camera space.

Parameters:
val Amount to move backward or forward
Remarks:
With positive val the Camera is moved backward; with negative val it is moved to the forward.
See also:
move

void orbitX | ( | float | targetDistance,
 |  | float | angle
 | ) | [inline]

Convenience function to orbit around the x-axis of the Camera.

Parameters:
targetDistance | Distance to target point to orbit around.
angle | Angle in radians to orbit.
Remarks:
With positive angle the Camera moves down while looking up; with negative angle it moves up while looking down.
See also:
orbit

void orbitY | ( | float | targetDistance,
 |  | float | angle
 | ) | [inline]

Convenience function to orbit around the y-axis of the Camera.

Parameters:
targetDistance | Distance to target point to orbit around
angle | Angle in radians to orbit
Remarks:
With positive angle the Camera moves to the right while looking to the left; with negative angle the Camera moves to the left while looking to the right.
See also:
orbit

void orbitZ | ( | float | targetDistance,
 |  | float | angle
 | ) | [inline]

Convenience function to orbit around the z-axis of the Camera.

Parameters:
targetDistance | Distance to target point to orbit around
angle | Angle in radians to orbit
Remarks:
Orbiting around the z-axis of the Camera has the same effect as rotating around it (rolling). With positive angle it rolls to the left; with positive angle it rolls to the right.
See also:
orbit, rotateZ

void rotateX ( float angle ) [inline]

Convenience function to rotate around the x-axis of the Camera.

Parameters:
angle Angle in radians to rotate
Remarks:
The Rotation around the x-axis of the Camera is also called Pitch. With positive angle the Camera looks up; with negative angle it looks down.
See also:
rotate

void rotateY ( float angle ) [inline]

Convenience function to rotate around the y-axis of the Camera.

Parameters:
angle Angle in radians to rotate
Remarks:
The Rotation around the y-axis of the Camera is also called Yaw. With positive angle the Camera looks to the left; with negative angle it looks to the right.
See also:
rotate

void rotateZ ( float angle ) [inline]

Convenience function to rotate around the z-axis of the Camera.

Parameters:
angle Angle in radians to rotate
Remarks:
The Rotation around the y-axis of the Camera is also called Roll. With positive angle the Camera rolls to the left; with negative angle it rolls to the right.
See also:
orbitZ, rotate

virtual NVSG_API CullCode determineCullCode ( const nvmath::Sphere3f & sphere ) const [pure virtual]

Interface for determining the CullCode of a Sphere3f relative to the view volume.

Parameters:
sphere A reference to the constant Sphere3f to determine the CullCode for.
Returns:
CC_IN, if the Sphere3f sphere is completely inside the view volume; CC_OUT if it is completely out of the view volume; otherwise CC_PART.
Remarks:
Behavior is undefined if sphere is empty. This can be checked using nvmath::isEmpty()

Implemented in ParallelCamera, and PerspectiveCamera.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and marked as invalid. Then it is validated and the Incarnation of each headlight is requested to continue validation down the tree hierarchy. Incarnation, LightSource

Reimplemented from Object.

NVSG_API Camera& operator= ( const Camera & rhs ) [protected]

Protected assignment operator.

Parameters:
rhs Reference to the constant Camera to copy from
Returns:
A reference to the assigned Camera.
Remarks:
Besides assigning the Camera as an Object, each head light is copied as well as all Camera defining parameters.
See also:
LightSource, Object

The documentation for this class was generated from the following file:
  • Camera.h
Generated on Tue Jan 15 10:29:00 2008 for NVSGSDK by NVIDIA


Member List

Camera Member List

This is the complete list of members for Camera, including all inherited members.
addHeadLight(LightSourceHandle *light) | Camera |
calcNearFarDistances(const nvmath::Sphere3f &sphere) | Camera |
Camera(void) | Camera | [protected]
Camera(const Camera &rhs) | Camera | [protected]
clearHeadLights(void) | Camera |
determineCullCode(const nvmath::Sphere3f &sphere) const=0 | Camera | [pure virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getAspectRatio(void) const | Camera | [inline]
getDataID() const | Object | [virtual]
getDirection(void) const | Camera | [inline]
getFarDistance(void) const | Camera | [inline]
getFocusDistance(void) const | Camera | [inline]
getHeadLight(unsigned int index) const | Camera | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getInverseProjection(void) const=0 | Camera | [pure virtual]
getName() const | Object |
getNearDistance(void) const | Camera | [inline]
getNumberOfHeadLights(void) const | Camera | [inline]
getObjectCode() const | Object | [inline]
getOrientation(void) const | Camera | [inline]
getPickRay(int x, int y, int w, int h, nvmath::Vec3f &rayOrigin, nvmath::Vec3f &rayDir) const=0 | Camera | [pure virtual]
getPosition(void) const | Camera | [inline]
getProjection(void) const=0 | Camera | [pure virtual]
getUpVector(void) const | Camera | [inline]
getUserData() const | Object | [inline]
getViewToWorldMatrix(void) const | Camera |
getWindowOffset(void) const | Camera | [inline]
getWindowRegion(nvmath::Vec2f &lowerLeft, nvmath::Vec2f &upperRight) const | Camera | [inline]
getWindowSize(void) const | Camera | [inline]
getWorldToViewMatrix(void) const | Camera |
invalidateIncarnation() | Object | [virtual]
isAutoClipPlanes(void) const | Camera | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
move(const nvmath::Vec3f &delta, bool cameraRelative=true) | Camera |
moveX(float val) | Camera | [inline]
moveY(float val) | Camera | [inline]
moveZ(float val) | Camera | [inline]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Camera &rhs) | Camera | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
orbit(const nvmath::Vec3f &axis, float targetDistance, float angle, bool cameraRelative=true) | Camera |
orbitX(float targetDistance, float angle) | Camera | [inline]
orbitY(float targetDistance, float angle) | Camera | [inline]
orbitZ(float targetDistance, float angle) | Camera | [inline]
removeHeadLight(unsigned int index) | Camera |
rotate(const nvmath::Vec3f &axis, float angle, bool cameraRelative=true) | Camera |
rotateX(float angle) | Camera | [inline]
rotateY(float angle) | Camera | [inline]
rotateZ(float angle) | Camera | [inline]
setAnnotation(const std::string &anno) | Object |
setAspectRatio(float ar, bool keepWidth=false) | Camera |
setAutoClipPlanes(bool on) | Camera |
setDirection(const nvmath::Vec3f &dir) | Camera |
setFarDistance(float fd) | Camera | [inline]
setFocusDistance(float fd) | Camera | [virtual]
setName(const std::string &name) | Object |
setNearDistance(float nd) | Camera | [inline]
setOrientation(const nvmath::Quatf &quat) | Camera |
setOrientation(const nvmath::Vec3f &dir, const nvmath::Vec3f &up) | Camera |
setPosition(const nvmath::Vec3f &pos) | Camera |
setUpVector(const nvmath::Vec3f &up) | Camera |
setUserData(const void *userData) | Object | [inline]
setWindowOffset(const nvmath::Vec2f &offset) | Camera | [inline]
setWindowRegion(const nvmath::Vec2f &lowerLeft, const nvmath::Vec2f &upperRight) | Camera | [inline]
setWindowSize(const nvmath::Vec2f &size) | Camera | [inline]
validateIncarnation() const | Camera | [virtual]
zoom(float factor) | Camera | [inline]
zoom(const nvmath::Sphere3f &sphere, float fovy=-1.0f) | Camera |
~Camera(void) | Camera | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:00 2008 for NVSGSDK by NVIDIA


CgFx Class Reference

A StateAttribute to apply render effects that are compliant to the Cg 1.4 standard. More...

#include <CgFx.h>

Inheritance diagram for CgFx:

[legend]
Collaboration diagram for CgFx:

[legend]
List of all members.

Public Member Functions

NVSG_API | CgFx ()
Default-constructs a CgFx object.

NVSG_API | CgFx (const CgFx &rhs)
Constructs a CgFx object as a copy from another CgFx object.

virtual NVSG_API | ~CgFx ()
Destructs a CgFx object.

NVSG_API CgFx & | operator= (const CgFx &rhs)
Assigns contents from a source CgFx object.

virtual NVSG_API bool | isDataShared () const
Returns whether this object shares its embedded data with other CgFx objects.

virtual NVSG_API DataID | getDataID () const
Returns the unique data identifier for this object.

NVSG_API CgFxEffectHandle * | getEffect () const
Returns the embedded effect.

NVSG_API void | unloadPrograms ()
Unloads vertex and fragment programs of the embedded CgFxEffect.

virtual NVSG_API bool | isTransparent () const
Overrides StateAttribute::isTransparent.

virtual NVSG_API bool | isEquivalent (const Object *object, bool ignoreNames, bool deepCompare) const
Overrides Object::isEquivalent.

Static Public Member Functions

NVSG_API CgFxHandle * | createFromFile (const std::string &file, std::vector< std::string > &searchPaths, std::string &errorReturn, bool &failOnTextureLoadInOut)
Creates a CgFx Effect from a file, and performs all appropriate initialization, such as loading associated textures specified in the CgFx into the appropriate samplers.

NVSG_API CgFxHandle * | createFromLump (const std::string &lump, std::vector< std::string > &searchPaths, std::string &errorReturn, bool &failOnTextureLoadInOut)
Creates a CgFx Effect from a text string, and performs all appropriate initialization, such as loading associated textures specified in the CgFx into the appropriate samplers.

Detailed Description

A StateAttribute to apply render effects that are compliant to the Cg 1.4 standard.

Namespace: nvsg

Constructor & Destructor Documentation

NVSG_API CgFx ( )

Default-constructs a CgFx object.

NVSG_API CgFx ( const CgFx & rhs )

Constructs a CgFx object as a copy from another CgFx object.

virtual NVSG_API ~CgFx ( ) [virtual]

Destructs a CgFx object.

Member Function Documentation

NVSG_API CgFx& operator= ( const CgFx & rhs )

Assigns contents from a source CgFx object.

Parameters:
rhs Source CgFx object
Returns:
The assignment operator returns a reference to this CgFx object.
Remarks:
The assignment operator releases old contents before re-assigning the new contents.

virtual NVSG_API bool isDataShared ( ) const [virtual]

Returns whether this object shares its embedded data with other CgFx objects.

Returns:
The function returns true if the object shares its embedded data with another CgFx object. Otherwise, the function returns false.
Remarks:
This function is useful only if you need to deal with shared data.

A certain CgFx object shares its data with another CgFx object if it was either instantiated as a copy of the other object (CgFxHandle::clone), or if it was assigned to by the other object using the assignment operator .

If you need to write code that, for instance, saves a CgFx object to a file, you can use this function if you want your code to handle shared data. In this context, CgFx::getDataID would be also very helpful to identify the shared data.

Reimplemented from Object.

virtual NVSG_API DataID getDataID ( ) const [virtual]

Returns the unique data identifier for this object.

Returns:
The function returns a 64-bit value which uniquely identifies the embedded data.
Remarks:
This function helps to identify shared CgFx objects. Two CgFx objects that share their data do have the same data ID. Use CgFx::isDataShared to determine whether a certain CgFx object shares its data with other CgFx objects.
See also:
CgFxHandle::clone, CgFx::operator=()

Reimplemented from Object.

NVSG_API CgFxEffectHandle* getEffect ( ) const

Returns the embedded effect.

Returns:
The function returns a pointer to the embedded const CgFxEffect object.
Remarks:
The function lets you access the embedded effect, for instance, to initialize it or to exchange data with it.

If you need to write-access the embedded effect, for example, to exchange data with it, you first need to make it writable using the template class WritableObject<>. You should limit the scope of the write lock as shown in the example below.
Example:
   const CgFx * cgfx;
   [...]
   // assume a valid read-locked CgFx object here

   { // limit write access
     WritableObject<CgFxEffect> effect( cgfx->getEffect() );
     // write access the embedded effect
     [...]
   } // end of scope releases the writable effect

NVSG_API CgFxHandle* createFromFile | ( | const std::string & | file,
 |  | std::vector< std::string > & | searchPaths,
 |  | std::string & | errorReturn,
 |  | bool & | failOnTextureLoadInOut
 | ) | [static]

Creates a CgFx Effect from a file, and performs all appropriate initialization, such as loading associated textures specified in the CgFx into the appropriate samplers.

Returns:
The function returns the fully initialized CgFxHandle, or NULL if there was an error. If NULL is returned, check the text in "errorReturn" for the reason. failOnTextureLoad signifies whether creation of the CgFx should fail if one of the texture files specified in the CgFx file is not found. If failOnTextureLoad is true, and a texture is not found, createFromFile will return NULL, and errorReturn will contain text about which texture was not found. If failOnTextureLoad is false on the way into the method, then its value on the way out will indicate whether any textures were not found. In this case, errorReturn will also contain text indicating which textures were not found. In other words, errorReturn contains valid text if the method returns NULL or failOnTexLoad is true;
Remarks:
The function lets you load a complete cgfx, including textures. The CgFxEffect::createFromFile method will not load textures automatically.
Example:
   vector<string> searchPaths; // configure this to search paths
   string err;                 // will receive error in event of null return.
   bool failOnTexLoad = false; // don't fail if a texture was not found.
   CgFxHandle * cgfx = CgFx::createFromFile( "c:/hermannIsCool.cgfx", searchPaths, err, failOnTexLoad );
   [...]
   if( !cgfx )
   {
     printf("I guess hermann was not cool - error: %s\n", err.c_str() );
     return;
   }

   //
   // return value indicates whether textures were not found
   //
   if( failOnTexLoad )
   {
     printf("One or more textures were not found: %s\n", err.c_str() );
   }
See also:
CgFx, CgFxEffect::createFromFile

NVSG_API CgFxHandle* createFromLump | ( | const std::string & | lump,
 |  | std::vector< std::string > & | searchPaths,
 |  | std::string & | errorReturn,
 |  | bool & | failOnTextureLoadInOut
 | ) | [static]

Creates a CgFx Effect from a text string, and performs all appropriate initialization, such as loading associated textures specified in the CgFx into the appropriate samplers.

Returns:
The function returns the fully initialized CgFxHandle, or NULL if there was an error. If NULL is returned, check the text in "errorReturn" for the reason. failOnTextureLoad signifies whether creation of the CgFx should fail if one of the texture files specified in the CgFx file is not found. If failOnTextureLoad is true, and a texture is not found, createFromLump will return NULL, and errorReturn will contain text about which texture was not found. If failOnTextureLoad is false on the way into the method, then its value on the way out will indicate whether any textures were not found. In this case, errorReturn will also contain text indicating which textures were not found. In other words, errorReturn contains valid text if the method returns NULL or failOnTexLoad is true;
Remarks:
The function lets you load a complete cgfx, including textures. The CgFxEffect::createFromLump method will not load textures automatically.
Example:
   vector<string> searchPaths; // configure this to search paths
   string err;                 // will receive error in event of null return.
   bool failOnTexLoad = false; // don't fail if a texture was not found.
   CgFxHandle * cgfx = CgFx::createFromFile( "c:/hermannIsCool.cgfx", searchPaths, err, failOnTexLoad );
   [...]
   if( !cgfx )
   {
     printf("I guess hermann was not cool - error: %s\n", err.c_str() );
     return;
   }

   //
   // return value indicates whether textures were not found
   //
   if( failOnTexLoad )
   {
     printf("One or more textures were not found: %s\n", err.c_str() );
   }

NVSG_API void unloadPrograms ( )

Unloads vertex and fragment programs of the embedded CgFxEffect.

Remarks:
This function unloads all currently loaded vertex and fragment programs of the embedded effect. This will be necessary after the render context for which the programs were loaded has been destroyed and the geometry with this CgFx attribute applied is going to be rendered to a new created render context.

virtual NVSG_API bool isTransparent ( ) const [virtual]

Overrides StateAttribute::isTransparent.

Returns:
The function returns true if the associated effect forces the respective geometry to appear transparent. Otherwise, the function returns false.

Reimplemented from StateAttribute.

virtual NVSG_API bool isEquivalent | ( | const Object * | object,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Overrides Object::isEquivalent.

Parameters:
object | Pointer to the const Object to test for equivalence with this CgFx object.
ignoreNames | Object names will be ignored while testing if this is true.
deepCompare | The function performs a deep-compare instead of a shallow compare if this is true.
Returns:
The function returns true if the Object pointed to by object is detected to be equivalent to this CgFx object.
Remarks:
The test will consider the optional control parameters ignoreNames and deepCompare. If you omit these two, the function ignores the object names and performs a shallow compare only.
See also:
Object::isEquivalent

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • CgFx.h
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


Member List

CgFx Member List

This is the complete list of members for CgFx, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
CgFx() | CgFx |
CgFx(const CgFx &rhs) | CgFx |
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
createFromFile(const std::string &file, std::vector< std::string > &searchPaths, std::string &errorReturn, bool &failOnTextureLoadInOut) | CgFx | [static]
createFromLump(const std::string &lump, std::vector< std::string > &searchPaths, std::string &errorReturn, bool &failOnTextureLoadInOut) | CgFx | [static]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | CgFx | [virtual]
getEffect() const | CgFx |
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | CgFx | [virtual]
isEquivalent(const Object *object, bool ignoreNames, bool deepCompare) const | CgFx | [virtual]
isTransparent() const | CgFx | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const CgFx &rhs) | CgFx |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
unloadPrograms() | CgFx |
validateIncarnation() const | Object | [virtual]
~CgFx() | CgFx | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


CgFxContext Class Reference

CgFxContext wraps a CGcontext and maintains its state machine configuration. More...

#include <CgFx.h>

Collaboration diagram for CgFxContext:

[legend]
List of all members.

Public Types

enum | CgFxStateMachineEnum { CGFX_STATE_MACHINE_INVALID = 0, CGFX_STATE_MACHINE_GL }
CgFxStateMachineEnum enumeration type. More...

Public Member Functions

NVSG_API | CgFxContext (CgFxStateMachineEnum stateMachine=CGFX_STATE_MACHINE_INVALID)
Constructs a CgFxContext.

NVSG_API | ~CgFxContext ()
Destructs a CgFxContext.

NVSG_API void | lock ()
Exclusively locks the CgFxContext.

NVSG_API void | unlock ()
Releases an exclusive lock.

NVSG_API | operator CGcontext () const
Implicit converts a CgFxContext to a CGcontext where needed.

NVSG_API CgFxStateMachineEnum | getStateMachine () const
Returns the state machine for which the CgFxContext currently is configured.

NVSG_API bool | setStateMachine (CgFxStateMachineEnum stateMachine)
Re-configures the CgFxContext for the specified state machine.

Detailed Description

CgFxContext wraps a CGcontext and maintains its state machine configuration.

Namespace: nvsg
Remarks:
To apply a Cg effect to a certain geometry it requires the associated CGcontext to be properly configured using a state machine (OpenGL, D3D) to perform state management as the effect's technique passes get applied. A CgFxContext wraps a CGcontext and maintains its actual state machine configuration.

NVSG core maintains a global CgFxContext singleton object to share between all effects that are applied to geometry by means of a CgFx state attribute. The user can access this CgFxContext through nvsg::cgfxContext. Normally, the user only needs to access the shared CgFxContext to either query its current state machine configuration, or to re-configure the CgFxContext's state machine if required. For this two actions the CgFxContext provides the two APIs CgFxContext::getStateMachine, and CgFxContext::setStateMachine.

There is no need for the NVSG user to take care of CgFxContext creation or deletion. This entirely is handled by the NVSG core framework. Effects that are going to be applied to a certain geometry by means of a CgFx state attribute, automatically will share the global CgFxContext singleton object which is available after nvsg::nvsgInitialize returns.

Member Enumeration Documentation

enum CgFxStateMachineEnum

CgFxStateMachineEnum enumeration type.

Enumeration values:
CGFX_STATE_MACHINE_INVALID | Indicates an invalid state machine.
CGFX_STATE_MACHINE_GL | Indicates an OpenGL state machine.

Constructor & Destructor Documentation

NVSG_API CgFxContext ( CgFxStateMachineEnum stateMachine = CGFX_STATE_MACHINE_INVALID ) [explicit]

Constructs a CgFxContext.

Parameters:
stateMachine Indicates the state machine for which the wrapped CGcontext will be configured. This is an optional parameter. If omitted, the wrapped CGcontext will be configured for the OpenGL state machine.
Remarks:
This creates the wrapped CGcontext and default configures it for the OpenGL state machine. The default configuration can be changed by setStateMachine.

The NVSG core uses a global CgFxContext singleton object, which can be accessed through nvsg::cgfxContext. This CgFxContext by default will be shared between all effects in a Scene.

NVSG_API ~CgFxContext ( )

Destructs a CgFxContext.

Remarks:
The wrapped CGcontext will be destroyed.

Member Function Documentation

NVSG_API void lock ( ) [inline]

Exclusively locks the CgFxContext.

Remarks:
If different renderer access the same CgFxContext from different threads, these renderer need to ensure the CgFxContext's configuration remains unchanged while applying effects that belong to that CgFxContext. Otherwise, the runtime behaviour would be undefined.

Use unlock to release the CgFxContext after the effects have been applied.

Note that this function is a NOP, if the NVSG runtime is not configured to run in a multithreaded environment. You can configure the NVSG runtime to run in a multithreaded environment by passing NVSG_MULTITHREADED to the nvsg::nvsgInitialize entry point.

NVSG_API void unlock ( ) [inline]

Releases an exclusive lock.

Remarks:
This function is a NOP, if the NVSG runtime is not configured to run in a multithreaded environment. You can configure the NVSG runtime to run in a multithreaded environment by passing NVSG_MULTITHREADED to the nvsg::nvsgInitialize entry point.

NVSG_API operator CGcontext ( ) const [inline]

Implicit converts a CgFxContext to a CGcontext where needed.

Remarks:
This operator enables you to always pass a CgFxContext where a CGcontext is expected. The wrapped CGcontext then will be passed implicitly.

NVSG_API CgFxStateMachineEnum getStateMachine ( ) const [inline]

Returns the state machine for which the CgFxContext currently is configured.

Returns:
The function returns a CgFxStateMachineEnum indicating the state machine for which this CgFxContext currently is configured.
Remarks:
A CgFxContext can be configured for only one state machine at a time. A renderer that is going to apply an effect that belongs to this CgFxContext, needs to ensure that a suitable state machine is configured. If an unsuitable state machine is configured, the renderer needs to re-configure the CgFxContext for the right state machine prior to apply the effect. Use setStateMachine to re-configure the state machine.

NVSG_API bool setStateMachine ( CgFxStateMachineEnum stateMachine )

Re-configures the CgFxContext for the specified state machine.

Parameters:
stateMachine Specifies the state machine for which the CgFxContext should be re-configured.
Returns:
The function returns true if the CgFxContext successfully was re-configured for the specified state machine. Otherwise, the function returns false. The CgFxContext remains configured for the previous state machine in case of failure.
Remarks:
A CgFxContext can be configured for only one state machine at a time. A renderer that is going to apply an effect that belongs to this CgFxContext, needs to ensure that a suitable state machine is configured, and, if necessary, needs to re-configure the CgFxContext for the right state machine prior to apply the effect.

Use getStateMachine to check what state machine currently is used by the CgFxContext.

Note that re-configuring the CgFxContext for a different state machine requires a re-validation of the effect's current technique. Use CgFxEffect::validateCurrentTechnique to perform current technique validation.

The documentation for this class was generated from the following file:
  • CgFx.h
Generated on Tue Jan 15 10:29:00 2008 for NVSGSDK by NVIDIA


Member List

CgFxContext Member List

This is the complete list of members for CgFxContext, including all inherited members.
CGFX_STATE_MACHINE_GL enum value | CgFxContext |
CGFX_STATE_MACHINE_INVALID enum value | CgFxContext |
CgFxContext(CgFxStateMachineEnum stateMachine=CGFX_STATE_MACHINE_INVALID) | CgFxContext | [explicit]
CgFxStateMachineEnum enum name | CgFxContext |
getStateMachine() const | CgFxContext | [inline]
lock() | CgFxContext | [inline]
operator CGcontext() const | CgFxContext | [inline]
setStateMachine(CgFxStateMachineEnum stateMachine) | CgFxContext |
unlock() | CgFxContext | [inline]
~CgFxContext() | CgFxContext |
Generated on Tue Jan 15 10:29:00 2008 for NVSGSDK by NVIDIA


CgFxEffect Class Reference

Abstracts a render effect to be applied to a specific geometry. More...

#include <CgFx.h>

Collaboration diagram for CgFxEffect:

[legend]
List of all members.

Public Types

enum TransformType {
TRAFO_UNKNOWN = -1, TRAFO_WORLD = 0, TRAFO_MODEL = TRAFO_WORLD, TRAFO_VIEW,
TRAFO_PROJECTION, TRAFO_WORLDT, TRAFO_MODELT = TRAFO_WORLDT, TRAFO_WORLDTRANSPOSE = TRAFO_WORLDT,
TRAFO_MODELTRANSPOSE = TRAFO_WORLDT, TRAFO_VIEWT, TRAFO_VIEWTRANSPOSE = TRAFO_VIEWT, TRAFO_PROJECTIONT,
TRAFO_PROJECTIONTRANSPOSE = TRAFO_PROJECTIONT, TRAFO_WORLDI, TRAFO_MODELI = TRAFO_WORLDI, TRAFO_WORLDINVERSE = TRAFO_WORLDI,
TRAFO_MODELINVERSE = TRAFO_WORLDI, TRAFO_VIEWI, TRAFO_VIEWINVERSE = TRAFO_VIEWI, TRAFO_PROJECTIONI,
TRAFO_PROJECTIONINVERSE = TRAFO_PROJECTIONI, TRAFO_WORLDIT, TRAFO_MODELIT = TRAFO_WORLDIT, TRAFO_WORLDINVERSETRANSPOSE = TRAFO_WORLDIT,
TRAFO_MODELINVERSETRANSPOSE = TRAFO_WORLDIT, TRAFO_VIEWIT, TRAFO_VIEWINVERSETRANSPOSE = TRAFO_VIEWIT, TRAFO_PROJECTIONIT,
TRAFO_PROJECTIONINVERSETRANSPOSE = TRAFO_PROJECTIONIT, TRAFO_WORLDVIEW, TRAFO_MODELVIEW = TRAFO_WORLDVIEW, TRAFO_WORLDVIEWPROJECTION,
TRAFO_MODELVIEWPROJECTION = TRAFO_WORLDVIEWPROJECTION, TRAFO_WORLDVIEWT, TRAFO_MODELVIEWT = TRAFO_WORLDVIEWT, TRAFO_WORLDVIEWTRANSPOSE = TRAFO_WORLDVIEWT,
TRAFO_MODELVIEWTRANSPOSE = TRAFO_WORLDVIEWT, TRAFO_WORLDVIEWPROJECTIONT, TRAFO_MODELVIEWPROJECTIONT = TRAFO_WORLDVIEWPROJECTIONT, TRAFO_WORLDVIEWPROJECTIONTRANSPOSE = TRAFO_WORLDVIEWPROJECTIONT,
TRAFO_MODELVIEWPROJECTIONTRANSPOSE = TRAFO_WORLDVIEWPROJECTIONT, TRAFO_WORLDVIEWI, TRAFO_MODELVIEWI = TRAFO_WORLDVIEWI, TRAFO_WORLDVIEWINVERSE = TRAFO_WORLDVIEWI,
TRAFO_MODELVIEWINVERSE = TRAFO_WORLDVIEWI, TRAFO_WORLDVIEWPROJECTIONI, TRAFO_MODELVIEWPROJECTIONI = TRAFO_WORLDVIEWPROJECTIONI, TRAFO_WORLDVIEWPROJECTIONINVERSE = TRAFO_WORLDVIEWPROJECTIONI,
TRAFO_MODELVIEWPROJECTIONINVERSE = TRAFO_WORLDVIEWPROJECTIONI, TRAFO_WORLDVIEWIT, TRAFO_MODELVIEWIT = TRAFO_WORLDVIEWIT, TRAFO_WORLDVIEWINVERSETRANSPOSE = TRAFO_WORLDVIEWIT,
TRAFO_MODELVIEWINVERSETRANSPOSE = TRAFO_WORLDVIEWIT, TRAFO_WORLDVIEWPROJECTIONIT, TRAFO_MODELVIEWPROJECTIONIT = TRAFO_WORLDVIEWPROJECTIONIT, TRAFO_WORLDVIEWPROJECTIONINVERSETRANSPOSE = TRAFO_WORLDVIEWPROJECTIONIT,
TRAFO_MODELVIEWPROJECTIONINVERSETRANSPOSE = TRAFO_WORLDVIEWPROJECTIONIT
}
Enumeration type to identify specific transforms. More...

enum ProgramIOType {
PROGRAM_IO_VERTEX = CG_VERTEX, PROGRAM_IO_FRAGMENT = CG_FRAGMENT, PROGRAM_IO_POINT = CG_POINT, PROGRAM_IO_LINE = CG_LINE,
PROGRAM_IO_LINE_ADJ = CG_LINE_ADJ, PROGRAM_IO_TRIANGLE = CG_TRIANGLE, PROGRAM_IO_TRIANGLE_ADJ = CG_TRIANGLE_ADJ
}
Enumeration type to identify input or output of shaders. More...

Public Member Functions

CgFxEffect ()
Default-constructs a CgFxEffect.

CgFxEffect (const CgFxEffect &rhs)
Constructs a CgFxEffect as a copy from another CgFxEffect.

~CgFxEffect ()
Destructs a CgFxEffect.

NVSG_API bool | createFromFile (const std::string &file, std::string &err)
Creates a render effect from an input file.

NVSG_API bool | createFromLump (const std::string &lump, std::string &err)
Creates a render effect from a code string.

NVSG_API bool | isValid () const
Returns whether the effect is valid.

NVSG_API CGcontext | getContext () const
Returns the CGcontext associated with the effect.

NVSG_API bool | isFromFile () const
Returns whether the effect was created from a file.

NVSG_API bool | isFromLump () const
Returns whether the effect was created from a lump of CgFX source code.

NVSG_API bool | getFileName (std::string &file) const
Returns the file name of the CgFX source file from which the effect was created.

NVSG_API bool | getSourceCode (std::string &code) const
Returns CgFX source string from which the effect was created.

NVSG_API unsigned int | getNumberOfParameterAnnotations (CgFxParameter param) const
Returns the number of annotations available for a specified parameter.

NVSG_API CgFxAnnotation | getParameterAnnotation (CgFxParameter param, unsigned int index) const
Returns the parameter annotation at the specified zero-based index.

NVSG_API CgFxAnnotation | getParameterAnnotationByName (CgFxParameter param, const std::string &name) const
Returns an annotation of the specified parameter by name.

NVSG_API unsigned int | getNumberOfTechniqueAnnotations (CgFxTechnique tech) const
Returns the number of annotations available for a specified technique.

NVSG_API CgFxAnnotation | getTechniqueAnnotation (CgFxTechnique tech, unsigned int index) const
Returns the technique annotation at the specified zero-based index.

NVSG_API CgFxAnnotation | getTechniqueAnnotationByName (CgFxTechnique tech, const std::string &name) const
Returns an annotation of the specified technique by name.

NVSG_API unsigned int | getNumberOfPassAnnotations (CgFxPass pass) const
Returns the number of annotations available for a specified render pass.

NVSG_API CgFxAnnotation | getPassAnnotation (CgFxPass pass, unsigned int index) const
Returns the pass annotation at the specified zero-based index.

NVSG_API CgFxAnnotation | getPassAnnotationByName (CgFxPass pass, const std::string &name) const
Returns an annotation of the specified pass by name.

NVSG_API const std::string & | getAnnotationName (CgFxAnnotation anno) const
Returns the name of the specified annotation.

NVSG_API const std::string & | getAnnotationTypeString (CgFxAnnotation anno) const
Returns the type string of the specified annotation's value.

NVSG_API bool | isFloatAnnotation (CgFxAnnotation anno) const
Returns whether the specified annotation is a float-type annotation.

NVSG_API bool | isIntAnnotation (CgFxAnnotation anno) const
Returns whether the specified annotation is a integer-type annotation.

NVSG_API bool | isBoolAnnotation (CgFxAnnotation anno) const
Returns whether the specified annotation is a boolean-type annotation.

NVSG_API bool | isStringAnnotation (CgFxAnnotation anno) const
Returns whether the specified annotation is a string-type annotation.

NVSG_API unsigned int | getAnnotationValueSize (CgFxAnnotation anno) const
Returns the size in bytes of the annotation value.

NVSG_API unsigned int | getNumberOfAnnotationValueComponents (CgFxAnnotation anno) const
Returns the number of components the annotation value has.

NVSG_API bool | getFloatAnnotationValue (CgFxAnnotation anno, float *value) const
Returns the value of a float-type annotation.

NVSG_API bool | getIntAnnotationValue (CgFxAnnotation anno, int *value) const
Returns the value of a integer-type annotation.

NVSG_API bool | getBoolAnnotationValue (CgFxAnnotation anno, int *value) const
Returns the value of a boolean-type annotation.

NVSG_API bool | getStringAnnotationValue (CgFxAnnotation anno, std::string &value) const
Returns the value of a string-type annotation.

NVSG_API const std::string & | getParameterName (CgFxParameter param) const
Returns the name of the specified effect parameter.

NVSG_API const std::string & | getParameterSemantic (CgFxParameter param) const
Returns the semantic of the specified effect parameter.

NVSG_API const std::string & | getParameterTypeString (CgFxParameter param) const
Returns the type of the specified parameter as string.

NVSG_API CgFxParameter | getParameterByName (const std::string &name) const
Returns an effect parameter by name.

NVSG_API CgFxParameter | getParameterBySemantic (const std::string &semantic) const
Returns an effect parameter by semantic.

NVSG_API unsigned int | getNumberOfArrayParameterElements (CgFxParameter param) const
Returns the array size of the specified array parameter.

NVSG_API CgFxParameter | getArrayParameterElement (CgFxParameter param, unsigned int index) const
Returns the array element at a specified zero-based index.

NVSG_API unsigned int | getNumberOfStructParameterMembers (CgFxParameter param) const
Returns the number of members for the specifies struct parameter.

NVSG_API CgFxParameter | getStructParameterMember (CgFxParameter param, unsigned int index) const
Returns the struct member at a specified zero-based index.

NVSG_API CgFxParameter | getStructParameterMemberByName (CgFxParameter param, const std::string &member) const
Returns a struct member by name.

NVSG_API unsigned int | getParameterValueSize (CgFxParameter param) const
Returns the size in bytes of the parameter value.

NVSG_API unsigned int | getNumberOfParameterValueComponents (CgFxParameter param) const
Returns the number of components the parameter value has. Returns the number of components the parameter value has.

NVSG_API bool | isScalarParameter (CgFxParameter param) const
Returns whether the specified parameter is a scalar-type parameter.

NVSG_API bool | isVector2Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 2-component vector-type parameter.

NVSG_API bool | isVector3Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 3-component vector-type parameter.

NVSG_API bool | isVector4Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 4-component vector-type parameter.

NVSG_API bool | isMatrix22Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 2x2 matrix-type parameter.

NVSG_API bool | isMatrix23Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 2x3 matrix-type parameter.

NVSG_API bool | isMatrix24Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 2x4 matrix-type parameter.

NVSG_API bool | isMatrix32Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 3x2 matrix-type parameter.

NVSG_API bool | isMatrix33Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 3x3 matrix-type parameter.

NVSG_API bool | isMatrix34Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 3x4 matrix-type parameter.

NVSG_API bool | isMatrix42Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 4x2 matrix-type parameter.

NVSG_API bool | isMatrix43Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 4x3 matrix-type parameter.

NVSG_API bool | isMatrix44Parameter (CgFxParameter param) const
Returns whether the specified parameter is a 4x4 matrix-type parameter.

NVSG_API bool | isFloatParameter (CgFxParameter param) const
Returns whether the specified parameter is a float-type parameter.

NVSG_API bool | isIntParameter (CgFxParameter param) const
Returns whether the specified parameter is a integer-type parameter.

NVSG_API bool | isBoolParameter (CgFxParameter param) const
Returns whether the specified parameter is a boolean-type parameter.

NVSG_API bool | isStringParameter (CgFxParameter param) const
Returns whether the specified parameter is a string-type parameter.

NVSG_API bool | isSamplerParameter (CgFxParameter param) const
Returns whether the specified parameter is a sampler-type parameter.

NVSG_API bool | isSampler1DParameter (CgFxParameter param) const
Returns whether the specified parameter is a sampler1D-type parameter.

NVSG_API bool | isSampler2DParameter (CgFxParameter param) const
Returns whether the specified parameter is a sampler2D-type parameter.

NVSG_API bool | isSampler3DParameter (CgFxParameter param) const
Returns whether the specified parameter is a sampler3D-type parameter.

NVSG_API bool | isSamplerRectParameter (CgFxParameter param) const
Returns whether the specified parameter is a samplerRECT-type parameter.

NVSG_API bool | isSamplerCubeParameter (CgFxParameter param) const
Returns whether the specified parameter is a samplerCUBE-type parameter.

NVSG_API bool | isSamplerArrayParameter (CgFxParameter param) const
Returns whether the specified parameter is a sampler array type parameter.

NVSG_API bool | isLightParameter (CgFxParameter param) const
Returns whether the specified parameter is a NVSGLight-type parameter.

NVSG_API bool | isLightArrayParameter (CgFxParameter param) const
Returns whether the specified parameter specifies an array of NVSGLight-type parameters.

NVSG_API bool | isMaterialParameter (CgFxParameter param) const
Returns whether the specified parameter is a NVSGMaterial-type parameter.

NVSG_API bool | isSceneParameter (CgFxParameter param) const
Returns whether the specified parameter is a NVSGScene-type parameter.

NVSG_API bool | isTransformParameter (CgFxParameter param) const
Returns whether the specified parameter is a transform parameter.

NVSG_API bool | isArrayParameter (CgFxParameter param) const
Returns whether the specified parameter is an array parameter.

NVSG_API bool | isStructParameter (CgFxParameter param) const
Returns whether the specified parameter is a struct parameter.

NVSG_API unsigned int | getNumberOfTransforms () const
Returns the number of transform parameters available.

NVSG_API CgFxParameter | getTransform (unsigned int index) const
Returns the transform parameter at the specified zero-based index. Returns the transform parameter at the specified zero-based index.

NVSG_API TransformType | getTransformType (CgFxParameter param) const
Returns the transform type of the specified transform parameter.

NVSG_API bool | setTransformValue (CgFxParameter param, const float *value)
Uploads a 4x4 transform matrix to the underlying effect resource.

NVSG_API unsigned int | getNumberOfTweakables () const
Returns the number of alterable effect parameters (so called 'tweakables').

NVSG_API CgFxParameter | getTweakable (unsigned int index) const
Returns the tweakable at the specified zero-based index.

NVSG_API CgFxParameter | getTweakableBySemantic (const std::string &semantic) const
Returns a tweakable effect parameter by semantic.

NVSG_API CgFxParameter | getTweakableByName (const std::string &name) const
Returns a tweakable effect parameter by name.

NVSG_API unsigned int | getNumberOfLights () const
Returns the number of effect lights available.

NVSG_API CgFxParameter | getLight (unsigned int index) const
Returns the light parameter at a specified zero-based index.

NVSG_API CgFxParameter | getLightBySemantic (const std::string &semantic) const
Returns a light parameter by semantic.

NVSG_API CgFxParameter | getLightByName (const std::string &name) const
Returns a light parameter by name.

NVSG_API CgFxParameter | getMaterial () const
Returns the effects material parameter if available.

NVSG_API CgFxParameter | getScene () const
Returns the effects scene parameter if available.

NVSG_API bool | getParameterValueAsFloat (CgFxParameter param, float *value) const
Returns a numeric-type parameter value as 32-bit float values.

NVSG_API bool | setParameterValueAsFloat (CgFxParameter param, const float *value)
Sets the value of a numeric-type parameter as 32-bit float value.

NVSG_API bool | getFloatParameterValue (CgFxParameter param, float *value) const
Returns the value of a float-type parameter.

NVSG_API bool | setFloatParameterValue (CgFxParameter param, const float *value)
Sets the value of a float-type parameter.

NVSG_API bool | getIntParameterValue (CgFxParameter param, int *value) const
Returns the value of a integer-type parameter.

NVSG_API bool | setIntParameterValue (CgFxParameter param, const int *value)
Sets the value of a integer-type parameter.

NVSG_API bool | getBoolParameterValue (CgFxParameter param, int *value) const
Returns the value of a 32-bit boolean-type parameter.

NVSG_API bool | setBoolParameterValue (CgFxParameter param, const int *value)
Sets the value of a 32-bit boolean-type parameter.

NVSG_API bool | getStringParameterValue (CgFxParameter param, std::string &value) const
Returns the string value of a string-type parameter.

NVSG_API bool | setStringParameterValue (CgFxParameter param, const std::string &value)
Sets the string value for a string-type parameter.

NVSG_API void | resetSceneValues (CgFxParameter param)
Resets the specified Scene to default.

NVSG_API bool | getSceneAmbientValue (CgFxParameter param, float *value) const
Returns the ambient RGBA intensity of the entire scene.

NVSG_API bool | setSceneAmbientValue (CgFxParameter param, const float *value)
Sets the ambient RGBA intensity of the entire scene.

NVSG_API bool | getSceneFrameNumberValue (CgFxParameter param, int *value) const
Returns the scene frame number.

NVSG_API bool | setSceneFrameNumberValue (CgFxParameter param, const int *value)
Sets the current frame number.

NVSG_API void | resetMaterialValues (CgFxParameter param)
Resets the specified material to default.

NVSG_API bool | getMaterialEmissionValue (CgFxParameter param, float *value) const
Returns the RGBA emitted light intensity of the specified material.

NVSG_API bool | setMaterialEmissionValue (CgFxParameter param, const float *value)
Sets the RGBA emitted light intensity for the specified material.

NVSG_API bool | getMaterialAmbientValue (CgFxParameter param, float *value) const
Returns the ambient RGBA reflectance of the specified material.

NVSG_API bool | setMaterialAmbientValue (CgFxParameter param, const float *value)
Sets the ambient RGBA reflectance for the specified material.

NVSG_API bool | getMaterialDiffuseValue (CgFxParameter param, float *value) const
Returns the diffuse RGBA reflectance of the specified material.

NVSG_API bool | setMaterialDiffuseValue (CgFxParameter param, const float *value)
Sets the diffuse RGBA reflectance for the specified material.

NVSG_API bool | getMaterialSpecularValue (CgFxParameter param, float *value) const
Returns the specular RGBA reflectance of the specified material.

NVSG_API bool | setMaterialSpecularValue (CgFxParameter param, const float *value)
Sets the specular RGBA reflectance for the specified material.

NVSG_API bool | getMaterialShininessValue (CgFxParameter param, float *value) const
Returns the RGBA specular exponent of the specified material.

NVSG_API bool | setMaterialShininessValue (CgFxParameter param, const float *value)
Sets the RGBA specular exponent for the specified material.

NVSG_API void | resetLightValues (CgFxParameter param)
Resets the values for the specified light to default.

NVSG_API bool | getLightAmbientValue (CgFxParameter param, float *value) const
Returns the ambient RGBA intensity of the specified light.

NVSG_API bool | setLightAmbientValue (CgFxParameter param, const float *value)
Sets the ambient RGBA intensity for the specified light.

NVSG_API bool | getLightDiffuseValue (CgFxParameter param, float *value) const
Returns the diffuse RGBA intensity of the specified light.

NVSG_API bool | setLightDiffuseValue (CgFxParameter param, const float *value)
Sets the diffuse RGBA intensity for the specified light.

NVSG_API bool | getLightSpecularValue (CgFxParameter param, float *value) const
Returns the specular RGBA intensity of the specified light.

NVSG_API bool | setLightSpecularValue (CgFxParameter param, const float *value)
Sets the specular RGBA intensity for the specified light.

NVSG_API bool | getLightPositionValue (CgFxParameter param, float *value) const
Returns the position of the specified light.

NVSG_API bool | setLightPositionValue (CgFxParameter param, const float *value)
Sets the position for the specified light.

NVSG_API bool | getLightDirectionValue (CgFxParameter param, float *value) const
Returns the direction of the specified light.

NVSG_API bool | setLightDirectionValue (CgFxParameter param, const float *value)
Sets the direction for the specified light.

NVSG_API bool | getLightSpotExponentValue (CgFxParameter param, float *value) const
Returns the intensity distribution of the specified light.

NVSG_API bool | setLightSpotExponentValue (CgFxParameter param, const float *value)
Sets the intensity distribution for the specified light.

NVSG_API bool | getLightSpotCutoffValue (CgFxParameter param, float *value) const
Returns the maximum spread angle of the specified light.

NVSG_API bool | setLightSpotCutoffValue (CgFxParameter param, const float *value)
Sets the maximum spread angle for the specified light.

NVSG_API bool | getLightConstantAttenuationValue (CgFxParameter param, float *value) const
Returns the constant attenuation factor of the specified light.

NVSG_API bool | setLightConstantAttenuationValue (CgFxParameter param, const float *value)
Sets the constant attenuation factor for the specified light.

NVSG_API bool | getLightLinearAttenuationValue (CgFxParameter param, float *value) const
Returns the linear attenuation factor of the specified light.

NVSG_API bool | setLightLinearAttenuationValue (CgFxParameter param, const float *value)
Sets the linear attenuation factor for the specified light.

NVSG_API bool | getLightQuadraticAttenuationValue (CgFxParameter param, float *value) const
Returns the quadratic attenuation factor of the specified light.

NVSG_API bool | setLightQuadraticAttenuationValue (CgFxParameter param, const float *value)
Sets the quadratic attenuation factor for the specified light.

NVSG_API unsigned int | getNumberOfSamplers () const
Returns the number of sampler available.

NVSG_API CgFxParameter | getSampler (unsigned int index) const
Returns the sampler at the specified zero-based index. Returns the sampler at the specified zero-based index.

NVSG_API CgFxParameter | getSamplerByName (const std::string &name) const
Returns a sampler parameter by name.

NVSG_API CgFxParameter | getSamplerByTextureParameterName (const std::string &name) const
Returns a sampler parameter by the name of its associated texture parameter.

NVSG_API CGparameter | getSamplerTexture (CgFxParameter param) const
Returns the CGparameter handle that corresponds to the specified sampler parameter.

NVSG_API unsigned int | getNumberOfProgramSamplers (CgFxProgram prog) const
Returns the number of samplers used in a particular program.

NVSG_API CgFxParameter | getProgramSampler (CgFxProgram prog, unsigned int index) const
Returns the sampler at the specified zero-based index in the given program. Returns the sampler at the specified zero-based index.

NVSG_API ProgramIOType | getProgramInputType (CgFxProgram prog) const
Returns the input type for the given program.

NVSG_API ProgramIOType | getProgramOutputType (CgFxProgram prog) const
Returns the output type for the given program.

NVSG_API bool | isMipmapSamplerState (CgFxParameter sampler) const
Returns whether the sampler state for the specified sampler requires mipmap generation.

NVSG_API bool | isTextureImageSamplerCompliant (CgFxParameter sampler, TextureImageHandle *image) const
Returns whether the indicated TextureImage is compliant to the specified sampler.

NVSG_API bool | setSamplerTextureImage (CgFxParameter param, TextureImageHandle *image)
Assigns a new TextureImage to the specified sampler parameter.

NVSG_API bool | getSamplerTextureFileName (CgFxParameter param, std::string &file) const
Returns the file name that is associated with the sampler's texture image.

NVSG_API TextureImageHandle * | getSamplerTextureImage (CgFxParameter param) const
Returns the texture image assigned to the specified sampler parameter.

NVSG_API bool | setSamplerTextureGPUFormat (CgFxParameter param, TextureImage::TextureGPUFormat format)
Requests a particular texture GPU format that be used for this sampler.

NVSG_API bool | getSamplerTextureGPUFormat (CgFxParameter param, TextureImage::TextureGPUFormat &format)
Returns the texture GPU format that was requested of this sampler.

NVSG_API TextureTarget | getSamplerTextureTarget (CgFxParameter param) const
Retrieves the TextureTarget for the specified sampler parameter.

NVSG_API unsigned int | getNumberOfSamplerStateValueComponents (CgFxParameter param, const std::string &name) const
Returns the number of components the specified named sampler state value has.

NVSG_API bool | isFloatSamplerState (CgFxParameter param, const std::string &name) const
Returns whether the specified sampler state is a float-type sampler state.

NVSG_API bool | isIntSamplerState (CgFxParameter param, const std::string &name) const
Returns whether the specified sampler state is a integer-type sampler state.

NVSG_API bool | isBoolSamplerState (CgFxParameter param, const std::string &name) const
Returns whether the specified sampler state is a boolean-type sampler state.

NVSG_API bool | getFloatSamplerStateValue (CgFxParameter param, const std::string &name, float *value) const
Returns the value of the specified float-type sampler state.

NVSG_API bool | getIntSamplerStateValue (CgFxParameter param, const std::string &name, int *value) const
Returns the value of the specified integer-type sampler state.

NVSG_API bool | getBoolSamplerStateValue (CgFxParameter param, const std::string &name, int *value) const
Returns the value of the specified 32-bit boolean-type sampler state.

NVSG_API unsigned int | getNumberOfTechniques () const
Returns the number of techniques defined for this effect.

NVSG_API CgFxTechnique | getTechnique (unsigned int index) const
Returns the technique at the specified zero-based index.

NVSG_API CgFxTechnique | getTechniqueByName (const std::string &name) const
Returns a technique by name.

NVSG_API unsigned int | getTechniqueIndex (CgFxTechnique tech) const
Returns the zero-based index of the specified technique.

NVSG_API const std::string & | getTechniqueName (CgFxTechnique tech) const
Returns the name of the specified technique.

NVSG_API CgFxTechnique | getCurrentTechnique () const
Returns the current technique.

NVSG_API void | setCurrentTechnique (CgFxTechnique tech)
Sets the current technique to be used with rendering.

NVSG_API bool | validateCurrentTechnique ()
Validates the current technique.

NVSG_API unsigned int | getNumberOfPasses (CgFxTechnique tech) const
Returns the number of render passes defined for the specified technique.

NVSG_API CgFxPass | getPass (CgFxTechnique tech, unsigned int index) const
Returns the pass at the specified zero-based index defined in the specified technique.

NVSG_API CgFxPass | getPassByName (CgFxTechnique tech, const std::string &name) const
Returns a pass of a specified technique by name.

NVSG_API const std::string & | getPassName (CgFxPass pass) const
Returns the name of the specified render pass.

NVSG_API bool | isTransparentPass (CgFxPass pass) const
Tests whether the specified pass forces transparency.

NVSG_API void | applyPass (unsigned int index)
Applies the specified render pass.

NVSG_API void | resetPass (unsigned int index)
Resets the specified render pass.

NVSG_API unsigned int | getNumberOfPassStateValueComponents (CgFxPass pass, const std::string &name) const
Returns the number of components the specified pass state value has.

NVSG_API bool | isFloatPassState (CgFxPass pass, const std::string &name) const
Returns whether the specified pass state is a float-type pass state.

NVSG_API bool | isIntPassState (CgFxPass pass, const std::string &name) const
Returns whether the specified pass state is a integer-type pass state.

NVSG_API bool | isBoolPassState (CgFxPass pass, const std::string &name) const
Returns whether the specified pass state is a 32-bit boolean-type pass state.

NVSG_API bool | getFloatPassStateValue (CgFxPass pass, const std::string &name, float *value) const
Returns the value of the specified float-type pass state.

NVSG_API bool | getIntPassStateValue (CgFxPass pass, const std::string &name, int *value) const
Returns the value of the specified integer-type pass state.

NVSG_API bool | getBoolPassStateValue (CgFxPass pass, const std::string &name, int *value) const
Returns the value of the specified 32-bit boolean-type pass state.

NVSG_API CgFxProgram | getVertexProgram (CgFxPass pass) const
Returns the vertex program defined for the specified pass.

NVSG_API CgFxProgram | getGeometryProgram (CgFxPass pass) const
Returns the geometry program defined for the specified pass.

NVSG_API CgFxProgram | getFragmentProgram (CgFxPass pass) const
Returns the fragment program defined for the specified pass.

NVSG_API bool | isProgramCompiled (CgFxProgram prog) const
Returns whether the specified program is compiled.

NVSG_API bool | compileProgram (CgFxProgram prog)
Compiles the specified program.

NVSG_API bool | setProgramProfile (CgFxProgram prog, const std::string &profile)
Sets the profile to be used to compile the specified program.

NVSG_API const std::string & | getProgramProfile (CgFxProgram prog) const
Returns the actual profile used to compile the specified program.

NVSG_API unsigned int | getNumberOfProgramParameters (CgFxProgram prog) const
Returns the number of parameters passed to the specified program.

NVSG_API CgFxParameter | getProgramParameter (CgFxProgram prog, unsigned int index) const
Returns the program parameter at the specified zero-based index.

NVSG_API bool | isInputProgramParameter (CgFxProgram prog, CgFxParameter param) const
Returns whether the specified program parameter is an input parameter.

NVSG_API bool | isOutputProgramParameter (CgFxProgram prog, CgFxParameter param) const
Returns whether the specified program parameter is an output parameter.

Detailed Description

Abstracts a render effect to be applied to a specific geometry.

Namespace: nvsg
Remarks:
This class provides interfaces that lets you
  • Create a render effect from either a file or a source string,
  • Query dependent data from the underlying effect resource,
  • Exchange dependent data with the underlying effect resource, and
  • Apply the render effect to a specific geometry.

The CgFxEffect class is always considered in conjunction with a CgFx state attribute. A CgFxEffect object cannot be instantiated directly, but will be instantiated through its associated CgFx attribute. You need to call CgFx::getEffect to get the embedded CgFxEffect object of a certain CgFx attribute. The CgFx::getEffect function returns a pointer to a CgFxEffectHandle. If you need read or write access to the CgFxEffectHandle, you have to use the WritableObject<> or ReadableObject<> template classes to gain access to the objects members. The scope of the template classes determines the duration of the read/write access. See the documentation on the "handles-based" interface for more information.

Member Enumeration Documentation

enum TransformType

Enumeration type to identify specific transforms.

Remarks:
Uniform transform parameters always have a defined meaning. Knowing this meaning is essential, for example, when a renderer needs to update transform data for a certain transform parameter.

CgFxEffect::getTransformType lets you determine what kind of transform a certain transform parameter represents.
Enumeration values:
TRAFO_UNKNOWN | Indicates an unknown transform.
TRAFO_WORLD | Indicates a transform from object space to world space.
TRAFO_MODEL | Indicates a transform from object space to world space.
TRAFO_VIEW | Indicates a transform from world space to eye space.
TRAFO_PROJECTION | Indicates a transform from eye space to clip space.
TRAFO_WORLDT | Indicates a transposed transform from object space to world space.
TRAFO_MODELT | Indicates a transposed transform from object space to world space.
TRAFO_WORLDTRANSPOSE | Indicates a transposed transform from object space to world space.
TRAFO_MODELTRANSPOSE | Indicates a transposed transform from object space to world space.
TRAFO_VIEWT | Indicates a transposed transform from world space to eye space.
TRAFO_VIEWTRANSPOSE | Indicates a transposed transform from world space to eye space.
TRAFO_PROJECTIONT | Indicates a transposed transform from eye space to clip space.
TRAFO_PROJECTIONTRANSPOSE | Indicates a transposed transform from eye space to clip space.
TRAFO_WORLDI | Indicates a transform from world space to object space.
TRAFO_MODELI | Indicates a transform from world space to object space.
TRAFO_WORLDINVERSE | Indicates a transform from world space to object space.
TRAFO_MODELINVERSE | Indicates a transform from world space to object space.
TRAFO_VIEWI | Indicates a transform from eye space to world space.
TRAFO_VIEWINVERSE | Indicates a transform from eye space to world space.
TRAFO_PROJECTIONI | Indicates a transform from clip space to eye space.
TRAFO_PROJECTIONINVERSE | Indicates a transform from clip space to eye space.
TRAFO_WORLDIT | Indicates a transposed transform from world space to object space.
TRAFO_MODELIT | Indicates a transposed transform from world space to object space.
TRAFO_WORLDINVERSETRANSPOSE | Indicates a transposed transform from world space to object space.
TRAFO_MODELINVERSETRANSPOSE | Indicates a transposed transform from world space to object space.
TRAFO_VIEWIT | Indicates a transposed transform from eye space to world space.
TRAFO_VIEWINVERSETRANSPOSE | Indicates a transposed transform from eye space to world space.
TRAFO_PROJECTIONIT | Indicates a transposed transform from clip space to eye space.
TRAFO_PROJECTIONINVERSETRANSPOSE | Indicates a transposed transform from clip space to eye space.
TRAFO_WORLDVIEW | Indicates a transform from object space to eye space.
TRAFO_MODELVIEW | Indicates a transform from object space to eye space.
TRAFO_WORLDVIEWPROJECTION | Indicates a transform from object space to clip space.
TRAFO_MODELVIEWPROJECTION | Indicates a transform from object space to clip space.
TRAFO_WORLDVIEWT | Indicates a transposed transform from object space to eye space.
TRAFO_MODELVIEWT | Indicates a transposed transform from object space to eye space.
TRAFO_WORLDVIEWTRANSPOSE | Indicates a transposed transform from object space to eye space.
TRAFO_MODELVIEWTRANSPOSE | Indicates a transposed transform from object space to eye space.
TRAFO_WORLDVIEWPROJECTIONT | Indicates a transposed transform from object space to clip space.
TRAFO_MODELVIEWPROJECTIONT | Indicates a transposed transform from object space to clip space.
TRAFO_WORLDVIEWPROJECTIONTRANSPOSE | Indicates a transposed transform from object space to clip space.
TRAFO_MODELVIEWPROJECTIONTRANSPOSE | Indicates a transposed transform from object space to clip space.
TRAFO_WORLDVIEWI | Indicates a transform from eye space to object space.
TRAFO_MODELVIEWI | Indicates a transform from eye space to object space.
TRAFO_WORLDVIEWINVERSE | Indicates a transform from eye space to object space.
TRAFO_MODELVIEWINVERSE | Indicates a transform from eye space to object space.
TRAFO_WORLDVIEWPROJECTIONI | Indicates a transform from clip space to object space.
TRAFO_MODELVIEWPROJECTIONI | Indicates a transform from clip space to object space.
TRAFO_WORLDVIEWPROJECTIONINVERSE | Indicates a transform from clip space to object space.
TRAFO_MODELVIEWPROJECTIONINVERSE | Indicates a transform from clip space to object space.
TRAFO_WORLDVIEWIT | Indicates a transposed transform from eye space to object space.
TRAFO_MODELVIEWIT | Indicates a transposed transform from eye space to object space.
TRAFO_WORLDVIEWINVERSETRANSPOSE | Indicates a transposed transform from eye space to object space.
TRAFO_MODELVIEWINVERSETRANSPOSE | Indicates a transposed transform from eye space to object space.
TRAFO_WORLDVIEWPROJECTIONIT | Indicates a transposed transform from clip space to object space.
TRAFO_MODELVIEWPROJECTIONIT | Indicates a transposed transform from clip space to object space.
TRAFO_WORLDVIEWPROJECTIONINVERSETRANSPOSE | Indicates a transposed transform from clip space to object space.
TRAFO_MODELVIEWPROJECTIONINVERSETRANSPOSE | Indicates a transposed transform from clip space to object space.

enum ProgramIOType

Enumeration type to identify input or output of shaders.

Remarks:
CgFxEffect::getProgramInputType and CgFxEffect::getProgramOutputType let you determine the input or output types of the programs.
Enumeration values:
PROGRAM_IO_VERTEX | input/output is a vertex
PROGRAM_IO_FRAGMENT | input/output is a fragment
PROGRAM_IO_POINT | input/output is a point
PROGRAM_IO_LINE | input/output is a line
PROGRAM_IO_LINE_ADJ | input/output is a line with adjacency
PROGRAM_IO_TRIANGLE | input/output is a triangle
PROGRAM_IO_TRIANGLE_ADJ | input/output is a triangle with adjacency

Constructor & Destructor Documentation

CgFxEffect ( )

Default-constructs a CgFxEffect.

CgFxEffect ( const CgFxEffect & rhs )

Constructs a CgFxEffect as a copy from another CgFxEffect.

Parameters:
rhs Source CgFxEffect.

~CgFxEffect ( )

Destructs a CgFxEffect.

Member Function Documentation

NVSG_API bool createFromFile | ( | const std::string & | file,
 |  | std::string & | err
 | ) |

Creates a render effect from an input file.

Parameters:
file | Specifies the path and filename of the effect's source file.
err | Reference to a string that receives an error string in the event an error occurred during creation.
Returns:
The function returns true if the effect creation was successful. If the effect creation fails, the function returns false.
Remarks:
The function tries to create an effect from the CgFX source file specified by file. Known file extensions for files to hold valid CgFX code are .cg and .cgfx. For the effect to be created successfully, the CgFX source code must comply with Cg 1.4 specification. More detailed information about Cg/CgFX can be found at http://developer.nvidia.com/page/cg_main.html

If an error occurred during creation, the function returns an error string in err which provides more information about the root cause of the error.
Example:
 // create a CgFX State Attribute Handle through the reference counted interface.
 RCObject_AutoPtr< CgFxHandle > hCgfx(CreateHandle(CgFxHandle));
 {
   // gain writable access to the CgFx handle
   WritableObject< CgFx > cg( hCgfx.get() );
   // gain writable access to the CgFxEffect
   WritableObject< CgFxEffect > effect( cg->getEffect() );
   //
   // Create effect from the file
   //
   std::string err;
   if(! effect->createFromFile( "c:\morrisonIsCool.cgfx", err ) )
   {
     nvutil::IO::errorMessage("effect creation failed", err, true);
     return false;
   }
   // effect creation succeeded - modify as needed
   [...]

  }
  // write access to the Cg shader and CgFxEffect ended inside above scope

  // ...
See also:
CgFx, CgFx::getEffect, CgFxEffect::createFromLump

NVSG_API bool createFromLump | ( | const std::string & | lump,
 |  | std::string & | err
 | ) |

Creates a render effect from a code string.

Parameters:
lump | Specifies the code string from which to create the effect.
err | Reference to a string that receives an error string in case an error occurred during creation.
Returns:
The function returns true if the effect creation was successful. If the effect creation fails, the function returns false.
Remarks:
In contrast to CgFxEffect::createFromFile, this function attempts to create a render effect from a string of CgFX source code. For the effect to be created successfully, The CgFX source code must comply with Cg 1.4 specification. More detailed information about Cg/CgFX can be found at http://developer.nvidia.com/page/cg_main.html

If an error occurred during creation, the function returns an error string in err which provides more information about the root cause of the error.
Example:
This example shows how to create a render effect from a CgFX source string.
 #include "nvsg/CgFx.h"
 #include "nvutil/IOLayer.h"
 #include "nvutil/SWMRSync.h"
 #include <string> // STL string

 using namespace nvsg;
 using namespace nvutil;
 using namespace nvutil::IO;

 std::string visualizeNormals(
   "float4x4 mvp : ModelViewProjection;                \n"
   "                                                   \n"
   "void vertex( float3 position : POSITION            \n"
   "           , float3 normal : NORMAL                \n"
   "           , out float4 opos : POSITION            \n"
   "           , out float3 onor : TEXCOORD0           \n"
   "           , uniform float4x4 mvp )                \n"
   "{                                                  \n"
   "  opos = mul(mvp, float4(position, 1));            \n"
   "  onor = normal;                                   \n"
   "}                                                  \n"
   "                                                   \n"
   "float4 fragment ( float4 position : POSITION       \n"
   "                , float3 normal : TEXCOORD0        \n"
   "                ) : COLOR                          \n"
   "{                                                  \n"
   "  float3 n = normalize(normal);                    \n"
   "  return float4(n, 1);                             \n"
   "}                                                  \n"
   "                                                   \n"
   "technique t0                                       \n"
   "{                                                  \n"
   "  pass p0                                          \n"
   "  {                                                \n"
   "    VertexProgram = compile arbvp1 vertex(mvp);    \n"
   "    FragmentProgram = compile arbfp1 fragment();   \n"
   "  }                                                \n"
   "}                                                  \n"
 );

 // create a CgFX State Attribute Handle through the reference counted interface.
 RCObject_AutoPtr< CgFxHandle > hCgfx(CreateHandle(CgFxHandle));
 {
   WritableObject<CgFx> cgfx( hCgfx.get() );
   WritableObject<CgFxEffect> effect( cgfx->getEffect() );

   std::string err;
   if ( !effect->createFromLump(visualizeNormals, err) )
   {
       errorMessage("effect creation failed", err, true);
       return false;
   }
   // effect creation succeeded - go ahead

 } // exit of scope release write access to cgfx and effect
 // ...
See also:
CgFx, CgFxEffect::createFromFile

NVSG_API bool isValid ( ) const

Returns whether the effect is valid.

Returns:
The function returns true if the effect is valid. If the effect is invalid, the function returns false.
Remarks:
An effect should be valid if it was previously created successfully. A render effect can be either created from a file using CgFxEffect::createFromFile, or alternatively from a string of source code using CgFxEffect::createFromLump.

This function primarily serves runtime checks to prevent an invalid effect from being applied to a geometry. Applying an invalid effect to a geometry results in undefined runtime behavior.
See also:
CgFxEffect::createFromFile, CgFxEffect::createFromLump

NVSG_API CGcontext getContext ( ) const

Returns the CGcontext associated with the effect.

Returns:
The function returns a handle to the CGcontext that is associated with the effect.
Remarks:
Creating an effect requires a valid CGcontext to be created in beforehand. The creation of a valid CGcontext is wrapped by CgFxEffect::createFromFile and CgFxEffect::createFromLump . Therefore, the user does not need to take care of the CGcontext creation by himself. However, one can think of situations where the application needs to call the Cg-runtime directly, in particular when it comes to device (e.g. OpenGL) dependent calls that require a valid CGcontext handle as a parameter.

NVSG_API bool isFromFile ( ) const

Returns whether the effect was created from a file.

Returns:
The function returns true if the effect was create from a CgFX source file. Otherwise, the function returns false.
Remarks:
A render effect can be created either from a CgFX source file using CgFxEffect::createFromFile, or alternatively from a string of CgFX source code using CgFxEffect::createFromLump.

Information on whether a certain effect was created from a file or a string could be useful, for example, for implementing a scene saver which probably needs to track this information.
See also:
CgFxEffect::createFromFile

NVSG_API bool isFromLump ( ) const

Returns whether the effect was created from a lump of CgFX source code.

Returns:
The function returns true if the effect was create from a lump of CgFX source code. Otherwise the function returns false.
Remarks:
A render effect can be either created from a CgFX source file using CgFxEffect::createFromFile, or alternatively from a string of CgFX source code using CgFxEffect::createFromLump.

Information on whether a certain effect was created from a file or a lump could be useful, for example, for implementing a scene saver which probably needs to track this information.
See also:
CgFxEffect::createFromLump

NVSG_API bool getFileName ( std::string & file ) const

Returns the file name of the CgFX source file from which the effect was created.

Parameters:
file Reference to a string that receives the file name of the source file.
Returns:
The function returns true if a source file name could be received successfully. Otherwise, the function returns false and file will receive an empty string.
Remarks:
If the function succeeds, the parameter file holds the path and file name of the particular CgFX source file from which the effect was previously created.

The function will fail if either the creation from file failed in beforehand, or if the effect was not created from a file but from a source string. You can use CgFxEffect::isFromFile to test whether the effect was created from a file.
Example:
 void printEffectFileName(const CgFx * cgfx)
 {
     // assumes cgfx is read locked
     ReadableObject<CgFxEffect> effect( cgfx->getEffect() );
     if ( effect->isFromFile() )
     {
         string filename;
         NVSG_VERIFY(effect->getFileName(filename));
         printf("The effect was created from %s\n", filename.c_str());
     }
     else
     {
         printf("The effect was not created from a file.\n");
     }
 }
See also:
CgFxEffect::isFromFile, CgFxEffect::createFromFile

NVSG_API bool getSourceCode ( std::string & code ) const

Returns CgFX source string from which the effect was created.

Parameters:
code Reference to a string that receives the string of CgFX source code.
Returns:
The function returns true if the source code could be received successfully. Otherwise, the function returns false and code will receive an empty string.
Remarks:
If the function succeeds, the parameter code holds the source code from which the effect was previously created through CgFxEffect::createFromLump.

The function will fail if either the creation from a source string failed beforehand, or if the effect was not created from a source string but from a file. You can use CgFxEffect::isFromLump to test whether the effect was created from a source string.
Example:
 void printEffectSources(const CgFx * cgfx)
 {
     // assumes cgfx is read locked
     ReadableObject<CgFxEffect> effect(cgfx->getEffect());
     if ( effect->isFromLump() )
     {
         string code;
         NVSG_VERIFY(effect->getSourceCode(code));
         printf("%s\n", code.c_str());
     }
     else
     {
         printf("The effect was not created from a source string.\n");
     }
 }
See also:
CgFxEfect::isFromLump, CgFxEffect::createFromLump

NVSG_API unsigned int getNumberOfParameterAnnotations ( CgFxParameter param ) const

Returns the number of annotations available for a specified parameter.

Parameters:
param Handle to the effect parameter from which to query the number of available annotations.
Returns:
The function returns the number of annotations available for the parameter specified by param.
Remarks:
The function is particularly useful if you need to iterate over all available annotations for a certain effect parameter.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use getTweakable, getParameterByName, or getParameterBySemantic to get a valid handle to a specific effect parameter.
Example:
 void printParameterAnnotationNames(const CgFxEffect * effect, CgFxParameter param)
 {
     unsigned int numAnnos = effect->getNumberOfParameterAnnotations(param);
     for ( unsigned int i=0; i<numAnnos; ++i )
     {
         CgFxAnnotation anno = effect->getParameterAnnotation(param, i);
         printf("Annotation %d: %s\n", i, effect->getAnnotationName(anno).c_str());
     }
 }
See also:
CgFxEffect::getParameterAnnotation, CgFxEffect::getTweakable, CgFxEffect::getParameterByName, CgFxEffect::getParameterBySemantic

NVSG_API CgFxAnnotation getParameterAnnotation | ( | CgFxParameter | param,
 |  | unsigned int | index
 | ) | const

Returns the parameter annotation at the specified zero-based index.

Parameters:
param | Handle to the effect parameter from which to get the annotation.
index | Zero-based index of the annotation.
Returns:
The function returns a handle to the queried parameter annotation.
Remarks:
For example, to query an annotation's name, its value type, or its value, you need a handle to that annotation. This function is particularly useful if you don't know the exact names of a certain parameter's annotations. If you want to get a particular annotation that you know by name, it would be more effective to get the annotation by calling CgFxEffect::getParameterAnnotationByName instead.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

You should use the function always in conjunction with CgFxEffect::getNumberOfParameterAnnotations to secure always passing a valid index to the function. Passing an invalid index - that is, an index greater or equal to what CgFxEffect::getNumberOfParameterAnnotation returns for the specified parameter - would result in undefined runtime behavior.
Example:
 const CgFxEffect * effect;
 CgFxParameter param;
 [...]
 // Assume a valid read-locked effect and a valid parameter here
 unsigned int numAnnos = effect->getNumberOfParameterAnnotations(param);

 for ( unsigned int i=0; i<numAnnos; ++i )
 {
     CgFxAnnotation anno = effect->getParameterAnnotation(param, i);
     // proceed with annotation
     [...]
 }
See also:
CgFxEffec::getParameterAnnotationByName, CgFxEffect::getTweakable, CgFxEffect::getParameterByName, CgFxEffect::getParameterBySemantic

NVSG_API CgFxAnnotation getParameterAnnotationByName | ( | CgFxParameter | param,
 |  | const std::string & | name
 | ) | const

Returns an annotation of the specified parameter by name.

Parameters:
param | Handle to the effect parameter for which to get the named annotation.
name | A string holding the name of the annotation to query for.
Returns:
The function returns a valid annotation handle if a matching annotation was found. Otherwise, a NULL handle is returned to indicate that an annotation with the specified name could not be found.
Remarks:
To query a parameter annotation for a certain attributes such as its name, its value type, or its value, you need a valid handle to that annotation. Use this function if you know the annotation by name, or if you expect a certain kind of parameter to have a conventional annotation. For example a texture parameter often has the File annotation to hold the filename of the default texture file to load the texture image from. Or you might conventionally add a Description annotation to your effect parameters, which holds a general parameter description that you might offer to the user by means of a graphical user interface (GUI).

If you are not interested in a certain 'named' annotation but you want to access all available annotations for a certain parameter, you should use getParameterAnnotation instead, which accesses the available parameter annotations by a zero-based index.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use getTweakable, getParameterByName, or getParameterBySemantic to get a valid handle to a certain effect parameter.
Example:
 void printParameterDescription(const CgFxEffect * effect, CgFxParameter param)
 {
     CgFxAnnotation anno = effect->getParameterAnnotationByName(param, "Description");
     if ( anno )
     {
         // description should be a string
         NVSG_ASSERT(effect->isStringAnnotation(anno));
         std::string desc;
         effect->getStringAnnotationValue(anno, desc);
         printf("Description: %s\n", desc.c_str());
     }
 }
See also:
CgFxEffect::getParameterAnnotation, CgFxEffect::getTweakable, CgFxEffect::getParameterByName, CgFxEffect::getParameterBySemantic

NVSG_API unsigned int getNumberOfTechniqueAnnotations ( CgFxTechnique tech ) const

Returns the number of annotations available for a specified technique.

Parameters:
tech Handle to the technique from which to query the number of available annotations.
Returns:
The function returns the number of annotations available for the technique specified by tech.
Remarks:
The function is particularly useful if you need to iterate over all available annotations for a certain technique.

Calling this function for an invalid technique handle results in undefined runtime behavior. You can use getTechnique or getTechniqueByName to get a valid handle to a certain technique.
Example:
 void printTechniqueAnnotationNames(const CgFxEffect * effect, CgFxTechnique tech)
 {
     unsigned int numAnnos = effect->getNumberOfTechniqueAnnotations(tech);
     for ( unsigned int i=0; i<numAnnos; ++i )
     {
         CgFxAnnotation anno = effect->getTechniqueAnnotation(tech, i);
         printf("Annotation %d: %s\n", i, effect->getAnnotationName(anno).c_str());
     }
 }
See also:
CgFxEffect::getTechniqueAnnotation, CgFxEffect::getTechnique, CgFxEffect::getTechniqueByName

NVSG_API CgFxAnnotation getTechniqueAnnotation | ( | CgFxTechnique | tech,
 |  | unsigned int | index
 | ) | const

Returns the technique annotation at the specified zero-based index.

Parameters:
tech | Handle to the technique from which to get the annotation.
index | Zero-based index of the annotation.
Returns:
The function returns a handle to the queried technique annotation.
Remarks:
For example, to query an annotation's name, its value type, or its value, you need a handle to that annotation. This function is particularly useful if you don't know the exact names of a certain technique's annotations. If you want to get a particular annotation that you know by name, it would be more effective to get the annotation by calling getTechniqueAnnotationByName instead.

Calling this function for an invalid technique handle results in undefined runtime behavior. You can use getTechnique or getTechniqueByName to get a valid handle to a certain technique.

You should use the function always in conjunction with getNumberOfTechniqueAnnotations to secure always passing a valid index to the function. Passing an invalid index - that is, an index greater or equal to what getNumberOfTechniqueAnnotation returns for the specified technique - would result in undefined runtime behavior.
Example:
 const CgFxEffect * effect;
 CgFxTechnique tech;
 [...]
 // assume a valid read-locked effect and a valid technique here
 unsigned int numAnnos = effect->getNumberOfTechniqueAnnotations(tech);

 for ( unsigned int i=0; i<numAnnos; ++i )
 {
     CgFxAnnotation anno = effect->getTechniqueAnnotation(tech, i);
     // proceed with annotation
     [...]
 }
See also:
CgFxEffec::getTechniqueAnnotationByName, CgFxEffect::getTechnique, CgFxEffect::getTechniqueByName

NVSG_API CgFxAnnotation getTechniqueAnnotationByName | ( | CgFxTechnique | tech,
 |  | const std::string & | name
 | ) | const

Returns an annotation of the specified technique by name.

Parameters:
tech | Handle to the technique for which to get the named annotation.
name | A string holding the name of the annotation to query for.
Returns:
The function returns a valid annotation handle if a matching annotation was found. Otherwise a NULL handle is returned to indicate that an annotation with the specified name could not be found.
Remarks:
To query a technique annotation for a certain attribute such as its name, its value type, or its value, you need a valid handle to that annotation. Use this function if you know the annotation by name, or if you expect a technique to have a conventional annotation. For example, you might conventionally add a Description annotation to your techniques, which holds a general technique description that you might offer to the user by means of a graphical user interface (GUI).

If you are not interested in a certain 'named' annotation but you want to access all available annotations for a certain technique, you should use getTechniqueAnnotation instead, which accesses the available technique annotations by a zero-based index.

Calling this function for an invalid technique handle results in undefined runtime behavior. You can use getTechnique or getTechniqueByName to get a valid handle to a certain technique.
Example:
 void printTechniqueDescription(const CgFxEffect * effect, CgFxTechnique tech)
 {
     CgFxAnnotation anno = effect->getTechniqueAnnotationByName(tech, "Description");
     if ( anno )
     {
         // description should be a string
         NVSG_ASSERT(effect->isStringAnnotation(anno));
         std::string desc;
         effect->getStringAnnotationValue(anno, desc);
         printf("Description: %s\n", desc.c_str());
     }
 }
See also:
CgFxEffect::getTechniqueAnnotation, CgFxEffect::getTechnique, CgFxEffect::getTechniqueByName

NVSG_API unsigned int getNumberOfPassAnnotations ( CgFxPass pass ) const

Returns the number of annotations available for a specified render pass.

Parameters:
pass Handle to the pass from which to query the number of available annotations.
Returns:
The function returns the number of annotations available for the render pass specified by pass.
Remarks:
The function is particularly useful if you need to iterate over all annotations available for a certain render pass.

Calling this function for an invalid pass handle results in undefined runtime behavior. You can use getPass or getPassByName to get a valid handle to a certain render pass.
Example:
 void printPassAnnotationNames(const CgFxEffect * effect, CgFxPass pass)
 {
     unsigned int numAnnos = effect->getNumberOfPassAnnotations(pass);
     for ( unsigned int i=0; i<numAnnos; ++i )
     {
         CgFxAnnotation anno = effect->getPassAnnotation(pass, i);
         printf("Annotation %d: %s\n", i, effect->getAnnotationName(anno).c_str());
     }
 }
See also:
CgFxEffect::getPassAnnotation, CgFxEffect::getPass, CgFxEffect::getPassByName

NVSG_API CgFxAnnotation getPassAnnotation | ( | CgFxPass | pass,
 |  | unsigned int | index
 | ) | const

Returns the pass annotation at the specified zero-based index.

Parameters:
pass | Handle to the pass from which to get the annotation.
index | Zero-based index of the annotation.
Returns:
The function returns a handle to the queried pass annotation.
Remarks:
For example, to query an annotation's name, its value type, or its value, you need a handle to that annotation. This function in particular is useful if you don't know the exact names of a certain pass's annotations. If you want to get a particular annotation that you know by name, it would be more effective to get the annotation by calling getTechniqueAnnotationByName instead.

Calling this function for an invalid pass handle results in undefined runtime behavior. You can use getPass or getPassByName to get a valid handle to a certain render pass.

You should use the function always in conjunction with getNumberOfPassAnnotations to avoid passing an invalid index to the function. Passing an invalid index - , that is, an index greater or equal to what getNumberOfPassAnnotation returns for the specified pass - would result in undefined runtime behaviour.
Example:
 const CgFxEffect * effect;
 CgFxPass pass;
 [...]
 // assume a valid read-locked effect and a valid pass here
 unsigned int numAnnos = effect->getNumberOfPassAnnotations(pass);

 for ( unsigned int i=0; i<numAnnos; ++i )
 {
     CgFxAnnotation anno = effect->getPassAnnotation(pass, i);
     // proceed with annotation
     [...]
 }
See also:
CgFxEffec::getPassAnnotationByName, CgFxEffect::getPass, CgFxEffect::getPassByName

NVSG_API CgFxAnnotation getPassAnnotationByName | ( | CgFxPass | pass,
 |  | const std::string & | name
 | ) | const

Returns an annotation of the specified pass by name.

Parameters:
pass | Handle to the render pass for which to get the named annotation.
name | A string holding the name of the annotation to query for.
Returns:
The function returns a valid annotation handle if a matching annotation was found. Otherwise a NULL handle is returned to indicate that an annotation with the specified name could not be found.
Remarks:
To query a pass annotation for a certain attributes such as its name, its value type, or its value, you need a valid handle to that annotation. Use this function if you know the annotation by name, or if you expect a render pass to have a conventional annotation. For example, you might conventionally add a Description annotation to your render passes, which holds a general pass description that you might offer to the user by means of a graphical user interface (GUI).

If you are not interested in a certain 'named' annotation but you want to access all annotations available for a certain pass, you should use getPassAnnotation instead, which accesses the available pass annotations by a zero-based index.

Calling this function for an invalid pass handle results in undefined runtime behavior. You can use getPass or getPassByName to get a valid handle to a certain render pass.
Example:
 void printPassDescription(const CgFxEffect * effect, CgFxPass pass)
 {
     CgFxAnnotation anno = effect->getPassAnnotationByName(pass, "Description");
     if ( anno )
     {
         // description should be a string
         NVSG_ASSERT(effect->isStringAnnotation(anno));
         std::string desc;
         effect->getStringAnnotationValue(anno, desc);
         printf("Description: %s\n", desc.c_str());
     }
 }
See also:
CgFxEffect::getPassAnnotation, CgFxEffect::getPass, CgFxEffect::getPassByName

NVSG_API const std::string& getAnnotationName ( CgFxAnnotation anno ) const

Returns the name of the specified annotation.

Parameters:
anno Handle to the annotation for which to get the name.
Returns:
The function returns a reference to a string holding the annotation's name as specified in the CgFx effect sources.

Annotations can be optionally added to effect parameters, to techniques, or to render passes. Annotations are thought to provide additional information that might be useful for certain applications. For an effect technique, for example, the effect writer could add an optional Description annotation that describes exactly what the technique does.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For a CgFxParameter, for example, you can use getParameterAnnotation to get a valid annotation handle.
See also:
CgFxEffect::getParameterAnnotation, CgFxEffect::GetTechniqueAnnotation, CgFxEffect::getPassAnnotation

NVSG_API const std::string& getAnnotationTypeString ( CgFxAnnotation anno ) const

Returns the type string of the specified annotation's value.

Parameters:
anno Handle to the annotation for which to get the type string.
Returns:
The function returns a reference to a string holding annotation value's type string. For a string-type annotation, for example, this would be "string".
Remarks:
Each annotation has a value of a certain type. Use this function if you need this value as a string.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For a CgFxParameter, for example, you can use getParameterAnnotation to get a valid annotation handle.
See also:
CgFxEffect::getParameterAnnotation, CgFxEffect::GetTechniqueAnnotation, CgFxEffect::getPassAnnotation

NVSG_API bool isFloatAnnotation ( CgFxAnnotation anno ) const

Returns whether the specified annotation is a float-type annotation.

Parameters:
anno Handle to the annotation to query.
Returns:
The function returns true if the annotations value is of type float. Otherwise, the function returns false.
Remarks:
To query an annotation value, you must know the value type and then call the corresponding 'getValue' function to receive the value. For a float-type annotation value, for example, you must call CgFxEffect::getFloatAnnotationValue, whereas for a string-type annotation value you must call CgFxEffect::getStringAnnotationValue to get the value.

This function tells you if the annotation value is a float-type value. It does not tell you how many components - that is, how many single float values - the value has. To determine this, you additioally need to call CgFxEffect::getNumberOfAnnotationValueComponents.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter, for example, you can use getParameterAnnotation to get a valid annotation handle.
Example:
 const CgFxEffect * effect;
 CgFxAnnotation anno;
 // ...
 // assume a valid read-locked effect and a valid annotation handle here
 if ( effect->isFloatAnnotation(anno) )
 {
     if ( 1==effect->getNumberOfAnnotationValueComponents(anno) )
     {
         // its a single float value
         float value;
         effect->getFloatAnnotationValue(anno, &value);
         printf("Value: %f\n", value);
     }
     else
     {
       // more components ...
     }
 }
 // other type
 else
 // ...
See also:
CgFxEffect::getFloatAnnotationValue, CgFxEffect::getNumberOfAnnotationValueComponents

NVSG_API bool isIntAnnotation ( CgFxAnnotation anno ) const

Returns whether the specified annotation is a integer-type annotation.

Parameters:
anno Handle to the annotation to query.
Returns:
The function returns true if the annotations value is of type int. Otherwise, the function returns false.
Remarks:
To query an annotation value, you must know the value type and then call the corresponding 'getValue' function to receive the value. For a integer-type annotation value, for example, you must call CgFxEffect::getIntAnnotationValue, whereas for a string-type annotation value you must call CgFxEffect::getStringAnnotationValue to get the value.

This function tells you if the annotation value is a integer-type value. It does not tell you how many components - that is, how many single integer values - the value has. To determine this, you additionally need to call CgFxEffect::getNumberOfAnnotationValueComponents.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter, for example, you can use getParameterAnnotation to get a valid annotation handle.
Example:
 const CgFxEffect * effect;
 CgFxAnnotation anno;
 // ...
 // assume a valid read-locked effect and a valid annotation handle here
 if ( effect->isIntAnnotation(anno) )
 {
     if ( 4==effect->getNumberOfAnnotationValueComponents(anno) )
     {
         // its a 4-component integer value
         int value[4]; // array to receive the 4-component integer value
         effect->getIntAnnotationValue(anno, value);
         printf("Value: %d, %d, %d, %d\n", value[0], value[1], value[2], value[3]);
     }
     else
     {
       // ...
     }
 }
 // other type
 else
 // ...
See also:
CgFxEffect::getIntAnnotationValue, CgFxEffect::getNumberOfAnnotationValueComponents

NVSG_API bool isBoolAnnotation ( CgFxAnnotation anno ) const

Returns whether the specified annotation is a boolean-type annotation.

Parameters:
anno Handle to the annotation to query.
Returns:
The function returns true if the annotations value is of type 32-bit bool. Otherwise, the function returns false.
Remarks:
To query an annotation value, you must know the value type and then call the corresponding 'getValue' function to receive the value. For a boolean-type annotation value, for example, you must call CgFxEffect::getBoolAnnotationValue, whereas for a string-type annotation value you must call CgFxEffect::getStringAnnotationValue to get the value.

This function tells you if the annotation value is a boolean-type value. It does not tell you how many components - that is, how many single integer values - the value has. To determine this, you additionally need to call CgFxEffect::getNumberOfAnnotationValueComponents.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter, for example, you can use getParameterAnnotation to get a valid annotation handle.
Example:
 const CgFxEffect * effect;
 CgFxAnnotation anno;
 // ...
 // assume a valid read-locked effect and a valid annotation handle here
 if ( effect->isBoolAnnotation(anno) )
 {
     if ( 1==effect->getNumberOfAnnotationValueComponents(anno) )
     {
         // its a 1-component 32-bit boolean value
         int value; // value to receive the 1-component 32-bit boolean value
         effect->getBoolAnnotationValue(anno, &value);
         printf("Value: %s\n", value ? "TRUE" : "FALSE");
     }
     else
     {
       // ...
     }
 }
 // other type
 else
 // ...
See also:
CgFxEffect::getBoolAnnotationValue, CgFxEffect::getNumberOfAnnotationValueComponents

NVSG_API bool isStringAnnotation ( CgFxAnnotation anno ) const

Returns whether the specified annotation is a string-type annotation.

Parameters:
anno Handle to the annotation to query.
Returns:
The function returns true if the annotations value is of type string. Otherwise, the function returns false.
Remarks:
To query an annotation value, you must know the value type and then call the corresponding 'getValue' function to receive the value. For a string-type annotation value, for example, you must call CgFxEffect::getStringAnnotationValue, whereas for a float-type annotation value you must call CgFxEffect::getFloatAnnotationValue to get the value.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter for example, you can use getParameterAnnotation to get a valid annotation handle.
Example:
 const CgFxEffect * effect;
 CgFxAnnotation anno;
 // ...
 // assume a valid read-locked effect and a valid annotation handle here
 if ( effect->isStringAnnotation(anno) )
 {
     // its a string value
     std::string value; // value to receive the string
     effect->getStringAnnotationValue(anno, value);
     printf("Value: %s\n", value.c_str());
 }
 // other type
 else
 // ...
See also:
CgFxEffect::getBoolAnnotationValue, CgFxEffect::getNumberOfAnnotationValueComponents

NVSG_API unsigned int getAnnotationValueSize ( CgFxAnnotation anno ) const

Returns the size in bytes of the annotation value.

Parameters:
anno Handle to the annotation to query.
Returns:
The function returns the size in bytes of the annotation value.
Remarks:
To receive an annotation value the user must provide a value buffer large enough to hold the value. This function can be used to determine how large the receiving buffer needs to be in bytes.

Alternatively, you can use CgFxEffect::getNumberOfAnnotationValueComponents together with the value's type information (e.g. CgFxEffect::isFloatAnnotation) to determine the size of the receiving value buffer.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter for example, you can use getParameterAnnotation to get a valid annotation handle.
See also:
CgFxEffect::getNumberOfAnnotationValueComponents

NVSG_API unsigned int getNumberOfAnnotationValueComponents ( CgFxAnnotation anno ) const

Returns the number of components the annotation value has.

Parameters:
anno Handle to the annotation to query.
Returns:
The function returns the number of value components. An annotation of type float4, for example, has 4 value components.
Remarks:
To receive an annotation value the user must provide a value buffer large enough to hold the value. This function together with the value type information ( e.g. CgFxEffect::isFloatAnnotation" can be used to determine how large the receiving buffer needs to be.

Note that this function is meaningful only for numeric value types like float, integer, or boolean types. For string annotations the value will be received in a STL string object (see CgFxEffect::getStringAnnotationValue) instead of a plain value buffer.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter, for example, you can use getParameterAnnotation to get a valid annotation handle.
See also:
CgFxEffect::getAnnotationValueSize

NVSG_API bool getFloatAnnotationValue | ( | CgFxAnnotation | anno,
 |  | float * | value
 | ) | const

Returns the value of a float-type annotation.

Parameters:
anno | Handle to the float-type annotation to get the value from.
value | Pointer to a float buffer that will receive the annotation value.
Returns:
The function returns true if the value successfully could have copied to the value buffer. Otherwise, the function returns false.
Remarks:
The function is dedicated to be used with float-type annotations only. The function returns false if it is called for other than float-type annotations. Use CgFxEffect::isFloatAnnotation to determine whether the annotation is a float-type annotation.

The caller must provide a buffer large enough to hold the annotation value. Use either CgFxEffect::getNumberOfAnnotationValueComponents or CgFxEffect::getAnnotationValueSize to determine the required size for the buffer to receive the value.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter, for example, you can use getParameterAnnotation to get a valid annotation handle.

The behavior also is undefined if either the pointer to the value buffer is invalid, or the buffer behind is not large enough to hold the annotation value.
See also:
CgFxEffect::isFloatAnnotation, CgFxEffect::getNumberOfAnnotationValueComponents, CgFxEffect::getAnnotationValueSize

NVSG_API bool getIntAnnotationValue | ( | CgFxAnnotation | anno,
 |  | int * | value
 | ) | const

Returns the value of a integer-type annotation.

Parameters:
anno | Handle to the integer-type annotation to get the value from.
value | Pointer to an integer buffer that will receive the annotation value.
Returns:
The function returns true if the value successfully could have copied to the value buffer. Otherwise, the function returns false.
Remarks:
The function is dedicated to be used with integer-type annotations only. The function returns false if it is called for other than integer-type annotations. Use CgFxEffect::isIntAnnotation to determine whether the annotation is an integer-type annotation.

The caller must provide a buffer large enough to hold the annotation value. Use either CgFxEffect::getNumberOfAnnotationValueComponents or CgFxEffect::getAnnotationValueSize to determine the required size for the buffer to receive the value.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter, for example, you can use getParameterAnnotation to get a valid annotation handle.

The behavior also is undefined if either the pointer to the value buffer is invalid, or the buffer behind is not large enough to hold the annotation value.
See also:
CgFxEffect::isIntAnnotation, CgFxEffect::getNumberOfAnnotationValueComponents, CgFxEffect::getAnnotationValueSize

NVSG_API bool getBoolAnnotationValue | ( | CgFxAnnotation | anno,
 |  | int * | value
 | ) | const

Returns the value of a boolean-type annotation.

Parameters:
anno | Handle to the boolean-type annotation to get the value from.
value | Pointer to an integer buffer that will receive the annotation value.
Returns:
The function returns true if the value successfully could have copied to the value buffer. Otherwise, the function returns false.
Remarks:
The function is dedicated to be used with boolean-type annotations only. The function returns false if it is called for other than boolean-type annotations. Use CgFxEffect::isBoolAnnotation to determine whether the annotation is a boolean-type annotation.

The caller must provide a buffer large enough to hold the annotation value. Use either CgFxEffect::getNumberOfAnnotationValueComponents or CgFxEffect::getAnnotationValueSize to determine the required size for the buffer to receive the value. Keep in mind that a boolean in this context is a 32-bit integer value!

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter, for example, you can use getParameterAnnotation to get a valid annotation handle.

The behavior also is undefined if either the pointer to the value buffer is invalid, or the buffer behind is not large enough to hold the annotation value.
See also:
CgFxEffect::isBoolAnnotation, CgFxEffect::getNumberOfAnnotationValueComponents, CgFxEffect::getAnnotationValueSize

NVSG_API bool getStringAnnotationValue | ( | CgFxAnnotation | anno,
 |  | std::string & | value
 | ) | const

Returns the value of a string-type annotation.

Parameters:
anno | Handle to the string-type annotation to get the value from.
value | Reference to a STL string that receives the value
Returns:
The function returns true if the string value could have assigned to value. Otherwise, the function returns false.
Remarks:
The function is dedicated to be used with string-type annotations only. The function returns false if it is called for other than string-type annotations. Use CgFxEffect::isStringAnnotation to determine whether the annotation is a string-type annotation.

Calling this function for an invalid annotation handle results in undefined runtime behavior. For an effect parameter, for example, you can use getParameterAnnotation to get a valid annotation handle.
See also:
CgFxEffect::isStringAnnotation

NVSG_API const std::string& getParameterName ( CgFxParameter param ) const

Returns the name of the specified effect parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns a reference to a const STL string that holds the parameter name.
Remarks:
The parameter name will be received as specified in the CgFX sources.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getTweakable, CgFxEffect::getParameterByName, CgFxEffect::getParameterBySemantic

NVSG_API const std::string& getParameterSemantic ( CgFxParameter param ) const

Returns the semantic of the specified effect parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns a reference to a const STL string that holds the semantic.
Remarks:
The parameter semantic will be received as specified in the CgFX sources.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getTweakable, CgFxEffect::getParameterByName, CgFxEffect::getParameterBySemantic

NVSG_API const std::string& getParameterTypeString ( CgFxParameter param ) const

Returns the type of the specified parameter as string.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns a reference to a const STL string that holds the type string. For a float4-type parameter, for example, this would be "float4".
Remarks:
Each parameter is of a certain type. Use this function if you need this type as a string.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getTweakable, CgFxEffect::getParameterByName, CgFxEffect::getParameterBySemantic

NVSG_API CgFxParameter getParameterByName ( const std::string & name ) const

Returns an effect parameter by name.

Parameters:
name Reference to a const STL string that holds the name of the parameter to retrieve.
Returns:
The function returns a valid parameter handle if a parameter with the specified name was found in the effect. Otherwise, NULL is returned to indicate that an effect parameter with the specified name could not be found.
Remarks:
The function case-sensitive looks up the effect parameter by its name.

The parameters of an effect can be retrieved directly by name using this function. The names of the parameters in an effect can be discovered by iterating through the effect parameters (see e.g. CgFxEffect::getNumberOfTweakables and CgFxEffect::getTweakable), and calling CgFxEffect::getParameterName for each parameter in turn.
Example:
The parameter name does not have to be a complete name for a leaf node parameter. For example, if you have a CgFX effect with the following parameters:
 struct FooStruct
 {
     float4 A;
     float4 B;
 };

 struct BarStruct
 {
     FooStruct Foo[2];
 };

 BarStruct Bar[3];
The following leaf-node parameters will be generated:
 Bar[0].Foo[0].A
 Bar[0].Foo[0].B
 Bar[0].Foo[1].A
 Bar[0].Foo[1].B
 Bar[1].Foo[0].A
 Bar[1].Foo[0].B
 Bar[1].Foo[1].A
 Bar[1].Foo[1].B
 Bar[2].Foo[0].A
 Bar[2].Foo[0].B
 Bar[2].Foo[1].A
 Bar[2].Foo[1].B
A handle to any of the non-leaf arrays or structs can be directly obtained by using the appropriate name. The following are a few examples of valid names that may be used with CgFxEffect::getParameterByName given the above example CgFX effect:
 "Bar"
 "Bar[1]"
 "Bar[1].Foo"
 "Bar[1].Foo[0]"
 "Bar[1].Foo[0].B"
 ...
See also:
CgFxEffect::getNumberOfTweakables, CgFxEffect::getTweakable

NVSG_API CgFxParameter getParameterBySemantic ( const std::string & semantic ) const

Returns an effect parameter by semantic.

Parameters:
semantic Reference to a const STL string that holds the semantic of the parameter to retrieve.
Returns:
The function returns a valid parameter handle if a matching effect parameter was found. Otherwise, NULL is returned to indicate that an effect parameter with the specified semantic could not be found.
Remarks:
The function case-sensitive looks up the effect parameter by it's semantic string.
See also:
CgFxEffect::getParameterByName

NVSG_API unsigned int getNumberOfArrayParameterElements ( CgFxParameter param ) const

Returns the array size of the specified array parameter.

Parameters:
param Handle to the array parameter to query.
Returns:
The function returns the number of array elements - that is,the size of the array.
Remarks:
This function in conjunction with CgFxEffect::getArrayParameterElement can be used to iterate through the elements of an array parameter.

Calling this function for other than array parameters results in undefined behavior. Use CgFxEffect::isArrayParameter to determine whether the parameter is an array parameter.
See also:
CgFxEffect::getArrayParameterElement

NVSG_API CgFxParameter getArrayParameterElement | ( | CgFxParameter | param,
 |  | unsigned int | index
 | ) | const

Returns the array element at a specified zero-based index.

Parameters:
param | Handle to the array parameter to retrieve the specified element from.
index | Zero-based index of the array element to retrieve.
Returns:
The function returns a handle to the index-th element of the specified array parameter.
Remarks:
Use this function to get the single elements of the specified array parameter. You should use this function always in conjunction with CgFxEffect::getNumberOfArrayParameterElements to avoid passing an invalid element index to the function. Passing an invalid index - that is, an index greater or equal to what CgFxEffect::GetNumberOfArrayParameterElements returns - results in undefined runtime behavior.

Calling this function for other than array parameters also results in undefined behavior. Use CgFxEffect::isArrayParameter to determine whether the parameter is an array parameter.
See also:
CgFxEffect::getArrayParameterElement, CgFxEffect::GetNumberOfArrayParameterElements

NVSG_API unsigned int getNumberOfStructParameterMembers ( CgFxParameter param ) const

Returns the number of members for the specifies struct parameter.

Parameters:
param Handle to the struct parameter to query.
Returns:
The function returns the number of struct members
Remarks:
This function in conjunction with CgFxEffect::getStructParameterMember supports iterating through the members of a struct parameter. For direct access to a named struct parameter it is recommend to use CgFxEffect::getStructParameterMemberByName instead.

Calling this function for others than struct parameters results in undefined behavior. Use CgFxEffect::isStructParameter to determine whether the parameter is a struct parameter.
See also:
CgFxEffect::getStructParameterMember, CgFxEffect::getStructParameterMemberByName

NVSG_API CgFxParameter getStructParameterMember | ( | CgFxParameter | param,
 |  | unsigned int | index
 | ) | const

Returns the struct member at a specified zero-based index.

Parameters:
param | Handle to the struct parameter from which to retrieve the member.
index | Zero-based index of the struct member.
Returns:
The function returns a handle to the index-th struct member.
Remarks:
Use this function together with CgFxEffect::getNumberOfStructParameterMembers to iterate through a struct parameter's members. Note that the function does not guarantee to preserve the order of struct members as specified in the struct definition. For direct access to a named struct parameter it is recommended to use CgFxEffect::getStructParameterMemberByName instead.

Calling this function for others than struct parameters results in undefined behavior. Use CgFxEffect::isStructParameter to determine whether the parameter is a struct parameter.

Passing an invalid index to the function also results in undefined behavior. Use CgFxEffect::getNumberOfStructParameterMembers to determine a valid range for the index to pass.
See also:
CgFxEffect::getNumberOfStructParameterMembers, CgFxEffect::getStructParameterMemberByName

NVSG_API CgFxParameter getStructParameterMemberByName | ( | CgFxParameter | param,
 |  | const std::string & | member
 | ) | const

Returns a struct member by name.

Parameters:
param | Handle to the struct parameter to retrieve the member from.
member | Name of the struct member to retrieve.
Returns:
The function returns a valid parameter handle to the to the struct member if the look-up was successful. Otherwise, the function returns NULL to indicate that a member with the specified name does not exist for the struct parameter.
Remarks:
The function case-sensitive looks up the struct member by name. Note that names of struct members need to be fully qualified to successfully look up the member!

To retrieve the names of a struct parameter's members you can iterate through the members of a struct parameter using CgFxEffect::getNumberOfStructParameterMembers and CgFxEffect::getStructParameterMember, and then call CgFxEffect::getParameterName for each in turn.

Calling this function for other than struct parameters results in undefined behavior. Use CgFxEffect::isStructParameter to determine whether the parameter is a struct parameter.
Example:
If a struct type is defined as follows:
 struct FooStruct
 {
     float4 a;
     float3 b;
 };
And you have defined a parameter of type FooStruct as follows:
 FooStruct foo;
The right way to look up the member 'b' would be to fully qualify its name:

 CgFxParameter fooB = effect->getStructParameterMemberByName(param, "foo.b");

Equivalent for an array of FooStructs:

 FooStruct bar[5];

The right way to look up the member 'b' of the first array element would be again to fully qualify its name:

 CgFxParameter barB = effect->getStructParameterMemberByName(param, "bar[0].b");

See also:
CgFxEffect::getNumberOfStructParameterMembers, CgFxEffect::getStructParameterMember

NVSG_API unsigned int getParameterValueSize ( CgFxParameter param ) const

Returns the size in bytes of the parameter value.

Parameters:
param Handle to the parameter to retrieve the value size from.
Returns:
The function returns the size in bytes of the parameter value.
Remarks:
To get parameter values, the caller needs to provide a buffer large enough to receive the value. Use this function to determine the amount of bytes the parameter value consumes. Alternatively you can use CgFxEffect::getNumberOfParameterValueComponents together with the parameter's type information (e.g. CgFxEffect::isFloatParameter, or CgFxEffect::isIntParameter) to determine what size the receiving buffer needs to be.

Note that only leaf parameters have a value. For example, a struct parameter has no concrete value (hence, CgFxEffect::getParameterValueSize would return 0) but the struct members, if they are leaf parameters, have a value.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getNumberOfParameterValueComponents

NVSG_API unsigned int getNumberOfParameterValueComponents ( CgFxParameter param ) const

Returns the number of components the parameter value has. Returns the number of components the parameter value has.

Parameters:
param Handle to the parameter to query
Returns:
The function returns the number of components the parameter value has. A parameter of type float4, for example, has 4 value components.
Remarks:
This function makes sense for numerical parameters only, as they can have multiple components (e.g. vectors or matrices).

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getParameterValueSize

NVSG_API bool isScalarParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a scalar-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a scalar-type parameter, that is - a single component, numerical type. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isVector2Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 2-component vector-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 2-component vector-type parameter, that is - a 2-component, numerical type. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isVector3Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 3-component vector-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 3-component vector-type parameter, that is - a 3-component, numerical type. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isVector4Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 4-component vector-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 4-component vector-type parameter, that is - a 4-component, numerical type. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix22Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 2x2 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 2x2 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix23Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 2x3 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 2x3 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix24Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 2x4 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 2x4 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix32Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 3x2 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 3x2 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix33Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 3x3 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 3x3 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix34Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 3x4 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 3x4 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix42Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 4x2 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 4x2 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix43Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 4x3 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 4x3 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMatrix44Parameter ( CgFxParameter param ) const

Returns whether the specified parameter is a 4x4 matrix-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a 4x4 matrix-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isFloatParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a float-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a float-type parameter (e.g. float, float2, float3, float4x4, ...). Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isIntParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a integer-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a integer-type parameter (e.g. int, int2, int4x4, ...). Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isBoolParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a boolean-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a integer-type parameter (e.g. bool, bool2, bool4x4, ...). Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isStringParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a string-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a string-type parameter. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isSamplerParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a sampler-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a sampler-type parameter, that is - either sampler1D, sampler2D, sampler3D, samplerRECT, or sampleCUBE. Otherwise, the function returns false.
Remarks:
A sampler in Cg refers to an external object that Cg can sample, such as a texture.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isSampler1DParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a sampler1D-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a sampler1D-type parameter. Otherwise, the function returns false.
Remarks:
A sampler in Cg refers to an external object that Cg can sample, such as a texture. The 1D suffix for the sampler1D type indicates that the texture is a conventional one-dimensional texture.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isSampler2DParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a sampler2D-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a sampler2D-type parameter. Otherwise, the function returns false.
Remarks:
A sampler in Cg refers to an external object that Cg can sample, such as a texture. The 2D suffix for the sampler2D type indicates that the texture is a conventional two-dimensional texture.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isSampler3DParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a sampler3D-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a sampler3D-type parameter. Otherwise, the function returns false.
Remarks:
A sampler in Cg refers to an external object that Cg can sample, such as a texture. The 3D suffix for the sampler2D type indicates that the texture is a conventional three-dimensional texture.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isSamplerRectParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a samplerRECT-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a samplerRECT-type parameter. Otherwise, the function returns false.
Remarks:
A sampler in Cg refers to an external object that Cg can sample, such as a texture. The RECT suffix for the samplerRECT type indicates that the texture is a rectangular (non-power-of-two) texture.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isSamplerCubeParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a samplerCUBE-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a samplerCUBE-type parameter. Otherwise, the function returns false.
Remarks:
A sampler in Cg refers to an external object that Cg can sample, such as a texture. The CUBE suffix for the samplerCUBE type indicates that the texture is a cube map.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isSamplerArrayParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a sampler array type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a sampler array. Otherwise, the function returns false.
Remarks:
A sampler in Cg refers to an external object that Cg can sample, such as a texture. Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isLightParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a NVSGLight-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a NVSGLight-type parameter. Otherwise, the function returns false.
Remarks:
Only parameters of type NVSGLight will be recognized as light parameters. The NVSGLight type is defined in the file NVSGLight.cg under media/effects/include.

Light parameters, if detected, will be automatically bound to the nvsg::LightSource objects inside the actual render tree. Hence, the effect lights will change as the tree lights change.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isLightArrayParameter ( CgFxParameter param ) const

Returns whether the specified parameter specifies an array of NVSGLight-type parameters.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter specifies an array of NVSGLight-type parameters. Otherwise, the function returns false.
Remarks:
You can use CgFxEffect::getNumberOfArrayParameterElements to determine the size of a light array. Use CgFxEffect::getArrayParameterElement to iterate the single light parameters inside a light array. Note that NVSG does not handle arrays of light arrays!

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isMaterialParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a NVSGMaterial-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if param is a NVSGMaterial-type parameter. Otherwise, the function returns false.
Remarks:
Only parameters of type NVSGMaterial will be recognized as material parameters. The NVSGMaterial type is defined in the file NVSGMaterial.cg under media/effects/include.

A material parameter, if detected, will be automatically bound to the corresponding nvsg::Material that was assigned to the same geometry the effect is applied to.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.

NVSG_API bool isSceneParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a NVSGScene-type parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if param is a NVSGScene-type parameter. Otherwise, the function returns false.
Remarks:
Only parameters of type NVSGScene will be recognized as Scene parameters. The NVSGScene type is defined in the file NVSGScene.cg under media/effects/include.

A Scene parameter, if detected, will be automatically bound to the Scene's ambient color.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
Scene::setAmbientColor Scene::getAmbientColor

NVSG_API bool isTransformParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a transform parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a transform parameter. Otherwise the function returns false.
Remarks:
For NVSG an effect parameter is recognized as a transform parameter only if it is a float4x4 parameter and has one of the semantics listed in the following table:
Semantic | Meaning
World, Model | object space to world space
View | world space to eye space
Projection | eye space to clip space
WorldT, ModelT, WorldTranspose, ModelTranspose | object space to world space (transposed matrix)
ViewT, ViewTranspose | world space to eye space (transposed matrix)
ProjectionT ProjectionTranspose | eye space to clip space (transposed matrix)
WorldI, ModelI, WorldInverse, ModelInverse | world space to object space
ViewI, ViewInverse | eye space to world space
ProjectionI, ProjectionInverse | clip space to eye space
WorldIT, ModelIT, WorldInverseTranspose, ModelInverseTranspose | world space to object space (transposed matrix)
ViewIT, ViewInverseTranspose | eye space to world space (transposed matrix)
ProjectionIT, ProjectionInverseTranspose | clip space to eye space (transposed matrix)
WorldView, ModelView | object space to eye space
WorldViewProjection, ModelViewProjection | object space to clip space
WorldViewT, ModelViewT, WorldViewTranspose, ModelViewTranspose | object space to eye space (transposed matrix)
WorldViewProjectionT, ModelViewProjectionT, WorldViewProjectionTranspose, ModelViewProjectionTranspose | object space to clip space (transposed matrix)
WorldViewI, ModelViewI, WorldViewInverse, ModelViewInverse | eye space to object space
WorldViewProjectionI, ModelViewProjectionI, WorldViewProjectionInverse, ModelViewProjectionInverse | clip space to object space
WorldViewIT, ModelViewIT, WorldViewInverseTranspose, ModelViewInverseTranspose | eye space to object space (transposed matrix)
WorldViewProjectionIT, ModelViewProjectionIT, WorldViewProjectionInverseTranspose, ModelViewProjectionInverseTranspose | clip space to object space (transposed matrix)

NVSG_API bool isArrayParameter ( CgFxParameter param ) const

Returns whether the specified parameter is an array parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is an array parameter. Otherwise, the function returns false.
See also:
CgFxEffect::getNumberOfArrayParameterElements, CgFxEffect::getArrayParameterElement

NVSG_API bool isStructParameter ( CgFxParameter param ) const

Returns whether the specified parameter is a struct parameter.

Parameters:
param Handle to the parameter to query.
Returns:
The function returns true if the specified parameter is a struct parameter. Otherwise the function returns false.
See also:
CgFxEffect::getNumberOfStructParameterMembers, CgFxEffect::getStructParameterMember, CgFxEffect::getStructParameterMemberByName

NVSG_API unsigned int getNumberOfTransforms ( ) const

Returns the number of transform parameters available.

Returns:
The function returns the number transform parameters available for this effect.
Remarks:
See the documentation on CgFxEffect::isTransformParameter for a more detailed description about transform parameters.

Use this function together with CgFxEffect::getTransform to iterate through all available transform parameters of this effect.

NVSG_API CgFxParameter getTransform ( unsigned int index ) const

Returns the transform parameter at the specified zero-based index. Returns the transform parameter at the specified zero-based index.

Parameters:
index Zero-based index of the transform parameter to retrieve.
Returns:
The function returns a handle to the index-th transform parameter.
Remarks:
This function is particularly useful when iterating through transform parameters.

Passing an invalid index results in undefined behavior. Use CgFxEffect::getNumberOfTransforms to determine a valid range for the indices to pass.
Example:
 void printTransformSemantics(const CgFxEffect * effect)
 {
   unsigned int numTrafos = effect->getNumberOfTransforms();
   for ( unsigned int i=0; i<numTrafos; ++i )
   {
       CgFxParameter trafo = effect->getTransform(i);
       printf( "%s %s : %s\n"
             , getParameterTypeString().c_str()
             , getParameterName().c_str()
             , getParameterSemantic().c_str() );
   }
 }
See also:

NVSG_API TransformType getTransformType ( CgFxParameter param ) const

Returns the transform type of the specified transform parameter.

Parameters:
param Handle to the transform parameter to query.
Returns:
The function returns a CgFxEffect::TransformType enum that indicates what kind of transform the parameter specifies.
Remarks:
The transform type of a transform parameter is tightly related to its semantic. For example, a renderer needs this information to always upload the correct state matrix to the underlying effect resource. See the documentation on CgFxEffect::isTransformParameter for a more detailed description about transform parameters.

The behaviour is undefined if this function is called for a non-transform parameter.

NVSG_API bool setTransformValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Uploads a 4x4 transform matrix to the underlying effect resource.

Parameters:
param | Handle to the transform parameter.
value | Pointer to the 16 32-bit float values to upload.
Returns:
The function return true if the matrix upload was successful. Otherwise the function returns false.
Remarks:
The function copies 16 32-bit float values from the buffer pointed to by value to the underlying effect resource.

Calling this function for other than transform parameters results in undefined behavior. Use CgFxEffect::isTransformParameter to test whether a certain parameter is a transform parameter.

The runtime behavior also is undefined if value specifies an invalid pointer.

NVSG_API unsigned int getNumberOfTweakables ( ) const

Returns the number of alterable effect parameters (so called 'tweakables').

Returns:
The function returns the number of tweakables available for this effect.
Remarks:
Tweakables are all alterable effect parameters that will not be automatically updated by the NVSG framework but need to be manually updated as wanted. For example, light or material parameters (see CgFxEffect::isLightParameter and CgFxEffect::isMaterialParameter) will be automatically updated by the NVSG framework every frame, and hence, are not recognized as tweakables. Same is true for transform parameters (see CgFxEffect::isTransformParameter).

An application can offer a graphical user interface that allows for manipulating the tweakable values manually.

NVSG_API CgFxParameter getTweakable ( unsigned int index ) const

Returns the tweakable at the specified zero-based index.

Parameters:
index Zero-based index of the tweakable to retrieve.
Returns:
The function returns a valid handle to the index-th tweakable.
Remarks:
This function is particularly useful when iterating through all tweakables available for this effect.

Passing an invalid index results in undefined behavior. Use CgFxEffect::getNumberOfTweakables to determine a valid range for the indices to pass.

NVSG_API CgFxParameter getTweakableBySemantic ( const std::string & semantic ) const

Returns a tweakable effect parameter by semantic.

Parameters:
semantic Semantic string used to look up the tweakable.
Returns:
The function returns a valid handle to the tweakable with the specified semantic, if found. Otherwise, the function returns NULL, to indicate that a tweakable with that semantic does not exist.
Remarks:
A tweakable can be directly accessed by its semantic. This function case-sensitive looks up the tweakable by it's semantic string.

NVSG_API CgFxParameter getTweakableByName ( const std::string & name ) const

Returns a tweakable effect parameter by name.

Parameters:
name Name string used to look up the tweakable.
Returns:
The function returns a valid handle to the tweakable with the specified name, if found. Otherwise, the function returns NULL, to indicate that a tweakable with that name does not exist.
Remarks:
A tweakable can be directly accessed by its name. This function case-sensitive looks up the tweakable by it's name string.

NVSG_API unsigned int getNumberOfLights ( ) const

Returns the number of effect lights available.

Returns:
The function returns the number of light parameters available.
Remarks:
Use this function in conjunction with CgFxEffect::getLight to iterate through all recognized effect lights. See the documentation CgFxEffect::isLightParameter for a more detailed description of light parameters.

NVSG_API CgFxParameter getLight ( unsigned int index ) const

Returns the light parameter at a specified zero-based index.

Parameters:
index Zero-based index of the light parameter to retrieve.
Returns:
The functions returns a valid handle to the index-th light parameter.
Remarks:
This function is particularly useful when iterating through light parameters.

Passing an invalid index results in undefined behavior. Use CgFxEffect::getNumberOfLights to determine a valid range for the indices to pass.
Example:
 const CgFxEffect * effect;
 //...
 // assume a valid read-locked effect here
 unsigned int numLights = effect->getNumberOfLigths();
 for ( unsigned int i=0; i<numLights; ++i )
 {
     // get i-th light from the effect
     CgFxParameter light = effect->getLight(i);
     // proceed with i-th light parameter
     // ...
 }
See also:
CgFxEffect::getNumberOfLights

NVSG_API CgFxParameter getLightBySemantic ( const std::string & semantic ) const

Returns a light parameter by semantic.

Parameters:
semantic Semantic string used to look up the light parameter.
Returns:
The function returns a valid handle to the light parameter with the specified semantic, if found. Otherwise, the function returns NULL, to indicate that a light parameter with that semantic does not exist.
Remarks:
A light parameter can be directly accessed by its semantic. This function case-sensitive looks up the light parameter by its semantic string.
See also:
CgFxEffect::isLightParameter

NVSG_API CgFxParameter getLightByName ( const std::string & name ) const

Returns a light parameter by name.

Parameters:
name Semantic string used to look up the light parameter.
Returns:
The function returns a valid handle to the light parameter with the specified name, if found. Otherwise, the function returns NULL, to indicate that a light parameter with that name does not exist.
Remarks:
A light parameter can be directly accessed by name. This function case-sensitive looks up the light parameter by name.
See also:
CgFxEffect::isLightParameter

NVSG_API CgFxParameter getMaterial ( ) const

Returns the effects material parameter if available.

Returns:
The function returns a valid handle to the material parameter, if available. Otherwise, the function returns NULL, to indicate that a material parameter is not available for this effect.
Remarks:
If an effect parameter is detected as material parameter (see CgFxEffect::isMaterialParameter), it will be automatically bound to the corresponding nvsg::Material that was assigned to the same geometry the effect is applied to.
See also:
nvsg::Material, CgFxEffect::isMaterialParameter

NVSG_API CgFxParameter getScene ( ) const

Returns the effects scene parameter if available.

Returns:
The function returns a valid handle to the NVSGScene parameter, if available. Otherwise, the function returns NULL, to indicate that a scene parameter is not available for this effect. Note that this is NOT the nvsg::Scene, but the NVSGScene data structure that may be defined in the effect!
Remarks:
If an effect parameter is detected as a scene parameter (see CgFxEffect::isSceneParameter), it will be automatically bound to the corresponding states in the nvsg::Scene.
See also:
nvsg::Scene, CgFxEffect::isSceneParameter

NVSG_API bool getParameterValueAsFloat | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns a numeric-type parameter value as 32-bit float values.

Parameters:
param | Handle to the parameter to retrieve the value from.
value | Pointer to the buffer that receives the float values.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise the function returns false.
Remarks:
This function lets you get a numerical parameter's value as float value regardless of what the real type of the numerical parameter is. This could save a lot of type-testing on numerical parameters where applicable.

The function returns the value in the buffer pointed to by value. The number of floats that will be copied to value corresponds to the number of value components for the specified numeric-type parameter. The caller must provide a buffer large enough to hold all the value components. Use CgFxEffect::getNumberOfParameterValueComponents to determine the required size for the output buffer. Note that the behavior is undefined if the buffer provided is not large enough to hold all the value components!

The function has no effect if called for a non-numeric-type parameter!

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getNumberOfParameterValueComponents

NVSG_API bool setParameterValueAsFloat | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the value of a numeric-type parameter as 32-bit float value.

Parameters:
param | Handle to the parameter for which to set the value.
value | Pointer to the buffer from which to read the new values.
Returns:
The function returns true if the parameter value could be updated successfully. Otherwise, the function returns false.
Remarks:
The function lets you set the value for an arbitrary numerical parameter as 32-bit floating point numbers. This probably could save you a lot of type-checking where applicable.

The function uploads the 32-bit float values from the buffer pointed to by value to the underlying effect resource.

The number of floats that will be copied from value corresponds to the number of value components for the specified numeric-type parameter. Use CgFxEffect::getNumberOfParameterValueComponents to determine how many components the specified parameter has.

The function has no effect if called for a non-numeric-type parameter!

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getNumberOfParameterValueComponents

NVSG_API bool getFloatParameterValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the value of a float-type parameter.

Parameters:
param | Handle to the parameter from which to retrieve the value.
value | Pointer to a buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to retrieve the value of a float-type parameter. The function returns false if called for parameters other than float-type parameters to indicate that no values have been copied to the output buffer. Use CgFxEffect::isFloatParameter to test whether a certain parameter is a float-type parameter.

The number of floats that will be copied to value corresponds to the number of value components for the specified float-type parameter. The caller must provide a buffer large enough to hold all the value components. Use CgFxEffect::getNumberOfParameterValueComponents to determine the required size for the output buffer. Note that the behavior is undefined if the buffer provided is not large enough to hold all the value components!

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::setFloatParameterValue

NVSG_API bool setFloatParameterValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the value of a float-type parameter.

Parameters:
param | Handle to the parameter for which to set the value.
value | Pointer to a buffer from which to read the new value.
Returns:
The function returns true if the parameter value could be updated successfully. Otherwise, the function returns false.
Remarks:
Use this function to update the value of a float-type parameter. The function returns false if called for parameters other than float-type parameters to indicate that no values have been updated. Use CgFxEffect::isFloatParameter to test whether a certain parameter is a float-type parameter.

The number of floats that will be copied from value corresponds to the number of value components for the specified float-type parameter. Use CgFxEffect::getNumberOfParameterValueComponents to determine the number of value components for the specified parameter.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getFloatParameterValue

NVSG_API bool getIntParameterValue | ( | CgFxParameter | param,
 |  | int * | value
 | ) | const

Returns the value of a integer-type parameter.

Parameters:
param | Handle to the parameter from which to retrieve the value.
value | Pointer to a buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to retrieve the value of an integer-type parameter. The function returns false if called for parameters other than integer-type parameters to indicate that no values have been copied to the output buffer. Use CgFxEffect::isIntParameter to test whether a certain parameter is a integer-type parameter.

The number of integers that will be copied to value corresponds to the number of value components for the specified integer-type parameter. The caller must provide a buffer large enough to hold all the value components. Use CgFxEffect::getNumberOfParameterValueComponents to determine the required size for the output buffer. Note that the behavior is undefined if the buffer provided is not large enough to hold all the value components!

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::setIntParameterValue

NVSG_API bool setIntParameterValue | ( | CgFxParameter | param,
 |  | const int * | value
 | ) |

Sets the value of a integer-type parameter.

Parameters:
param | Handle to the parameter for which to set the value.
value | Pointer to a buffer from which to read the new value.
Returns:
The function returns true if the parameter value could be updated successfully. Otherwise, the function returns false.
Remarks:
Use this function to update the value of an integer-type parameter. The function returns false if called for parameters other than integer-type parameters to indicate that no values have been updated. Use CgFxEffect::isIntParameter to test whether a certain parameter is a integer-type parameter.

The number of integers that will be copied from value corresponds to the number of value components for the specified integer-type parameter. Use CgFxEffect::getNumberOfParameterValueComponents to determine the number of value components for the specified parameter.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getIntParameterValue

NVSG_API bool getBoolParameterValue | ( | CgFxParameter | param,
 |  | int * | value
 | ) | const

Returns the value of a 32-bit boolean-type parameter.

Parameters:
param | Handle to the parameter from which to retrieve the value.
value | Pointer to a buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to retrieve the value of a boolean-type parameter. The function returns false if called for parameters other than boolean-type parameters to indicate that no values have been copied to the output buffer. Use CgFxEffect::isBoolParameter to test whether a certain parameter is a boolean-type parameter.

The number of 32-bit booleans that will be copied to value corresponds to the number of value components for the specified boolean-type parameter. The caller is responsible for providing a buffer large enough to hold all the value components. Use CgFxEffect::getNumberOfParameterValueComponents to determine the required size for the output buffer. Note that the behavior is undefined if the buffer provided is not large enough to hold all the value components!

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::setBoolParameterValue

NVSG_API bool setBoolParameterValue | ( | CgFxParameter | param,
 |  | const int * | value
 | ) |

Sets the value of a 32-bit boolean-type parameter.

Parameters:
param | Handle to the parameter for which to set the value.
value | Pointer to a buffer from which to read the new value.
Returns:
The function returns true if the parameter value could be updated successfully. Otherwise, the function returns false.
Remarks:
Use this function to update the value of a boolean-type parameter. The function returns false if called for parameters other than boolean-type parameters to indicate that no values have been updated. Use CgFxEffect::isBoolParameter to test whether a certain parameter is a boolean-type parameter.

The number of 32-bit booleans that will be copied from value corresponds to the number of value components for the specified boolean-type parameter. Use CgFxEffect::getNumberOfParameterValueComponents to determine the number of value components for the specified parameter.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getBoolParameterValue

NVSG_API bool getStringParameterValue | ( | CgFxParameter | param,
 |  | std::string & | value
 | ) | const

Returns the string value of a string-type parameter.

Parameters:
param | Handle to the string-type parameter to query.
value | Reference to a STL string that receives the string value.
Returns:
The function returns true if the string could have been retrieved successfully. Otherwise the function returns false.
Remarks:
Use this function to retrieve the string from a string-type parameter. The function returns false if called for other parameters than string-type parameters to indicate that no string could have been retrieved. Use CgFxEffect::isStringParameter to test whether a certain parameter is a string-type parameter.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::setStringParameterValue

NVSG_API bool setStringParameterValue | ( | CgFxParameter | param,
 |  | const std::string & | value
 | ) |

Sets the string value for a string-type parameter.

Parameters:
param | Handle to the string-type parameter for which to set the string.
value | Reference to a STL string that holds the string to set.
Returns:
Use this function to update the string value of a string-type parameter. The function returns false if called for parameters other than string-type parameters to indicate that the parameter's string value has not been updated. Use CgFxEffect::isStringParameter to test whether a certain parameter is a string-type parameter.

Calling this function for an invalid parameter handle results in undefined runtime behavior. You can use CgFxEffect::getTweakable, CgFxEffect::getParameterByName, or CgFxEffect::getParameterBySemantic to get a valid handle to a certain effect parameter.
See also:
CgFxEffect::getStringParameterValue

NVSG_API void resetSceneValues ( CgFxParameter param )

Resets the specified Scene to default.

Parameters:
param Handle to the Scene to reset
Remarks:
Calling this function for other than Scene parameters results in undefined behavior. Use CgFxEffect::isSceneParameter to test whether a certain parameter is a Scene parameter.

NVSG_API bool getSceneAmbientValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the ambient RGBA intensity of the entire scene.

Parameters:
param | Handle to the Scene parameter.
value | Pointer to the buffer that receives four floating-point values that represent the ambient RGBA intensity.
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Typically, this value will track the Scene::Ambient color automatically. Calling this function for other than Scene parameters results in undefined behavior. Use CgFxEffect::isSceneParameter to test whether a certain parameter specifies a Scene parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating point values.
See also:
CgFxEffect::setSceneAmbientValue

Scene::setAmbientColor Scene::getAmbientColor

NVSG_API bool setSceneAmbientValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the ambient RGBA intensity of the entire scene.

Parameters:
param | Handle to the material.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise, the function returns false.
Remarks:
Typically, this value will track the Scene::Ambient color automatically. Calling this function for other than Scene parameters results in undefined behavior. Use CgFxEffect::isSceneParameter to test whether a certain parameter specifies a Scene parameter.
See also:
CgFxEffect::getSceneAmbientValue

Scene::setAmbientColor Scene::getAmbientColor

NVSG_API bool getSceneFrameNumberValue | ( | CgFxParameter | param,
 |  | int * | value
 | ) | const

Returns the scene frame number.

Parameters:
param | Handle to the Scene parameter.
value | Pointer to the buffer that receives the unsigned int
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Typically, this value will track the number of times the scene has been rendered automatically. Calling this function for other than Scene parameters results in undefined behavior. Use CgFxEffect::isSceneParameter to test whether a certain parameter specifies a Scene parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold a single 32-bit integer See notes in Scene::setFrameNumber for range issues with this value.
See also:
CgFxEffect::setSceneFrameNumberValue

Scene::setFrameNumber Scene::getFrameNumber

NVSG_API bool setSceneFrameNumberValue | ( | CgFxParameter | param,
 |  | const int * | value
 | ) |

Sets the current frame number.

Parameters:
param | Handle to the scene parameter.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise, the function returns false.
Remarks:
Typically, this value will track the Scene::FrameNumber automatically. Calling this function for other than Scene parameters results in undefined behavior. Use CgFxEffect::isSceneParameter to test whether a certain parameter specifies a Scene parameter. See notes in Scene::setFrameNumber for range issues with this value.
See also:
CgFxEffect::getSceneFrameNumberValue

Scene::setFrameNumber Scene::getFrameNumber

NVSG_API void resetMaterialValues ( CgFxParameter param )

Resets the specified material to default.

Parameters:
param Handle to the material to reset
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter is a material parameter.

NVSG_API bool getMaterialEmissionValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the RGBA emitted light intensity of the specified material.

Parameters:
param | Handle to the material.
value | Pointer to the buffer that receives four floating-point values that represent the RGBA emitted light intensity.
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating point values.
See also:
CgFxEffect::setMaterialEmissionValue

NVSG_API bool setMaterialEmissionValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the RGBA emitted light intensity for the specified material.

Parameters:
param | Handle to the material.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.
See also:
CgFxEffect::getMaterialEmissionValue

NVSG_API bool getMaterialAmbientValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the ambient RGBA reflectance of the specified material.

Parameters:
param | Handle to the material parameter.
value | Pointer to the buffer that receives four floating-point values that represent the ambient RGBA reflectance values.
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating point values.
See also:
CgFxEffect::setMaterialAmbientValue

NVSG_API bool setMaterialAmbientValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the ambient RGBA reflectance for the specified material.

Parameters:
param | Handle to the material.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.
See also:
CgFxEffect::getMaterialAmbientValue

NVSG_API bool getMaterialDiffuseValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the diffuse RGBA reflectance of the specified material.

Parameters:
param | Handle to the material.
value | Pointer to the buffer that receives four floating-point values that represent the diffuse RGBA reflectance values.
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating point values.
See also:
CgFxEffect::setMaterialDiffuseValue

NVSG_API bool setMaterialDiffuseValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the diffuse RGBA reflectance for the specified material.

Parameters:
param | Handle to the material.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.
See also:
CgFxEffect::getMaterialDiffuseValue

NVSG_API bool getMaterialSpecularValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the specular RGBA reflectance of the specified material.

Parameters:
param | Handle to the material.
value | Pointer to the buffer that receives four floating-point values that represent the specular RGBA reflectance values.
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating point values.
See also:
CgFxEffect::setMaterialSpecularValue

NVSG_API bool setMaterialSpecularValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the specular RGBA reflectance for the specified material.

Parameters:
param | Handle to the material.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.
See also:
CgFxEffect::getMaterialSpecularValue

NVSG_API bool getMaterialShininessValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the RGBA specular exponent of the specified material.

Parameters:
param | Handle to the material.
value | Pointer to a single float value that represents the specular exponent.
Returns:
The function returns true if the requested value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.

The behaviour also is undefined if value specifies an invalid pointer.
See also:
CgFxEffect::setMaterialShininessValue

NVSG_API bool setMaterialShininessValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the RGBA specular exponent for the specified material.

Parameters:
param | Handle to the material.
value | Pointer to a single float to read the input value from.
Returns:
The function returns true if the value could be updated successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than material parameters results in undefined behavior. Use CgFxEffect::isMaterialParameter to test whether a certain parameter specifies a material parameter.
See also:
CgFxEffect::getMaterialShininessValue

NVSG_API void resetLightValues ( CgFxParameter param )

Resets the values for the specified light to default.

Parameters:
param Handle to the light parameter to reset
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter is a material parameter.

NVSG_API bool getLightAmbientValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the ambient RGBA intensity of the specified light.

Parameters:
param | Handle to the light.
value | Pointer to the buffer that receives four floating-point values that represent the ambient RGBA intensity values.
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating point values.
See also:
CgFxEffect::setLightAmbientValue

NVSG_API bool setLightAmbientValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the ambient RGBA intensity for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightAmbientValue

NVSG_API bool getLightDiffuseValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the diffuse RGBA intensity of the specified light.

Parameters:
param | Handle to the light.
value | Pointer to the buffer that receives four floating-point values that represent the diffuse RGBA intensity values.
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating point values.
See also:
CgFxEffect::setLightDiffuseValue

NVSG_API bool setLightDiffuseValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the diffuse RGBA intensity for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightDiffuseValue

NVSG_API bool getLightSpecularValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the specular RGBA intensity of the specified light.

Parameters:
param | Handle to the light.
value | Pointer to the buffer that receives four floating-point values that represent the specular RGBA intensity values.
Returns:
The function returns true if the requested values could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating-point values.
See also:
CgFxEffect::setLightSpecularValue

NVSG_API bool setLightSpecularValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the specular RGBA intensity for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to the buffer to read the input values from.
Returns:
The function returns true if the values could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightSpecularValue

NVSG_API bool getLightPositionValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the position of the specified light.

Parameters:
param | Handle to the light
value | Pointer to the buffer that receives four floating-point values that represent the light position in homogeneous world coordinates.
Returns:
The function returns true if the light position could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating-point values.
See also:
CgFxEffect::setLightPositionValue

NVSG_API bool setLightPositionValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the position for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to a buffer of four floating-point values that represents the new light position in homogeneous world coordinates.
Returns:
The function returns true if the values could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightPositionValue

NVSG_API bool getLightDirectionValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the direction of the specified light.

Parameters:
param | Handle to the light
value | Pointer to the buffer that receives four floating-point values that represent the light direction in homogeneous world coordinates.
Returns:
The function returns true if the light direction could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if the output buffer pointed to by value is not large enough to hold four 32-bit floating-point values.
See also:
CgFxEffect::setLightDirectionValue

NVSG_API bool setLightDirectionValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the direction for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to a buffer of four floating-point values that represents the new light direction in homogeneous world coordinates.
Returns:
The function returns true if the values could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightDirectionValue

NVSG_API bool getLightSpotExponentValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the intensity distribution of the specified light.

Parameters:
param | Handle to the light
value | Pointer to the buffer that receives a single floating-point value that represents the intensity distribution of the light.
Returns:
The function returns true if the intensity distribution could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if value specifies an invalid pointer.
See also:
CgFxEffect::setLightSpotExponentValue

NVSG_API bool setLightSpotExponentValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the intensity distribution for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to a single float value that represents the new intensity distribution.
Returns:
The function returns true if the value could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightSpotExponentValue

NVSG_API bool getLightSpotCutoffValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the maximum spread angle of the specified light.

Parameters:
param | Handle to the light
value | Pointer to the buffer that receives a single floating-point value that represents the maximum spread angle of the light.
Returns:
The function returns true if the maximum spread angle could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if value specifies an invalid pointer.
See also:
CgFxEffect::setLightPosition

NVSG_API bool setLightSpotCutoffValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the maximum spread angle for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to a single float value that represents the new maximum spread angle.
Returns:
The function returns true if the value could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightSpotCutoffValue

NVSG_API bool getLightConstantAttenuationValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the constant attenuation factor of the specified light.

Parameters:
param | Handle to the light
value | Pointer to the buffer that receives a single floating-point value that represents the constant attenuation factor of the light.
Returns:
The function returns true if the constant attenuation factor could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if value specifies an invalid pointer.
See also:
CgFxEffect::setLightPosition

NVSG_API bool setLightConstantAttenuationValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the constant attenuation factor for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to a single float value that represents the constant attenuation factor.
Returns:
The function returns true if the value could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightConstantAttenuationValue

NVSG_API bool getLightLinearAttenuationValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the linear attenuation factor of the specified light.

Parameters:
param | Handle to the light
value | Pointer to the buffer that receives a single floating-point value that represents the linear attenuation factor of the light.
Returns:
The function returns true if the linear attenuation factor could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if value specifies an invalid pointer.
See also:
CgFxEffect::setLightPosition

NVSG_API bool setLightLinearAttenuationValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the linear attenuation factor for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to a single float value that represents the linear attenuation factor.
Returns:
The function returns true if the value could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightLinearAttenuationValue

NVSG_API bool getLightQuadraticAttenuationValue | ( | CgFxParameter | param,
 |  | float * | value
 | ) | const

Returns the quadratic attenuation factor of the specified light.

Parameters:
param | Handle to the light
value | Pointer to the buffer that receives a single floating-point value that represents the quadratic attenuation factor of the light.
Returns:
The function returns true if the quadratic attenuation factor could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.

The behaviour also is undefined if value specifies an invalid pointer.
See also:
CgFxEffect::setLightPosition

NVSG_API bool setLightQuadraticAttenuationValue | ( | CgFxParameter | param,
 |  | const float * | value
 | ) |

Sets the quadratic attenuation factor for the specified light.

Parameters:
param | Handle to the light.
value | Pointer to a single float value that represents the quadratic attenuation factor.
Returns:
The function returns true if the value could be updated successfully. Otherwise the function returns false.
Remarks:
Calling this function for other than light parameters results in undefined behavior. Use CgFxEffect::isLightParameter to test whether a certain parameter specifies a light parameter.
See also:
CgFxEffect::getLightQuadraticAttenuationValue

NVSG_API unsigned int getNumberOfSamplers ( ) const

Returns the number of sampler available.

Returns:
The function returns the number of samplers available for this effect.
Remarks:
This function in conjunction with CgFxEffect::getSampler is useful for iterating through the effect samplers.

NVSG_API CgFxParameter getSampler ( unsigned int index ) const

Returns the sampler at the specified zero-based index. Returns the sampler at the specified zero-based index.

Parameters:
index Zero-based index of the sampler.
Returns:
The function returns a handle to the requested sampler.
Remarks:
Passing an invalid index, that is - an index greater or equal to what CgFxEffect::getNumberOfSamplers returns results in undefined behavior.

NVSG_API CgFxParameter getSamplerByName ( const std::string & name ) const

Returns a sampler parameter by name.

Parameters:
name Name of the parameter to get.
Returns:
The function returns a handle to the sampler if found by name. Otherwise, the function returns NULL to indicate that a sampler with the specified name does not exist.
Remarks:
A sampler can be directly accessed by name using this function. The function case-sensitive looks up the sampler parameter by name.

NVSG_API CgFxParameter getSamplerByTextureParameterName ( const std::string & name ) const

Returns a sampler parameter by the name of its associated texture parameter.

Parameters:
name Name of the associated texture parameter.
Returns:
The function returns a handle to the requested sampler if the lookup was successful. Otherwise, the function returns NULL to indicate that no such sampler is available.
Remarks:
If in a CgFx source a texture parameter and a sampler parameter are defined as follows:
 texture environment
 <
     string FILE = "textures/myenv.dds"
 >;

 samplerCUBE environmentSampler = sampler_state
 {
     Texture = <environment>;
     MinFilter = LinearMipMapLinear;
     MagFilter = Linear;
     WrapS  = ClampToEdge;
     WrapT  = ClampToEdge;
 };
We call the sampler 'environmentSampler' to be associated with the texture 'environment'.
See also:
CgFxEffect::getSamplerTexture

NVSG_API CGparameter getSamplerTexture ( CgFxParameter param ) const

Returns the CGparameter handle that corresponds to the specified sampler parameter.

Parameters:
param Handle to the sampler.
Returns:
The function returns the CGparameter handle that corresponds to the specified sampler parameter.
Remarks:
A CGparameter handle sometimes is required for platform dependent calls that need to be executed, for example, from a certain renderer to pass platform dependent texture resources to the underlying effect or to manage platform dependent texture states. These platform dependent calls are not wrapped by NVSG, and hence, require the original Cg types instead of the NVSG wrapped types.

NVSG_API unsigned int getNumberOfProgramSamplers ( CgFxProgram prog ) const

Returns the number of samplers used in a particular program.

Returns:
The function returns the number of samplers in the given program.
Remarks:
This function in conjunction with CgFxEffect::getProgramSampler is useful for iterating through the samplers in a given program.

NVSG_API CgFxParameter getProgramSampler | ( | CgFxProgram | prog,
 |  | unsigned int | index
 | ) | const

Returns the sampler at the specified zero-based index in the given program. Returns the sampler at the specified zero-based index.

Parameters:
prog | Program (bound to this effect) to query.
index | Zero-based index of the sampler.
Returns:
The function returns a handle to the requested sampler.
Remarks:
Passing an invalid index, that is - an index greater or equal to what CgFxEffect::getNumberOfSamplers returns results in undefined behavior.

NVSG_API ProgramIOType getProgramInputType ( CgFxProgram prog ) const

Returns the input type for the given program.

This function is typically only useful for geometry programs, since the input and output to Vertex and Fragment programs are Vertices and Fragments. Hence, the return value for Vertex and Fragment programs will be PROGRAM_IO_VERTEX and PROGRAM_IO_FRAGMENT respectively.

The behavior is undefined if passed an invalid program.

Returns:
A ProgramIOType associated with this program.
See also:
ProgramIOType, CgFxEffect::getProgramOutputType

NVSG_API ProgramIOType getProgramOutputType ( CgFxProgram prog ) const

Returns the output type for the given program.

This function is typically only useful for geometry programs, since the input and output to Vertex and Fragment programs are Vertices and Fragments. Hence, the return value for Vertex and Fragment programs will be PROGRAM_IO_VERTEX and PROGRAM_IO_FRAGMENT respectively.

The behavior is undefined if passed an invalid program.

Returns:
A ProgramIOType associated with this program.
See also:
ProgramIOType, CgFxEffect::getProgramInputType

NVSG_API bool isMipmapSamplerState ( CgFxParameter sampler ) const

Returns whether the sampler state for the specified sampler requires mipmap generation.

Parameters:
sampler Specifies the sampler for which to query information.
Returns:
true if mipmap generation is required, false otherwise.
Remarks:
The function evaluates if the current MinFilter sampler state assignment requires mipmap generation for the assigned texture object. This is true if the MinFilter state is set to one of the following values: LinearMipMapNearest, NearestMipMapNearest, NearestMipMapLinear, LinearMipMapLinear
Note:
Calling this function for others than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter is a sampler parameter.
See also:
isSamplerParameter

NVSG_API bool isTextureImageSamplerCompliant | ( | CgFxParameter | sampler,
 |  | TextureImageHandle * | image
 | ) | const

Returns whether the indicated TextureImage is compliant to the specified sampler.

Parameters:
sampler | Handle to the sampler.
image | Specifies the TextureImage to test for compliance.
Returns:
The function returns true if the indicated TextureImage is compliant to the specified sampler, and hence, could be assigned to the sampler. Otherwise the function returns false.
Remarks:
A TextureImage that is not compliant to a given sampler cannot be assigned to that sampler. For example, a cube map TextureImage cannot be assigned to a Sampler2D. Doing so, would result in display corruption during rendering.

Calling this function for others than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter is a sampler parameter.
See also:
setSamplerTextureImage

NVSG_API bool setSamplerTextureImage | ( | CgFxParameter | param,
 |  | TextureImageHandle * | image
 | ) |

Assigns a new TextureImage to the specified sampler parameter.

Parameters:
param | Handle to the sampler.
image | Specifies the new TextureImage.
Returns:
The function returns true if the re-specification of the sampler's texture image was successful. Otherwise, the function returns false.
Remarks:
The function can be used to re-specify a sampler's texture image.
If the type of the passed through TextureImage doesn't match the sampler's type, or if the type is not convertible to a type matching the sampler's type, the current assignment remains unchanged, and the function returns false, to indicate an error. Use isTextureImageSamplerCompliant to obtain if a given TextureImage is compliant to a given sampler.
If the type of the new TextureImage matches the sampler's type, the new TextureImage will be assigned. If the new TextureImage is convertible to a type matching the sampler's type, the new TextureImage will be converted prior to assignment.
A previously assigned TextureImage will be unreferenced prior to assign the new TextureImage. If the previously assigned TextureImage is not referenced by any other objects, it will be destroyed as it gets unreferenced.

Calling this function for others than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter is a sampler parameter.
See also:
getSamplerTextureImage, isTextureImageSamplerCompliant, TextureImage

NVSG_API bool getSamplerTextureFileName | ( | CgFxParameter | param,
 |  | std::string & | file
 | ) | const

Returns the file name that is associated with the sampler's texture image.

Parameters:
param | Handle to the sampler.
file | Reference to a STL string that receives the requested file name.
Returns:
The function returns true if a file is associated with the sampler's texture image and the file name could have been successfully assigned to file. Otherwise the function returns false.
Remarks:
If a valid filename is associated with the sampler's texture image, the function returns the filename in the string object referenced by file. Use CgFxEffect::setSamplerTextureImageSpec to associate a file name with a sampler's texture image.
See also:
cgFxEffect::getSamplerTextureImage

NVSG_API TextureImageHandle* getSamplerTextureImage ( CgFxParameter param ) const

Returns the texture image assigned to the specified sampler parameter.

Parameters:
param Handle to the sampler.
Returns:
The function returns a pointer to the TextureImageHandle that is associated with the specified sampler.

The function returns NULL if there is no TextureImage associated with the sampler.
Remarks:
Use CgFxEffect::setSamplerTextureImageSpec to specify a certain textureImage with the sampler.

Calling this function for other than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter specifies a sampler parameter.

NVSG_API bool setSamplerTextureGPUFormat | ( | CgFxParameter | param,
 |  | TextureImage::TextureGPUFormat | format
 | ) |

Requests a particular texture GPU format that be used for this sampler.

Parameters:
param | Handle to the sampler.
format | The format from TextureGPUFormat enum.
Returns:
The function returns false if there is no texture associated with this parameter.
See also:
getSamplerTextureGPUFormat

NVSG_API bool getSamplerTextureGPUFormat | ( | CgFxParameter | param,
 |  | TextureImage::TextureGPUFormat & | format
 | ) |

Returns the texture GPU format that was requested of this sampler.

Parameters:
param | Handle to the sampler.
format | The returned format.
Returns:
The function returns the GPU format that was requested for this sampler. Note that the return value does not indicate the ACTUAL GPU format used, only the one that was requested.

The function returns false if there is no texture associated with this parameter.
See also:
setSamplerTextureGPUFormat

NVSG_API TextureTarget getSamplerTextureTarget ( CgFxParameter param ) const

Retrieves the TextureTarget for the specified sampler parameter.

Parameters:
param Handle to the Sampler to query.
Returns:
The function returns a TextureTarget specifier that indicates the texture target to which the assigned TextureImage should be bound by the renderer. The texture target for a certain sampler is determined by it's unambiguous type. This is read-only information and cannot be changed through the CgFxEffect API.
See also:
setSamplerTextureImage

NVSG_API unsigned int getNumberOfSamplerStateValueComponents | ( | CgFxParameter | param,
 |  | const std::string & | name
 | ) | const

Returns the number of components the specified named sampler state value has.

Parameters:
param | Handle to the sampler.
name | Specifies the name of the sampler state to query.
Returns:
The function returns the number of value components for the sampler state identified by name. If for the specified sampler the named state could not be found, the function returns 0.
Remarks:
This function is particularly useful when calculating the size of a certain sampler state's value. Together with the type information for the sampler state (e.g. CgFxEffect::isFloatSamplerState) this is an easy task: Calculating the size that a certain sampler state's value consumes is essential when querying the value (e.g. CgFxEffect::getFloatSamplerStateValue).

Calling this function for other than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter specifies a sampler parameter.

NVSG_API bool isFloatSamplerState | ( | CgFxParameter | param,
 |  | const std::string & | name
 | ) | const

Returns whether the specified sampler state is a float-type sampler state.

Parameters:
param | Handle to the sampler.
name | Specifies the name of the sampler state to query.
Returns:
The function returns true if the specified sampler state is a float-type sampler state. If the sampler state is of another type, or if the named sampler state is not defined for the sampler, the function returns false.
Remarks:
To query the current value of a certain sampler state, one need to know what type the sampler state is because corresponding query functions are type dependent (e.g. CgFxEffect::getFloatSamplerStateValue or CgFxEffect::getIntSamplerStateValue).

Calling this function for others than sampler parameter results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter specifies a sampler parameter.

NVSG_API bool isIntSamplerState | ( | CgFxParameter | param,
 |  | const std::string & | name
 | ) | const

Returns whether the specified sampler state is a integer-type sampler state.

Parameters:
param | Handle to the sampler.
name | Specifies the name of the sampler state to query.
Returns:
The function returns true if the specified sampler state is a integer-type sampler state. If the sampler state is of another type, or if the named sampler state is not defined for the sampler, the function returns false.
Remarks:
To query the current value of a certain sampler state, you need to know what type the sampler state is because corresponding query functions are type dependent (e.g. CgFxEffect::getIntSamplerStateValue or CgFxEffect::getFloatSamplerStateValue).

Calling this function for other than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter specifies a sampler parameter.

NVSG_API bool isBoolSamplerState | ( | CgFxParameter | param,
 |  | const std::string & | name
 | ) | const

Returns whether the specified sampler state is a boolean-type sampler state.

Parameters:
param | Handle to the sampler.
name | Specifies the name of the sampler state to query.
Returns:
The function returns true if the specified sampler state is a boolean-type sampler state. If the sampler state is of another type, or if the named sampler state is not defined for the sampler, the function returns false.
Remarks:
To query the current value of a certain sampler state, you need to know what type the sampler state is because corresponding query functions are type dependent (e.g. CgFxEffect::getBoolSamplerStateValue or CgFxEffect::getIntSamplerStateValue).

Calling this function for other than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter specifies a sampler parameter.

NVSG_API bool getFloatSamplerStateValue | ( | CgFxParameter | param,
 |  | const std::string & | name,
 |  | float * | value
 | ) | const

Returns the value of the specified float-type sampler state.

Parameters:
param | Handle to the sampler
name | Specifies the name of the sampler state to query.
value | Pointer to the buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to get hold of the the value of the float-type sampler state specified by name. The user must provide a buffer large enough to hold the value. The behavior is undefined if the buffer pointed to by value does not fulfill this requirement. You can call CgFxEffect::getNumberOfSamplerStateValueComponents to determine the number of components a certain sampler state value has. Together with the sampler state's type information (e.g. CgFxEffect::isFloatSamplerState) it is easy to calculate the right size for the receiving buffer.

The function has no effect if called for other than float-type sampler states! Use CgFxEffect::isFloatSamplerState to determine whether a certain sampler state is a float-type sampler state.

The value for a certain sampler state corresponds to the actual Cg 1.4 specification. More details regarding the Cg 1.4 specification can be found at http://developer.nvidia.com/page/cg_main.html

Note that sampler states are read-only. Hence, there is no corresponding function to modify a certain sampler state's value.

Calling this function for other than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter specifies a sampler parameter.
See also:
CgFxEffect::getIntSamplerStateValue, CgFxEffect::getBoolSamplerStateValue

NVSG_API bool getIntSamplerStateValue | ( | CgFxParameter | param,
 |  | const std::string & | name,
 |  | int * | value
 | ) | const

Returns the value of the specified integer-type sampler state.

Parameters:
param | Handle to the sampler
name | Specifies the name of the sampler state to query.
value | Pointer to the buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to get the value of the integer-type sampler state specified by name. The user must provide a buffer large enough to hold the value. The behavior is undefined if the buffer pointed to by value does not fulfill this requirement. You can call CgFxEffect::getNumberOfSamplerStateValueComponents to determine the number of components a certain sampler state value has. Together with the sampler state's type information (e.g. CgFxEffect::isIntSamplerState) it is easy to calculate the right size for the receiving buffer.

The function has no effect if called for other than integer-type sampler states! Use CgFxEffect::isIntSamplerState to determine whether a certain sampler state is a integer-type sampler state.

The value for a certain sampler state corresponds to the actual Cg 1.4 specification. More details regarding the Cg 1.4 specification can be found at http://developer.nvidia.com/page/cg_main.html

Note that sampler states are read-only. Hence, there is no corresponding function to modify a certain sampler state's value.

Calling this function for other than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter specifies a sampler parameter.
See also:
CgFxEffect::getFloatSamplerStateValue, CgFxEffect::getBoolSamplerStateValue

NVSG_API bool getBoolSamplerStateValue | ( | CgFxParameter | param,
 |  | const std::string & | name,
 |  | int * | value
 | ) | const

Returns the value of the specified 32-bit boolean-type sampler state.

Parameters:
param | Handle to the sampler
name | Specifies the name of the sampler state to query.
value | Pointer to the buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to get the value of the 32-bit boolean-type sampler state specified by name. The user must provide a buffer large enough to hold the value. The behavior is undefined if the buffer pointed to by value does not fulfill this requirement. You can call CgFxEffect::getNumberOfSamplerStateValueComponents to determine the number of components a certain sampler state value has. Together with the sampler state's type information (e.g. CgFxEffect::isBoolSamplerState) it is easy to calculate the right size for the receiving buffer.

The function has no effect if called for other than 32-bit boolean-type sampler states! Use CgFxEffect::isBoolSamplerState to determine whether a certain sampler state is a 32-bit boolean-type sampler state.

The value for a certain sampler state corresponds to the actual Cg 1.4 specification. More details regarding the Cg 1.4 specification can be found at http://developer.nvidia.com/page/cg_main.html

Note that sampler states are read-only. Hence, there is no corresponding function to modify a certain sampler state's value.

Calling this function for other than sampler parameters results in undefined behavior. Use CgFxEffect::isSamplerParameter to test whether a certain parameter specifies a sampler parameter.
See also:
CgFxEffect::getIntSamplerStateValue, CgFxEffect::getFloatSamplerStateValue

NVSG_API unsigned int getNumberOfTechniques ( ) const

Returns the number of techniques defined for this effect.

Returns:
The function returns the number of techniques defined for this effect.
Remarks:
Use this function together with CgFxEffect::getTechnique to iterate through all techniques defined for this effect.
Example:
 const CgFxEffect * effect;
 // ...
 // assume a valid read-locked effect here
 unsigned int numTechs = effect->getNumberOfTechniques();
 for ( unsigned int i=0; i<numTechs; ++i )
 {
     CgFxTechnique tech = effect->getTechnique(i);
     // proceed with the technique received ...
 }
See also:
CgFxEffect::setCurrentTechnique, CgFxEffect::validateCurrentTechnique

NVSG_API CgFxTechnique getTechnique ( unsigned int index ) const

Returns the technique at the specified zero-based index.

Parameters:
index Zero-based index of the technique to query.
Returns:
The function returns the index-th technique defined in the effect.
Remarks:
This function together with CgFxEffect::getNumberOfTechniques can be used to iterate through all techniques defined in the effect.

Calling this function with an invalid index, that is - an index greater or equal to what CgFxEffect::getNumberOfTechniques returns, results in undefined behavior.
See also:
CgFxEffect::getTechniqueByName

NVSG_API CgFxTechnique getTechniqueByName ( const std::string & name ) const

Returns a technique by name.

Parameters:
name Specifies the name of the technique to retrieve.
Returns:
If a technique with the specified name could be found in the effect, the function returns a valid handle to that technique. Otherwise, the function returns NULL.
Remarks:
A technique defined in an effect can be accessed directly by name. The names of the techniques defined in an effect can be discovered by iterating through all techniques using CgFxEffect::getNumberOfTechniques and CgFxEffect::getTechnique, and in turn calling CgFxEffect::getTechniqueName for each.
See also:
CgFxEffect::getTechnique

NVSG_API unsigned int getTechniqueIndex ( CgFxTechnique tech ) const

Returns the zero-based index of the specified technique.

Parameters:
tech Handle to the technique to query.
Returns:
The function returns the zero-based index of the specified technique if found. The function returns ~0 if the technique could not be found.
See also:
getTechnique

NVSG_API const std::string& getTechniqueName ( CgFxTechnique tech ) const

Returns the name of the specified technique.

Parameters:
tech Handle to the technique to query.
Returns:
The function returns a reference to a const STL string that holds the name of the technique.
Remarks:
Once a the name of a technique is determined, the technique can be directly accessed by its name using CgFxEffect::getTechniqueByName.

Calling this function for an invalid technique results in undefined behavior. Use either CgFxEffect::getTechnique or CgFxEffect::getTechniqueByName to get hold of valid techniques defined in the effect.

NVSG_API CgFxTechnique getCurrentTechnique ( ) const

Returns the current technique.

Returns:
The function returns a handle to the technique currently used for rendering.
Remarks:
The function returns the current technique used for rendering. Initially this is the first technique found in the effect. Use CgFxEffect::setCurrentTechnique to alter the current technique as wanted. Note that before using the current technique for rendering, it must be validated using CgFxEffect::validateCurrentTechniqe.

NVSG_API void setCurrentTechnique ( CgFxTechnique tech )

Sets the current technique to be used with rendering.

Parameters:
tech Handle to the technique to make current.
Remarks:
Before using the current technique for rendering, it must be validated using CgFxEffect::validateCurrentTechniqe.

Calling this function for an invalid technique results in undefined behavior. Use either CgFxEffect::getTechnique or CgFxEffect::getTechniqueByName to get hold of valid techniques defined in the effect.
See also:
CgFxEffect::getCurrentTechnique

NVSG_API bool validateCurrentTechnique ( )

Validates the current technique.

Returns:
The function returns true if the validation succeeded. Otherwise the function returns false.
Remarks:
Before using the current technique, it is important to validate it. A technique validation can fail if, for instance, for a fragment program an unsupported profile is used, or if the technique includes an unsupported state assignment.
See also:
CgFxEffect::setCurrentTechnique

NVSG_API unsigned int getNumberOfPasses ( CgFxTechnique tech ) const

Returns the number of render passes defined for the specified technique.

Parameters:
tech Handle to the technique to query.
Returns:
The function returns the number of passes defined for the specified technique.
Remarks:
A pass in CgFX defines, for example, what vertex and fragment programs should be applied, and what specific render states need to be assigned to achieve the desired render effect.

Use this function together with CgFxEffect::getPass to iterate through all passes defined in the specified technique.

Calling this function for an invalid technique results in undefined behavior. Use either CgFxEffect::getTechnique or CgFxEffect::getTechniqueByName to get hold of valid techniques defined in the effect.

NVSG_API CgFxPass getPass | ( | CgFxTechnique | tech,
 |  | unsigned int | index
 | ) | const

Returns the pass at the specified zero-based index defined in the specified technique.

Parameters:
tech | Handle to the technique to query.
index | Zero-based index of the pass to retrieve.
Returns:
The function returns a handle to the index-th pass defined in the specified technique.
Remarks:
A pass in CgFX defines, for example, what vertex and fragment programs should be applied, and what specific render states need to be assigned to achieve the desired render effect.

Calling this function for an invalid technique results in undefined behavior. Use either CgFxEffect::getTechnique or CgFxEffect::getTechniqueByName to get hold of valid techniques defined in the effect.

Passing an invalid index - that is, an index greater or equal to what CgFxEffect::getNumberOfPasses returns - also results in undefined behavior.

NVSG_API CgFxPass getPassByName | ( | CgFxTechnique | tech,
 |  | const std::string & | name
 | ) | const

Returns a pass of a specified technique by name.

Parameters:
tech | Handle to the technique to query.
name | Name of the pass to retrieve.
Returns:
If a pass with the specified name could be found in the specified technique, the function returns a valid handle to that pass. Otherwise, the function returns NULL.
Remarks:
A pass can be accessed directly by name. The names of all passes defined in a technique can be discovered by iterating through all passes using CgFxEffect::getNumberOfPasses and CgFxEffect::getPass, and in turn calling CgFxEffect::getPassName for each.

A pass in CgFX defines, for example, what vertex and fragment programs should be applied, and what specific render states need to be assigned to achieve the desired render effect.

Calling this function for an invalid technique results in undefined behavior. Use either CgFxEffect::getTechnique or CgFxEffect::getTechniqueByName to get valid techniques defined in the effect.

NVSG_API const std::string& getPassName ( CgFxPass pass ) const

Returns the name of the specified render pass.

Parameters:
pass Handle to the pass to query.
Returns:
The function returns a reference to a STL string that holds the name of the pass.
Remarks:
Once a the name of a pass is determined, the pass can be directly accessed by its name using CgFxEffect::getPassByName.

Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get hold of valid passes defined for a certain technique.

NVSG_API bool isTransparentPass ( CgFxPass pass ) const

Tests whether the specified pass forces transparency.

Parameters:
pass Handle to the pass to query
Returns:
The function returns true if the pass forces the respective geometry to appear transparent. Otherwise, the function returns false.
Remarks:
Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get valid passes defined for a certain technique.
See also:
CgFx::isTransparent

NVSG_API void applyPass ( unsigned int index )

Applies the specified render pass.

Parameters:
index Zero-based index of the pass of the current technique
Remarks:
The function applies all state assignments of the index-th pass of the current technique. The function must be called immediately before sending the geometry for that pass down the pipeline. After the geometry was sent you need to un-apply the pass by calling CgFxEffect::resetPass. This call sequence (apply-draw-reset) must be repeated for all passes available in the current technique. Passes must be applied in ascending order starting at the first pass (index 0).

Note that before applying the passes of the current technique, the current technique must be validated using CgFxEffect::validateCurrentTechnique.

Passing an invalid index - that is, an index greater or equal to what CgFxEffect::getNumberOfPasses for the current technique returns - results in undefined behavior.
Example:
 const CgFx * cgfx;
 // ...
 { // limit effect writable scope

   // assume a valid write-locked CgFx attribute here
   WritableObject<CgFxEffect> effect( cgfx->getEffect() );
   if ( effect->validateCurrentTechnique() )
   {
     // prepare the effect for rendering, that is
     // - setup all required textures (platform dependent), and
     // - update uniform transforms
     // ...

     // apply all the passes
     CgFxTechnique tech = effect->getCurrentTechnique();
     unsigned int numPasses = effect->getNumberOfPasses(tech);
     unsigned int currPass = 0;
     do
     {
         effect->applyPass(currPass);
         DrawGeometry(); // send geometry down the pipeline
         effect->resetPass(currPass);
     } while (++currPass < numPasses)
   }
 } // end writable scope
See also:
CgFxEffect::setCurrentTechnique

NVSG_API void resetPass ( unsigned int index )

Resets the specified render pass.

Parameters:
index Zero-based index of the pass of the current technique
Remarks:
The function resets all state assignments specified in the index-th pass of the current technique. This function should be called after the pass was applied and geometry was sent down the pipeline.

Passing an invalid index - that is, an index greater or equal to what CgFxEffect::getNumberOfPasses for the current technique returns - results in undefined behavior.
See also:
CgFxEffect::applyPass

NVSG_API unsigned int getNumberOfPassStateValueComponents | ( | CgFxPass | pass,
 |  | const std::string & | name
 | ) | const

Returns the number of components the specified pass state value has.

Parameters:
pass | Handle to the pass.
name | Specifies the name of the pass state to query.
Returns:
The function returns the number of value components for the pass state identified by name. If for the specified pass the named state could not be found, the function returns 0.
Remarks:
This function is particularly useful when calculating the size of a certain pass state's value. Together with the type information for the pass state (e.g. CgFxEffect::isFloatPassState) this is an easy task: Calculating the size that a certain pass state's value consumes is essential when querying the value (e.g. CgFxEffect::getFloatPassStateValue).

Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get hold of valid passes defined for a certain technique.

NVSG_API bool isFloatPassState | ( | CgFxPass | pass,
 |  | const std::string & | name
 | ) | const

Returns whether the specified pass state is a float-type pass state.

Parameters:
pass | Handle to the pass.
name | Specifies the name of the pass state to query.
Returns:
The function returns true if the specified pass state is a float-type pass state. If the pass state is of another type, or if the named pass state is not defined for the pass, the function returns false.
Remarks:
To query the current value of a certain pass state, one need to know what type the pass state is, because the corresponding query functions are type dependent (e.g. CgFxEffect::getFloatPassStateValue or CgFxEffect::getIntPassStateValue).

Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get hold of valid passes defined for a certain technique.

NVSG_API bool isIntPassState | ( | CgFxPass | pass,
 |  | const std::string & | name
 | ) | const

Returns whether the specified pass state is a integer-type pass state.

Parameters:
pass | Handle to the pass.
name | Specifies the name of the pass state to query.
Returns:
The function returns true if the specified pass state is a integer-type pass state. If the pass state is of another type, or if the named pass state is not defined for the pass, the function returns false.
Remarks:
To query the current value of a certain pass state, you need to know what type the pass state is, because the corresponding query functions are type dependent (e.g. CgFxEffect::getIntPassStateValue or CgFxEffect::getFloatPassStateValue).

Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get hold of valid passes defined for a certain technique.

NVSG_API bool isBoolPassState | ( | CgFxPass | pass,
 |  | const std::string & | name
 | ) | const

Returns whether the specified pass state is a 32-bit boolean-type pass state.

Parameters:
pass | Handle to the pass.
name | Specifies the name of the pass state to query.
Returns:
The function returns true if the specified pass state is a 32-bit boolean-type pass state. If the pass state is of another type, or if the named pass state is not defined for the pass, the function returns false.
Remarks:
To query the current value of a certain pass state, you need to know what type the pass state is, because the corresponding query functions are type dependent (e.g. CgFxEffect::getBoolPassStateValue or CgFxEffect::getFloatPassStateValue).

Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get hold of valid passes defined for a certain technique.

NVSG_API bool getFloatPassStateValue | ( | CgFxPass | pass,
 |  | const std::string & | name,
 |  | float * | value
 | ) | const

Returns the value of the specified float-type pass state.

Parameters:
pass | Handle to the pass
name | Specifies the name of the pass state to query.
value | Pointer to the buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to get the value of the float-type pass state specified by name. The user must provide a buffer large enough to hold the value. The behavior is undefined if the buffer pointed to by value does not fulfill this requirement. You can call CgFxEffect::getNumberOfPassStateValueComponents to determine the number of components a certain pass state value has. Together with the pass state's type information (e.g. CgFxEffect::isFloatPassState) it is easy to calculate the right size for the receiving buffer.

The function has no effect if called for others than float-type pass states! Use CgFxEffect::isFloatPassState to determine whether a certain pass state is a float-type pass state.

The value for a certain pass state corresponds to the actual Cg 1.4 specification. More details regarding the Cg 1.4 specification can be found at http://developer.nvidia.com/page/cg_main.html

Note that pass states are read-only. Hence, there is no corresponding function to modify a certain pass state's value.

Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get hold of valid passes defined for a certain technique.
See also:
CgFxEffect::getIntPassStateValue, CgFxEffect::getBoolPassStateValue

NVSG_API bool getIntPassStateValue | ( | CgFxPass | pass,
 |  | const std::string & | name,
 |  | int * | value
 | ) | const

Returns the value of the specified integer-type pass state.

Parameters:
pass | Handle to the pass
name | Specifies the name of the pass state to query.
value | Pointer to the buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to get the value of the integer-type pass state specified by name. The user must provide a buffer large enough to hold the value. The behavior is undefined if the buffer pointed to by value does not fulfill this requirement. You can call CgFxEffect::getNumberOfPassStateValueComponents to determine the number of components a certain pass state value has. Together with the pass state's type information (e.g. CgFxEffect::isIntPassState) it is easy to calculate the right size for the receiving buffer.

The function has no effect if called for other than integer-type pass states! Use CgFxEffect::isIntPassState to determine whether a certain pass state is a integer-type pass state.

The value for a certain pass state corresponds to the actual Cg 1.4 specification. More details regarding the Cg 1.4 specification can be found at http://developer.nvidia.com/page/cg_main.html

Note that pass states are read-only. Hence, there is no corresponding function to modify a certain pass state's value.

Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get hold of valid passes defined for a certain technique.
See also:
CgFxEffect::getFloatPassStateValue, CgFxEffect::getBoolPassStateValue

NVSG_API bool getBoolPassStateValue | ( | CgFxPass | pass,
 |  | const std::string & | name,
 |  | int * | value
 | ) | const

Returns the value of the specified 32-bit boolean-type pass state.

Parameters:
pass | Handle to the pass
name | Specifies the name of the pass state to query.
value | Pointer to the buffer that receives the value.
Returns:
The function returns true if the value could be retrieved successfully. Otherwise, the function returns false.
Remarks:
Use this function to get the value of the 32-bit boolean-type pass state specified by name. The user must provide a buffer large enough to hold the value. The behavior is undefined if the buffer pointed to by value does not fulfill this requirement. You can call CgFxEffect::getNumberOfPassStateValueComponents to determine the number of components a certain pass state value has. Together with the pass state's type information (e.g. CgFxEffect::isBoolPassState) it is easy to calculate the right size for the receiving buffer.

The function has no effect if called for other than 32-bit boolean-type pass states! Use CgFxEffect::isBoolPassState to determine whether a certain pass state is a 32-bit boolean-type pass state.

The value for a certain pass state corresponds to the actual Cg 1.4 specification. More details regarding the Cg 1.4 specification can be found at http://developer.nvidia.com/page/cg_main.html

Note that pass states are read-only. Hence, there is no corresponding function to modify a certain pass state's value.

Calling this function for an invalid pass results in undefined behavior. Use either CgFxEffect::getPass or CgFxEffect::getPassByName to get hold of valid passes defined for a certain technique.
See also:
CgFxEffect::getFloatPassStateValue, CgFxEffect::getIntPassStateValue

NVSG_API CgFxProgram getVertexProgram ( CgFxPass pass ) const

Returns the vertex program defined for the specified pass.

Parameters:
pass Handle to the pass to query.
Returns:
If a vertex program is defined for the specified pass, the function returns a handle to that vertex program. Otherwise, the function returns NULL.

NVSG_API CgFxProgram getGeometryProgram ( CgFxPass pass ) const

Returns the geometry program defined for the specified pass.

Parameters:
pass Handle to the pass to query.
Returns:
If a geometry program is defined for the specified pass, the function returns a handle to that geometry program. Otherwise, the function returns NULL.

NVSG_API CgFxProgram getFragmentProgram ( CgFxPass pass ) const

Returns the fragment program defined for the specified pass.

Parameters:
pass Handle to the pass to query.
Returns:
If a fragment program is defined for the specified pass, the function returns a handle to that fragment program. Otherwise, the function returns NULL.

NVSG_API bool isProgramCompiled ( CgFxProgram prog ) const

Returns whether the specified program is compiled.

Parameters:
prog Handle to the program.
Returns:
The function returns true if the specified program is compiled. Otherwise the function returns false.
Remarks:
Passing this function an invalid program handle results in undefined behavior. Use either CgFxEffect::getVertexProgram or CgFxEffect::getFragmentProgram to get a valid handle to either the vertex program or the fragment program defined for a certain pass.
See also:
CgFxEffect::compileProgram

NVSG_API bool compileProgram ( CgFxProgram prog )

Compiles the specified program.

Parameters:
prog Handle to the program to compile.
Returns:
The function returns true if the compilation succeeded. Otherwise, the function returns false.
Remarks:
The function compiles the specified program for its target profile. Use CgFxEffect::getProgramProfile to determine the current profile used for the program compilation. CgFxEffect::setProgramProfile lets you change that profile as needed.

A program must be compiled before its parameters can be inspected.

Passing this function an invalid program handle results in undefined behavior. Use either CgFxEffect::getVertexProgram or CgFxEffect::getFragmentProgram to get a valid handle to either the vertex program or the fragment program defined for a certain pass.

NVSG_API bool setProgramProfile | ( | CgFxProgram | prog,
 |  | const std::string & | profile
 | ) |

Sets the profile to be used to compile the specified program.

Parameters:
prog | Handle to the program.
profile | A string specifying the profile to set.
Returns:
The function returns true if the profile is recognized as a known profile, and hence, could have been set successfully. Otherwise the function returns false.
Remarks:
Dependent on the graphics platform, a profile may not be supported. For OpenGL, for example, this would be the case if a certain OpenGL extension, the profile requires, is not available.

If the specified profile could not be set for some reasons, the former profile remains the current one.

Note that the program must be recompiled if the program's profile changes in order to take effect.

Calling this function passing it an invalid program handle results in undefined behavior. Use either CgFxEffect::getVertexProgram or CgFxEffect::getFragmentProgram to get a valid handle to either the vertex program or the fragment program defined for a certain pass.
See also:
CgFxEffect::compileProgram

NVSG_API const std::string& getProgramProfile ( CgFxProgram prog ) const

Returns the actual profile used to compile the specified program.

Parameters:
prog Handle to the program.
Returns:
The function returns a reference to a const STL string that holds the profile string.
Remarks:
Passing this function an invalid program handle results in undefined behavior. Use either CgFxEffect::getVertexProgram or CgFxEffect::getFragmentProgram to get a valid handle to either the vertex program or the fragment program defined for a certain pass.
See also:
CgFxEffect::setProgramProfile

NVSG_API unsigned int getNumberOfProgramParameters ( CgFxProgram prog ) const

Returns the number of parameters passed to the specified program.

Parameters:
prog Handle to the program.
Returns:
The function returns the number of parameters passed to the specified program.
Remarks:
Use this function together with CgFxEffect::getProgramParameter to iterate through all parameters passed to the specified program.

Passing this function an invalid program handle results in undefined behavior. Use either CgFxEffect::getVertexProgram or CgFxEffect::getFragmentProgram to get a valid handle to either the vertex program or the fragment program defined for a certain pass.

NVSG_API CgFxParameter getProgramParameter | ( | CgFxProgram | prog,
 |  | unsigned int | index
 | ) | const

Returns the program parameter at the specified zero-based index.

Parameters:
prog | Handle to the program.
index | Zero-based index of the parameter to query
Returns:
The function returns a handle to the requested program parameter.
Remarks:
Use this function together with CgFxEffect::getNumberOfProgramParameter to iterate through all parameters passed to the specified program.

Passing this an invalid program handle results in undefined behavior. Use either CgFxEffect::getVertexProgram or CgFxEffect::getFragmentProgram to get a valid handle to either the vertex program or the fragment program defined for a certain pass.

NVSG_API bool isInputProgramParameter | ( | CgFxProgram | prog,
 |  | CgFxParameter | param
 | ) | const

Returns whether the specified program parameter is an input parameter.

Parameters:
prog | Handle to the program
param | Handle to the program parameter.
Returns:
The function returns true if the specified parameter is either an input parameter or an input/output parameter. Otherwise, the function returns false.
Remarks:
Passing this function an invalid program handle results in undefined behavior. Use either CgFxEffect::getVertexProgram or CgFxEffect::getFragmentProgram to get a valid handle to either the vertex program or the fragment program defined for a certain pass.

The behavior also is undefined if an invalid parameter handle is passed. Use CgFxEffect::getProgramParameter together with CgFxEffect::getNumberOfProgramParameter to iterate through all parameters of a program.
See also:
CgFxEffect::isOutputProgramParameter

NVSG_API bool isOutputProgramParameter | ( | CgFxProgram | prog,
 |  | CgFxParameter | param
 | ) | const

Returns whether the specified program parameter is an output parameter.

Parameters:
prog | Handle to the program
param | Handle to the program parameter.
Returns:
The function returns true if the specified parameter is either an output parameter or an input/output parameter. Otherwise, the function returns false.
Remarks:
Passing this function an invalid program handle results in undefined behavior. Use either CgFxEffect::getVertexProgram or CgFxEffect::getFragmentProgram to get a valid handle to either the vertex program or the fragment program defined for a certain pass.

The behavior also is undefined if an invalid parameter handle is passed. Use CgFxEffect::getProgramParameter together with CgFxEffect::getNumberOfProgramParameter to iterate through all parameters of a program.
See also:
CgFxEffect::isInputProgramParameter

The documentation for this class was generated from the following file:
  • CgFx.h
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


Member List

CgFxEffect Member List

This is the complete list of members for CgFxEffect, including all inherited members.
applyPass(unsigned int index) | CgFxEffect
CgFxEffect() | CgFxEffect
CgFxEffect(const CgFxEffect &rhs) | CgFxEffect
compileProgram(CgFxProgram prog) | CgFxEffect
createFromFile(const std::string &file, std::string &err) | CgFxEffect
createFromLump(const std::string &lump, std::string &err) | CgFxEffect
getAnnotationName(CgFxAnnotation anno) const | CgFxEffect
getAnnotationTypeString(CgFxAnnotation anno) const | CgFxEffect
getAnnotationValueSize(CgFxAnnotation anno) const | CgFxEffect
getArrayParameterElement(CgFxParameter param, unsigned int index) const | CgFxEffect
getBoolAnnotationValue(CgFxAnnotation anno, int *value) const | CgFxEffect
getBoolParameterValue(CgFxParameter param, int *value) const | CgFxEffect
getBoolPassStateValue(CgFxPass pass, const std::string &name, int *value) const | CgFxEffect
getBoolSamplerStateValue(CgFxParameter param, const std::string &name, int *value) const | CgFxEffect
getContext() const | CgFxEffect
getCurrentTechnique() const | CgFxEffect
getFileName(std::string &file) const | CgFxEffect
getFloatAnnotationValue(CgFxAnnotation anno, float *value) const | CgFxEffect
getFloatParameterValue(CgFxParameter param, float *value) const | CgFxEffect
getFloatPassStateValue(CgFxPass pass, const std::string &name, float *value) const | CgFxEffect
getFloatSamplerStateValue(CgFxParameter param, const std::string &name, float *value) const | CgFxEffect
getFragmentProgram(CgFxPass pass) const | CgFxEffect
getGeometryProgram(CgFxPass pass) const | CgFxEffect
getIntAnnotationValue(CgFxAnnotation anno, int *value) const | CgFxEffect
getIntParameterValue(CgFxParameter param, int *value) const | CgFxEffect
getIntPassStateValue(CgFxPass pass, const std::string &name, int *value) const | CgFxEffect
getIntSamplerStateValue(CgFxParameter param, const std::string &name, int *value) const | CgFxEffect
getLight(unsigned int index) const | CgFxEffect
getLightAmbientValue(CgFxParameter param, float *value) const | CgFxEffect
getLightByName(const std::string &name) const | CgFxEffect
getLightBySemantic(const std::string &semantic) const | CgFxEffect
getLightConstantAttenuationValue(CgFxParameter param, float *value) const | CgFxEffect
getLightDiffuseValue(CgFxParameter param, float *value) const | CgFxEffect
getLightDirectionValue(CgFxParameter param, float *value) const | CgFxEffect
getLightLinearAttenuationValue(CgFxParameter param, float *value) const | CgFxEffect
getLightPositionValue(CgFxParameter param, float *value) const | CgFxEffect
getLightQuadraticAttenuationValue(CgFxParameter param, float *value) const | CgFxEffect
getLightSpecularValue(CgFxParameter param, float *value) const | CgFxEffect
getLightSpotCutoffValue(CgFxParameter param, float *value) const | CgFxEffect
getLightSpotExponentValue(CgFxParameter param, float *value) const | CgFxEffect
getMaterial() const | CgFxEffect
getMaterialAmbientValue(CgFxParameter param, float *value) const | CgFxEffect
getMaterialDiffuseValue(CgFxParameter param, float *value) const | CgFxEffect
getMaterialEmissionValue(CgFxParameter param, float *value) const | CgFxEffect
getMaterialShininessValue(CgFxParameter param, float *value) const | CgFxEffect
getMaterialSpecularValue(CgFxParameter param, float *value) const | CgFxEffect
getNumberOfAnnotationValueComponents(CgFxAnnotation anno) const | CgFxEffect
getNumberOfArrayParameterElements(CgFxParameter param) const | CgFxEffect
getNumberOfLights() const | CgFxEffect
getNumberOfParameterAnnotations(CgFxParameter param) const | CgFxEffect
getNumberOfParameterValueComponents(CgFxParameter param) const | CgFxEffect
getNumberOfPassAnnotations(CgFxPass pass) const | CgFxEffect
getNumberOfPasses(CgFxTechnique tech) const | CgFxEffect
getNumberOfPassStateValueComponents(CgFxPass pass, const std::string &name) const | CgFxEffect
getNumberOfProgramParameters(CgFxProgram prog) const | CgFxEffect
getNumberOfProgramSamplers(CgFxProgram prog) const | CgFxEffect
getNumberOfSamplers() const | CgFxEffect
getNumberOfSamplerStateValueComponents(CgFxParameter param, const std::string &name) const | CgFxEffect
getNumberOfStructParameterMembers(CgFxParameter param) const | CgFxEffect
getNumberOfTechniqueAnnotations(CgFxTechnique tech) const | CgFxEffect
getNumberOfTechniques() const | CgFxEffect
getNumberOfTransforms() const | CgFxEffect
getNumberOfTweakables() const | CgFxEffect
getParameterAnnotation(CgFxParameter param, unsigned int index) const | CgFxEffect
getParameterAnnotationByName(CgFxParameter param, const std::string &name) const | CgFxEffect
getParameterByName(const std::string &name) const | CgFxEffect
getParameterBySemantic(const std::string &semantic) const | CgFxEffect
getParameterName(CgFxParameter param) const | CgFxEffect
getParameterSemantic(CgFxParameter param) const | CgFxEffect
getParameterTypeString(CgFxParameter param) const | CgFxEffect
getParameterValueAsFloat(CgFxParameter param, float *value) const | CgFxEffect
getParameterValueSize(CgFxParameter param) const | CgFxEffect
getPass(CgFxTechnique tech, unsigned int index) const | CgFxEffect
getPassAnnotation(CgFxPass pass, unsigned int index) const | CgFxEffect
getPassAnnotationByName(CgFxPass pass, const std::string &name) const | CgFxEffect
getPassByName(CgFxTechnique tech, const std::string &name) const | CgFxEffect
getPassName(CgFxPass pass) const | CgFxEffect
getProgramInputType(CgFxProgram prog) const | CgFxEffect
getProgramOutputType(CgFxProgram prog) const | CgFxEffect
getProgramParameter(CgFxProgram prog, unsigned int index) const | CgFxEffect
getProgramProfile(CgFxProgram prog) const | CgFxEffect
getProgramSampler(CgFxProgram prog, unsigned int index) const | CgFxEffect
getSampler(unsigned int index) const | CgFxEffect
getSamplerByName(const std::string &name) const | CgFxEffect
getSamplerByTextureParameterName(const std::string &name) const | CgFxEffect
getSamplerTexture(CgFxParameter param) const | CgFxEffect
getSamplerTextureFileName(CgFxParameter param, std::string &file) const | CgFxEffect
getSamplerTextureGPUFormat(CgFxParameter param, TextureImage::TextureGPUFormat &format) | CgFxEffect
getSamplerTextureImage(CgFxParameter param) const | CgFxEffect
getSamplerTextureTarget(CgFxParameter param) const | CgFxEffect
getScene() const | CgFxEffect
getSceneAmbientValue(CgFxParameter param, float *value) const | CgFxEffect
getSceneFrameNumberValue(CgFxParameter param, int *value) const | CgFxEffect
getSourceCode(std::string &code) const | CgFxEffect
getStringAnnotationValue(CgFxAnnotation anno, std::string &value) const | CgFxEffect
getStringParameterValue(CgFxParameter param, std::string &value) const | CgFxEffect
getStructParameterMember(CgFxParameter param, unsigned int index) const | CgFxEffect
getStructParameterMemberByName(CgFxParameter param, const std::string &member) const | CgFxEffect
getTechnique(unsigned int index) const | CgFxEffect
getTechniqueAnnotation(CgFxTechnique tech, unsigned int index) const | CgFxEffect
getTechniqueAnnotationByName(CgFxTechnique tech, const std::string &name) const | CgFxEffect
getTechniqueByName(const std::string &name) const | CgFxEffect
getTechniqueIndex(CgFxTechnique tech) const | CgFxEffect
getTechniqueName(CgFxTechnique tech) const | CgFxEffect
getTransform(unsigned int index) const | CgFxEffect
getTransformType(CgFxParameter param) const | CgFxEffect
getTweakable(unsigned int index) const | CgFxEffect
getTweakableByName(const std::string &name) const | CgFxEffect
getTweakableBySemantic(const std::string &semantic) const | CgFxEffect
getVertexProgram(CgFxPass pass) const | CgFxEffect
isArrayParameter(CgFxParameter param) const | CgFxEffect
isBoolAnnotation(CgFxAnnotation anno) const | CgFxEffect
isBoolParameter(CgFxParameter param) const | CgFxEffect
isBoolPassState(CgFxPass pass, const std::string &name) const | CgFxEffect
isBoolSamplerState(CgFxParameter param, const std::string &name) const | CgFxEffect
isFloatAnnotation(CgFxAnnotation anno) const | CgFxEffect
isFloatParameter(CgFxParameter param) const | CgFxEffect
isFloatPassState(CgFxPass pass, const std::string &name) const | CgFxEffect
isFloatSamplerState(CgFxParameter param, const std::string &name) const | CgFxEffect
isFromFile() const | CgFxEffect
isFromLump() const | CgFxEffect
isInputProgramParameter(CgFxProgram prog, CgFxParameter param) const | CgFxEffect
isIntAnnotation(CgFxAnnotation anno) const | CgFxEffect
isIntParameter(CgFxParameter param) const | CgFxEffect
isIntPassState(CgFxPass pass, const std::string &name) const | CgFxEffect
isIntSamplerState(CgFxParameter param, const std::string &name) const | CgFxEffect
isLightArrayParameter(CgFxParameter param) const | CgFxEffect
isLightParameter(CgFxParameter param) const | CgFxEffect
isMaterialParameter(CgFxParameter param) const | CgFxEffect
isMatrix22Parameter(CgFxParameter param) const | CgFxEffect
isMatrix23Parameter(CgFxParameter param) const | CgFxEffect
isMatrix24Parameter(CgFxParameter param) const | CgFxEffect
isMatrix32Parameter(CgFxParameter param) const | CgFxEffect
isMatrix33Parameter(CgFxParameter param) const | CgFxEffect
isMatrix34Parameter(CgFxParameter param) const | CgFxEffect
isMatrix42Parameter(CgFxParameter param) const | CgFxEffect
isMatrix43Parameter(CgFxParameter param) const | CgFxEffect
isMatrix44Parameter(CgFxParameter param) const | CgFxEffect
isMipmapSamplerState(CgFxParameter sampler) const | CgFxEffect
isOutputProgramParameter(CgFxProgram prog, CgFxParameter param) const | CgFxEffect
isProgramCompiled(CgFxProgram prog) const | CgFxEffect
isSampler1DParameter(CgFxParameter param) const | CgFxEffect
isSampler2DParameter(CgFxParameter param) const | CgFxEffect
isSampler3DParameter(CgFxParameter param) const | CgFxEffect
isSamplerArrayParameter(CgFxParameter param) const | CgFxEffect
isSamplerCubeParameter(CgFxParameter param) const | CgFxEffect
isSamplerParameter(CgFxParameter param) const | CgFxEffect
isSamplerRectParameter(CgFxParameter param) const | CgFxEffect
isScalarParameter(CgFxParameter param) const | CgFxEffect
isSceneParameter(CgFxParameter param) const | CgFxEffect
isStringAnnotation(CgFxAnnotation anno) const | CgFxEffect
isStringParameter(CgFxParameter param) const | CgFxEffect
isStructParameter(CgFxParameter param) const | CgFxEffect
isTextureImageSamplerCompliant(CgFxParameter sampler, TextureImageHandle *image) const | CgFxEffect
isTransformParameter(CgFxParameter param) const | CgFxEffect
isTransparentPass(CgFxPass pass) const | CgFxEffect
isValid() const | CgFxEffect
isVector2Parameter(CgFxParameter param) const | CgFxEffect
isVector3Parameter(CgFxParameter param) const | CgFxEffect
isVector4Parameter(CgFxParameter param) const | CgFxEffect
PROGRAM_IO_FRAGMENT enum value | CgFxEffect
PROGRAM_IO_LINE enum value | CgFxEffect
PROGRAM_IO_LINE_ADJ enum value | CgFxEffect
PROGRAM_IO_POINT enum value | CgFxEffect
PROGRAM_IO_TRIANGLE enum value | CgFxEffect
PROGRAM_IO_TRIANGLE_ADJ enum value | CgFxEffect
PROGRAM_IO_VERTEX enum value | CgFxEffect
ProgramIOType enum name | CgFxEffect
resetLightValues(CgFxParameter param) | CgFxEffect
resetMaterialValues(CgFxParameter param) | CgFxEffect
resetPass(unsigned int index) | CgFxEffect
resetSceneValues(CgFxParameter param) | CgFxEffect
setBoolParameterValue(CgFxParameter param, const int *value) | CgFxEffect
setCurrentTechnique(CgFxTechnique tech) | CgFxEffect
setFloatParameterValue(CgFxParameter param, const float *value) | CgFxEffect
setIntParameterValue(CgFxParameter param, const int *value) | CgFxEffect
setLightAmbientValue(CgFxParameter param, const float *value) | CgFxEffect
setLightConstantAttenuationValue(CgFxParameter param, const float *value) | CgFxEffect
setLightDiffuseValue(CgFxParameter param, const float *value) | CgFxEffect
setLightDirectionValue(CgFxParameter param, const float *value) | CgFxEffect
setLightLinearAttenuationValue(CgFxParameter param, const float *value) | CgFxEffect
setLightPositionValue(CgFxParameter param, const float *value) | CgFxEffect
setLightQuadraticAttenuationValue(CgFxParameter param, const float *value) | CgFxEffect
setLightSpecularValue(CgFxParameter param, const float *value) | CgFxEffect
setLightSpotCutoffValue(CgFxParameter param, const float *value) | CgFxEffect
setLightSpotExponentValue(CgFxParameter param, const float *value) | CgFxEffect
setMaterialAmbientValue(CgFxParameter param, const float *value) | CgFxEffect
setMaterialDiffuseValue(CgFxParameter param, const float *value) | CgFxEffect
setMaterialEmissionValue(CgFxParameter param, const float *value) | CgFxEffect
setMaterialShininessValue(CgFxParameter param, const float *value) | CgFxEffect
setMaterialSpecularValue(CgFxParameter param, const float *value) | CgFxEffect
setParameterValueAsFloat(CgFxParameter param, const float *value) | CgFxEffect
setProgramProfile(CgFxProgram prog, const std::string &profile) | CgFxEffect
setSamplerTextureGPUFormat(CgFxParameter param, TextureImage::TextureGPUFormat format) | CgFxEffect
setSamplerTextureImage(CgFxParameter param, TextureImageHandle *image) | CgFxEffect
setSceneAmbientValue(CgFxParameter param, const float *value) | CgFxEffect
setSceneFrameNumberValue(CgFxParameter param, const int *value) | CgFxEffect
setStringParameterValue(CgFxParameter param, const std::string &value) | CgFxEffect
setTransformValue(CgFxParameter param, const float *value) | CgFxEffect
TRAFO_MODEL enum value | CgFxEffect
TRAFO_MODELI enum value | CgFxEffect
TRAFO_MODELINVERSE enum value | CgFxEffect
TRAFO_MODELINVERSETRANSPOSE enum value | CgFxEffect
TRAFO_MODELIT enum value | CgFxEffect
TRAFO_MODELT enum value | CgFxEffect
TRAFO_MODELTRANSPOSE enum value | CgFxEffect
TRAFO_MODELVIEW enum value | CgFxEffect
TRAFO_MODELVIEWI enum value | CgFxEffect
TRAFO_MODELVIEWINVERSE enum value | CgFxEffect
TRAFO_MODELVIEWINVERSETRANSPOSE enum value | CgFxEffect
TRAFO_MODELVIEWIT enum value | CgFxEffect
TRAFO_MODELVIEWPROJECTION enum value | CgFxEffect
TRAFO_MODELVIEWPROJECTIONI enum value | CgFxEffect
TRAFO_MODELVIEWPROJECTIONINVERSE enum value | CgFxEffect
TRAFO_MODELVIEWPROJECTIONINVERSETRANSPOSE enum value | CgFxEffect
TRAFO_MODELVIEWPROJECTIONIT enum value | CgFxEffect
TRAFO_MODELVIEWPROJECTIONT enum value | CgFxEffect
TRAFO_MODELVIEWPROJECTIONTRANSPOSE enum value | CgFxEffect
TRAFO_MODELVIEWT enum value | CgFxEffect
TRAFO_MODELVIEWTRANSPOSE enum value | CgFxEffect
TRAFO_PROJECTION enum value | CgFxEffect
TRAFO_PROJECTIONI enum value | CgFxEffect
TRAFO_PROJECTIONINVERSE enum value | CgFxEffect
TRAFO_PROJECTIONINVERSETRANSPOSE enum value | CgFxEffect
TRAFO_PROJECTIONIT enum value | CgFxEffect
TRAFO_PROJECTIONT enum value | CgFxEffect
TRAFO_PROJECTIONTRANSPOSE enum value | CgFxEffect
TRAFO_UNKNOWN enum value | CgFxEffect
TRAFO_VIEW enum value | CgFxEffect
TRAFO_VIEWI enum value | CgFxEffect
TRAFO_VIEWINVERSE enum value | CgFxEffect
TRAFO_VIEWINVERSETRANSPOSE enum value | CgFxEffect
TRAFO_VIEWIT enum value | CgFxEffect
TRAFO_VIEWT enum value | CgFxEffect
TRAFO_VIEWTRANSPOSE enum value | CgFxEffect
TRAFO_WORLD enum value | CgFxEffect
TRAFO_WORLDI enum value | CgFxEffect
TRAFO_WORLDINVERSE enum value | CgFxEffect
TRAFO_WORLDINVERSETRANSPOSE enum value | CgFxEffect
TRAFO_WORLDIT enum value | CgFxEffect
TRAFO_WORLDT enum value | CgFxEffect
TRAFO_WORLDTRANSPOSE enum value | CgFxEffect
TRAFO_WORLDVIEW enum value | CgFxEffect
TRAFO_WORLDVIEWI enum value | CgFxEffect
TRAFO_WORLDVIEWINVERSE enum value | CgFxEffect
TRAFO_WORLDVIEWINVERSETRANSPOSE enum value | CgFxEffect
TRAFO_WORLDVIEWIT enum value | CgFxEffect
TRAFO_WORLDVIEWPROJECTION enum value | CgFxEffect
TRAFO_WORLDVIEWPROJECTIONI enum value | CgFxEffect
TRAFO_WORLDVIEWPROJECTIONINVERSE enum value | CgFxEffect
TRAFO_WORLDVIEWPROJECTIONINVERSETRANSPOSE enum value | CgFxEffect
TRAFO_WORLDVIEWPROJECTIONIT enum value | CgFxEffect
TRAFO_WORLDVIEWPROJECTIONT enum value | CgFxEffect
TRAFO_WORLDVIEWPROJECTIONTRANSPOSE enum value | CgFxEffect
TRAFO_WORLDVIEWT enum value | CgFxEffect
TRAFO_WORLDVIEWTRANSPOSE enum value | CgFxEffect
TransformType enum name | CgFxEffect
validateCurrentTechnique() | CgFxEffect
~CgFxEffect() | CgFxEffect
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


ChangeCallback Class Reference

Abstract class for defining a CallBack on an object. More...

#include <ChangeCallBack.h>

Inheritance diagram for ChangeCallback:

[legend]
Collaboration diagram for ChangeCallback:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API void | changed (nvsg::ObjectHandle *subjectHandle, const void *userData=NULL) const=0
pure virtual method to call when the subject changes

Protected Member Functions

ChangeCallback ()
Constructs a ChangeCallback.

virtual | ~ChangeCallback ()
Destructs a ChangeCallback object.

Detailed Description

Abstract class for defining a CallBack on an object.

Namespace: nvsg
Remarks:
This class (in conjunction with the CallBackServer) provides an interface that allows the user to: -trigger CallBacks on an Object and/or -do Object-Object messaging (Subject-Observer pattern)

Constructor & Destructor Documentation

ChangeCallback ( ) [protected]

Constructs a ChangeCallback.

virtual ~ChangeCallback ( ) [protected, virtual]

Destructs a ChangeCallback object.

Member Function Documentation

virtual NVSG_API void changed | ( | nvsg::ObjectHandle * | subjectHandle,
 |  | const void * | userData = NULL
 | ) | const [pure virtual]

pure virtual method to call when the subject changes

Parameters:
subjectHandle | Handle to the subject that changed
userData | An optional pointer to user defined data, default is NULL.
Remarks:
-Derive a concrete ChangeCallBack and override this method -add the call back to the CallBackServer using CallBackServer::addCallback Calling CallBackServer::changed method routes(i.e calls the changed method) for an object and its associated CallBacks

The documentation for this class was generated from the following file:
  • ChangeCallBack.h
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


Member List

ChangeCallback Member List

This is the complete list of members for ChangeCallback, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
ChangeCallback() | ChangeCallback | [protected]
changed(nvsg::ObjectHandle *subjectHandle, const void *userData=NULL) const=0 | ChangeCallback | [pure virtual]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~ChangeCallback() | ChangeCallback | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


Chunk Class Reference

Chunk of memory for our low level memory managment of fixed size objects. More...

#include <Allocator.h>

List of all members.

Public Member Functions

Chunk (size_t blockSize)
construct a chunk of blockSize bytes

bool | operator== (const Chunk &rhs) const
provide comparison of chunks

bool | operator!= (const Chunk &rhs) const
void * | alloc ()
memory management interface

void | dealloc (void *p)
void | freeMemory ()
explicitely free memory

unsigned char | blocksAvailable () const
provide number of blocks available in this chunk

bool | isUnused () const
for cleanup purposes, provide check if chunk is entirely unused

bool | isInsideBounds (void *p) const
provide address checking

Detailed Description

Chunk of memory for our low level memory managment of fixed size objects.

Constructor & Destructor Documentation

Chunk ( size_t blockSize )

construct a chunk of blockSize bytes

Member Function Documentation

bool operator== ( const Chunk & rhs ) const [inline]

provide comparison of chunks

Chunk::operator==()

returns true if rhs equals this chunk

bool operator!= ( const Chunk & rhs ) const [inline]

Chunk::operator!=()

returns true if rhs not equals this chunk

void * alloc ( ) [inline]

memory management interface

Chunk::alloc()

get one block from chunk; returns NULL if no blocks available

void dealloc ( void * p ) [inline]

Chunk::dealloc()

deallocate a block pointed to by p

void freeMemory ( ) [inline]

explicitely free memory

Chunk::freeMemory()

explicitely free chunk's raw memory

unsigned char blocksAvailable ( ) const [inline]

provide number of blocks available in this chunk

Chunk::blocksAvailable()

provides number of blocks available in this chunk

bool isUnused ( ) const [inline]

for cleanup purposes, provide check if chunk is entirely unused

Chunk::isUnused()

for cleanup purposes, provide check if chunk is entirely unused

bool isInsideBounds ( void * p ) const [inline]

provide address checking

Chunk::isInsideBounds()

returns true if the address given belongs to this chunk; false otherwise

The documentation for this class was generated from the following file:
  • Allocator.h
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


Member List

Chunk Member List

This is the complete list of members for Chunk, including all inherited members.
alloc() | Chunk | [inline]
blocksAvailable() const | Chunk | [inline]
Chunk(size_t blockSize) | Chunk |
dealloc(void *p) | Chunk | [inline]
freeMemory() | Chunk | [inline]
isInsideBounds(void *p) const | Chunk | [inline]
isUnused() const | Chunk | [inline]
operator!=(const Chunk &rhs) const | Chunk | [inline]
operator==(const Chunk &rhs) const | Chunk | [inline]
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


ClipPlanesElement Class Reference

Helper class to hold the clip planes valid for a number of PrimitiveSets. More...

#include <ClipPlanesElement.h>

Inheritance diagram for ClipPlanesElement:

[legend]
Collaboration diagram for ClipPlanesElement:

[legend]
List of all members.

Public Member Functions

NVSG_API | ClipPlanesElement ()
Default constructor.

NVSG_API | ClipPlanesElement (nvsg::GroupHandle *group, const nvmath::Mat44f &modelToWorld, const ClipPlanesElement &rhs)
Constructor of a ClipPlanesElement.

NVSG_API const nvmath::Plane3f & | getClipPlane (unsigned int index) const
Get the clip plane at index index.

NVSG_API nvsg::GroupHandle * | getGroup () const
Get the GroupHandle corresponding to this ClipPlanesElement.

NVSG_API const nvmath::Mat44f & | getModelToWorld (unsigned int index) const
Get the model-to-world transformation matrix at index index.

NVSG_API unsigned int | getNumberOfClipPlanes () const
Get the number of clip planes in this ClipPlanesElement.

Detailed Description

Helper class to hold the clip planes valid for a number of PrimitiveSets.

Remarks:
This class holds the complete clip plane information valid for the objects being beneath a Group in the scene tree.
See also:
BaseRenderElement

Constructor & Destructor Documentation

ClipPlanesElement ( ) [inline]

Default constructor.

Remarks:
The default constructor initializes the corresponding Group to be NULL. It is used to initialize the stack of ClipPlanesElements maintained by the RenderTraverser.

ClipPlanesElement | ( | nvsg::GroupHandle * | group,
 |  | const nvmath::Mat44f & | modelToWorld,
 |  | const ClipPlanesElement & | rhs
 | ) | [inline]

Constructor of a ClipPlanesElement.

Parameters:
group | A pointer to the Group that adds at least one clip plane.
modelToWorld | A reference to the corresponding constant model to world transformation matrix.
rhs | A reference to the constant ClipPlanesElement to get the first clip planes from.
Remarks:
The RenderTraverser maintains a stack of ClipPlaneElmenents. Whenever a Group with at least one clip plane is encountered on traversal, a new ClipPlaneElement is pushed on that stack, holding all the clip planes being valid at that point, plus the clip planes defined in that Group.

Member Function Documentation

const nvmath::Plane3f & getClipPlane ( unsigned int index ) const [inline]

Get the clip plane at index index.

Parameters:
index The index of the clip plane to get.
Returns:
The clip plane at index index.
Note:
The behavior is undefined, if index is larger or equal to the number of clip planes in this ClipPlanesElement.
See also:
getNumberOfClipPlanes, getModelToWorld

nvsg::GroupHandle * getGroup ( ) const [inline]

Get the GroupHandle corresponding to this ClipPlanesElement.

Returns:
A pointer to the GroupHandle corresponding to this ClipPlanesElement.
Remarks:
This is used in RenderTraverser::postTraverseGroup to ensure that this is a Group that added some clip planes.

const nvmath::Mat44f & getModelToWorld ( unsigned int index ) const [inline]

Get the model-to-world transformation matrix at index index.

Parameters:
index The index of the model-to-world transformation matrix to get.
Returns:
The model-to-world transformation matrix corresponding to the clip plane at index index.
Note:
The behavior is undefined, if index is larger or equal to the number of clip planes in this ClipPlanesElement.
See also:
getNumberOfClipPlanes, getClipPlane

unsigned int getNumberOfClipPlanes ( ) const [inline]

Get the number of clip planes in this ClipPlanesElement.

Returns:
The number of clip planes in this ClipPlanesElement.
Remarks:
For each of the clip planes, there is a corresponding model-to-world transformation matrix.
See also:
getClipPlane, getModelToWorld

The documentation for this class was generated from the following file:
  • ClipPlanesElement.h
Generated on Tue Jan 15 10:29:28 2008 for NVSGSDK by NVIDIA


Member List

ClipPlanesElement Member List

This is the complete list of members for ClipPlanesElement, including all inherited members.
addRef() | BaseRenderElement | [inline]
BaseRenderElement() | BaseRenderElement | [inline, protected]
BaseRenderElement(const BaseRenderElement &rhs) | BaseRenderElement | [inline, protected]
ClipPlanesElement() | ClipPlanesElement | [inline]
ClipPlanesElement(nvsg::GroupHandle *group, const nvmath::Mat44f &modelToWorld, const ClipPlanesElement &rhs) | ClipPlanesElement | [inline]
getClipPlane(unsigned int index) const | ClipPlanesElement | [inline]
getGroup() const | ClipPlanesElement | [inline]
getModelToWorld(unsigned int index) const | ClipPlanesElement | [inline]
getNumberOfClipPlanes() const | ClipPlanesElement | [inline]
getRefCnt() const | BaseRenderElement | [inline]
removeRef() | BaseRenderElement | [inline]
~BaseRenderElement() | BaseRenderElement | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:28 2008 for NVSGSDK by NVIDIA


CombinableResult Class Reference

AnalyzeResult indicating that a number of Objects can be combined. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for CombinableResult:

[legend]
Collaboration diagram for CombinableResult:

[legend]
List of all members.

Public Attributes

unsigned int | combinableCount
The number of combinable objects of this type.

unsigned int | reducedCount
The number of objects of this type, if combinable objects would be combined.

Detailed Description

AnalyzeResult indicating that a number of Objects can be combined.

Namespace: nvsg
Remarks:
Reports if, and how many, combinable Objects are in the tree. It tells how many objects of the type objectCode are combinable, and by how many objects they could be replaced with. Currently, the following objects are checked for combinability: nvsg::GeoNode, nvsg::Lines, nvsg::LineStrips, nvsg::Points, nvsg::QuadMeshes, nvsg::Quads, nvsg::QuatStrips, nvsg::Triangles, nvsg::TriFans, and nvsg::TriStrips.
See also:
AnalyzeResult AnalyzeTraverser

Member Data Documentation

unsigned int combinableCount

The number of combinable objects of this type.

unsigned int reducedCount

The number of objects of this type, if combinable objects would be combined.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


Member List

CombinableResult Member List

This is the complete list of members for CombinableResult, including all inherited members.
combinableCount | CombinableResult |
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
reducedCount | CombinableResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~CombinableResult() (defined in CombinableResult) | CombinableResult | [inline, virtual]
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


CombineTraverser Class Reference

Traverser that combines a number of Objects, if appropriate. More...

#include <CombineTraverser.h>

Inheritance diagram for CombineTraverser:

[legend]
Collaboration diagram for CombineTraverser:

[legend]
List of all members.

Public Types

enum {
CT_GEONODE = BIT0, CT_LOD = BIT1, CT_LOD_RANGES = BIT2, CT_PRIMITIVE_SET = BIT3,
CT_TRANSFORM = BIT4, CT_ALL_TARGETS_MASK = ( CT_GEONODE | CT_LOD | CT_LOD_RANGES | CT_PRIMITIVE_SET | CT_TRANSFORM )
}

Public Member Functions

NVSG_API | CombineTraverser (void)
Constructor.

NVSG_API unsigned int | getCombineTargets () const
Get the bitmask describing the targets to combine.

NVSG_API void | setCombineTargets (unsigned int mask)
Set the bitmask describing the targets to combine.

Public Attributes

enum nvtraverser::CombineTraverser:: { ... } | CombineTarget

Protected Member Functions

virtual NVSG_API | ~CombineTraverser (void)
Protected destructor to prevent instantiation of a CombineTraverser on stack.

virtual NVSG_API void | handleAnimatedTransform (nvsg::AnimatedTransform *p)
Combine all GeoNodes and LODs directly underneath this AnimatedTransform.

virtual NVSG_API void | handleBillboard (nvsg::Billboard *p)
Combine all GeoNodes and LODs directly underneath this Billboard.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *p)
Combine all PrimitiveSets of the same type bound to the same StateSet.

virtual NVSG_API void | handleGroup (nvsg::Group *p)
Combine all GeoNodes and LODs directly underneath this Group.

virtual NVSG_API void | handleLines (nvsg::Lines *p)
Gather Lines to combine PrimitiveSets.

virtual NVSG_API void | handleLineStrips (nvsg::LineStrips *p)
Gather LineStrips to combine PrimitiveSets.

virtual NVSG_API void | handleLOD (nvsg::LOD *p)
Combine all consecutive LOD ranges referencing the same Node.

virtual NVSG_API void | handlePoints (nvsg::Points *p)
Gather Points to combine PrimitiveSets.

virtual NVSG_API void | handleQuadMeshes (nvsg::QuadMeshes *p)
Gather QuadMeshes to combine PrimitiveSets.

virtual NVSG_API void | handleQuads (nvsg::Quads *p)
Gather Quads to combine PrimitiveSets.

virtual NVSG_API void | handleQuadStrips (nvsg::QuadStrips *p)
Gather QuadStrips to combine PrimitiveSets.

virtual NVSG_API void | handleTransform (nvsg::Transform *p)
Combine all GeoNodes and LODs directly underneath this Transform.

virtual NVSG_API void | handleTriangles (nvsg::Triangles *p)
Gather Triangles to combine PrimitiveSets.

virtual NVSG_API void | handleTriFans (nvsg::TriFans *p)
Gather TriFans to combine PrimitiveSets.

virtual NVSG_API void | handleTriStrips (nvsg::TriStrips *p)
Gather TriStrips to combine PrimitiveSets.

virtual NVSG_API bool | preTraverseDrawables (const nvsg::GeoNode *gnode, unsigned int geomIndex)
Keep track of the current StateSet.

Detailed Description

Traverser that combines a number of Objects, if appropriate.

Remarks:
There are a number of different objects types combinable:
  • All geometries of all GeoNodes under one Group are combined into a single GeoNode.
  • All LODs with the same ranges under one Group into a single LOD.
  • Consecutive ranges in an LOD that reference the same Node into one range.
  • All PrimitveSets of the same type bound to the same StateSet are combined into one.

Member Enumeration Documentation

anonymous enum

Enumeration values:
CT_GEONODE | CombineTarget GeoNode: combine compatible GeoNode objects into one.
CT_LOD | CombineTarget LOD: combine compatible LOD objects into one.
CT_LOD_RANGES | CombineTarget LOD Range: combine identical adjacent LOD levels into one.
CT_PRIMITIVE_SET | CombineTarget PrimitiveSet: combine compatible PrimitiveSet objects into one.
CT_TRANSFORM | CombineTarget Transform: combine compatible Transform objects into one.

Constructor & Destructor Documentation

NVSG_API CombineTraverser ( void )

Constructor.

virtual NVSG_API ~CombineTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a CombineTraverser on stack.

Member Function Documentation

unsigned int getCombineTargets ( ) const [inline]

Get the bitmask describing the targets to combine.

Returns:
A bitmask describing the targets to combine.

void setCombineTargets ( unsigned int mask ) [inline]

Set the bitmask describing the targets to combine.

Parameters:
mask The bitmask describing the targets to combine.

virtual NVSG_API void handleAnimatedTransform ( nvsg::AnimatedTransform * p ) [protected, virtual]

Combine all GeoNodes and LODs directly underneath this AnimatedTransform.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleBillboard ( nvsg::Billboard * p ) [protected, virtual]

Combine all GeoNodes and LODs directly underneath this Billboard.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * p ) [protected, virtual]

Combine all PrimitiveSets of the same type bound to the same StateSet.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGroup ( nvsg::Group * p ) [protected, virtual]

Combine all GeoNodes and LODs directly underneath this Group.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLines ( nvsg::Lines * p ) [protected, virtual]

Gather Lines to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLineStrips ( nvsg::LineStrips * p ) [protected, virtual]

Gather LineStrips to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLOD ( nvsg::LOD * p ) [protected, virtual]

Combine all consecutive LOD ranges referencing the same Node.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handlePoints ( nvsg::Points * p ) [protected, virtual]

Gather Points to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadMeshes ( nvsg::QuadMeshes * p ) [protected, virtual]

Gather QuadMeshes to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuads ( nvsg::Quads * p ) [protected, virtual]

Gather Quads to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadStrips ( nvsg::QuadStrips * p ) [protected, virtual]

Gather QuadStrips to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTransform ( nvsg::Transform * p ) [protected, virtual]

Combine all GeoNodes and LODs directly underneath this Transform.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriangles ( nvsg::Triangles * p ) [protected, virtual]

Gather Triangles to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriFans ( nvsg::TriFans * p ) [protected, virtual]

Gather TriFans to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriStrips ( nvsg::TriStrips * p ) [protected, virtual]

Gather TriStrips to combine PrimitiveSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API bool preTraverseDrawables | ( | const nvsg::GeoNode * | gnode,
 |  | unsigned int | geomIndex
 | ) | [protected, virtual]

Keep track of the current StateSet.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • CombineTraverser.h
Generated on Tue Jan 15 10:29:28 2008 for NVSGSDK by NVIDIA


Member List

CombineTraverser Member List

This is the complete list of members for CombineTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
CombineTarget (defined in CombineTraverser) | CombineTraverser |
CombineTraverser(void) | CombineTraverser |
CT_ALL_TARGETS_MASK enum value (defined in CombineTraverser) | CombineTraverser |
CT_GEONODE enum value | CombineTraverser |
CT_LOD enum value | CombineTraverser |
CT_LOD_RANGES enum value | CombineTraverser |
CT_PRIMITIVE_SET enum value | CombineTraverser |
CT_TRANSFORM enum value | CombineTraverser |
doApply(nvsg::NodeHandle *root) | OptimizeTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getCombineTargets() const | CombineTraverser | [inline]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *p) | CombineTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *p) | CombineTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *p) | CombineTraverser | [protected, virtual]
handleGroup(nvsg::Group *p) | CombineTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *p) | CombineTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *p) | CombineTraverser | [protected, virtual]
handleLOD(nvsg::LOD *p) | CombineTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *p) | CombineTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *p) | CombineTraverser | [protected, virtual]
handleQuads(nvsg::Quads *p) | CombineTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *p) | CombineTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *p) | CombineTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *p) | CombineTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *p) | CombineTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *p) | CombineTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | CombineTraverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setCombineTargets(unsigned int mask) | CombineTraverser | [inline]
setIgnoreNames(bool ignore) | OptimizeTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~CombineTraverser(void) | CombineTraverser | [protected, virtual]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:28 2008 for NVSGSDK by NVIDIA


CPUSkinningProcessor Class Reference

CPUSkinningProcessor Class. More...

#include <CPUSkinningProcessor.h>

List of all members.

Public Member Functions

NVSG_API | CPUSkinningProcessor ()
Default constructor.

virtual NVSG_API void | process (bool process)
apply to scene

virtual NVSG_API AppTraverser::SkinningProcessorType | getType ()

Static Public Member Functions

NVSG_API bool | isSupported (void)
is this processor supported on the current arch.

Detailed Description

CPUSkinningProcessor Class.

This class provides the mechanism to apply CPU skinning in the app post processor.

Constructor & Destructor Documentation

NVSG_API CPUSkinningProcessor ( )

Default constructor.

Member Function Documentation

virtual NVSG_API void process ( bool process ) [virtual]

apply to scene

NVSG_API bool isSupported ( void ) [static]

is this processor supported on the current arch.

The documentation for this class was generated from the following file:
  • CPUSkinningProcessor.h
Generated on Tue Jan 15 10:29:28 2008 for NVSGSDK by NVIDIA


Member List

CPUSkinningProcessor Member List

This is the complete list of members for CPUSkinningProcessor, including all inherited members.
CPUSkinningProcessor() | CPUSkinningProcessor |
getType() (defined in CPUSkinningProcessor) | CPUSkinningProcessor | [virtual]
isSupported(void) | CPUSkinningProcessor | [static]
process(bool process) | CPUSkinningProcessor | [virtual]
~CPUSkinningProcessor() (defined in CPUSkinningProcessor) | CPUSkinningProcessor | [protected, virtual]
Generated on Tue Jan 15 10:29:28 2008 for NVSGSDK by NVIDIA


CullData Class Reference

Class holding culling information of an object and it's children. More...

#include <CullData.h>

Inheritance diagram for CullData:

[legend]
Collaboration diagram for CullData:

[legend]
List of all members.

Public Member Functions

NVSG_API | CullData (CullCode cullCode)
Constructor with nvsg::CullCode.

NVSG_API void | balance (void)
Balance the tree beneath this CullData.

NVSG_API void | addChild (CullData *cd)
Add a child to this CullData.

NVSG_API const CullData * | getChild (unsigned int i) const
Get the i'th child of this CullData.

NVSG_API CullCode | getCullCode (void) const
Get the nvsg::CullCode of this CullData.

NVSG_API unsigned int | getNumberOfChildren (void) const
Get the number of children of this CullData.

Protected Member Functions

virtual NVSG_API | ~CullData (void)
Destructor.

Related Functions

(Note that these are not member functions.)

NVSG_API CullData * | clone (const CullData *rhs)
Clone a CullData by performing deep copy operation.

bool | operator== (const CullData &lhs, const CullData &rhs)
Test two CullData for beeing equal.

bool | operator!= (const CullData &lhs, const CullData &rhs)
Test two CullData for beeing unequal.

Detailed Description

Class holding culling information of an object and it's children.

Namespace: nvsg
Remarks:
With CullData, a CullTraverser can build a (somewhat simplified) mirror of the scene tree. Each CullData object corresponds to one object in a scene tree. Such a CullData tree is used in the Traverser to determine if parts of the scene tree are to be traversed.
See also:
CullCode, nvtraverser::CullTraverser, nvtraverser::FrustumCullTraverser, nvtraverser::Traverser

Constructor & Destructor Documentation

NVSG_API CullData ( CullCode cullCode )

Constructor with nvsg::CullCode.

Parameters:
cullCode Code to be associated with this CullData.
See also:
CullCode

virtual NVSG_API ~CullData ( void ) [protected, virtual]

Destructor.

Member Function Documentation

NVSG_API void balance ( void )

Balance the tree beneath this CullData.

Remarks:
After having constructed a CullData tree, it might be of value to improve it. When this CullData has a nvsg::CullCode of CC_PART, and all it's children have a nvsg::CullCode of CC_IN, this function removes these children and changes the CullData to CC_IN, thus simplifying the CullData tree.
See also:
addChild, getChild, getCullCode

void addChild ( CullData * cd ) [inline]

Add a child to this CullData.

Parameters:
cd A pointer to the CullData to add to the back of this CullData's childrens.
Remarks:
CullData represent a somewhat simplified mirror of a scene tree. If this is the CullData of an object in a scene tree with the nvsg::CullCode CC_PART, and that object has children, this should get the same number of children as that object in the scene tree, each representing the CullData of the corresponding child.
If the nvsg::CullCode of this is CC_IN or CC_OUT, it need not have to have corresponding children, because the in/out determination is obviously valid for all children of that scene tree object.
See also:
getChild, getCullCode

const CullData * getChild ( unsigned int i ) const [inline]

Get the i'th child of this CullData.

Parameters:
i The Index of the child to get.
Returns:
A pointer to the constant CullData of the i'th child.
See also:
addChild

CullCode getCullCode ( void ) const [inline]

Get the nvsg::CullCode of this CullData.

Returns:
The nvsg::CullCode of this CullData.

unsigned int getNumberOfChildren ( void ) const [inline]

Get the number of children of this CullData.

Returns:
The number of children of this CullData.
Remarks:
The number of children of this CullDat should be zero (if the nvsg::CullCode is CC_IN or CC_OUT), or the same as the number of children of the scene tree object that this CullData has the nvsg::CullCode for.
See also:
addChild, getChild, getCullCode

Friends And Related Function Documentation

NVSG_API CullData * clone ( const CullData * rhs ) [related]

Clone a CullData by performing deep copy operation.

Parameters:
rhs A pointer to the constant CullData to clone.
Returns:
A pointer to the cloned CullData.

bool operator== | ( | const CullData & | lhs,
 |  | const CullData & | rhs
 | ) | [related]

Test two CullData for beeing equal.

Parameters:
lhs | A reference to the constant left hand side of the comparison.
rhs | A reference to the constant right hand side of the comparison.
Returns:
true, if the two CullData are equal, otherwise false.
Remarks:
Two CullData are considered to be equal, if they have the same nvsg::CullCode and the same number of children, and each of the children are pairwise equal.
See also:
CullData

bool operator!= | ( | const CullData & | lhs,
 |  | const CullData & | rhs
 | ) | [related]

Test two CullData for beeing unequal.

Parameters:
lhs | A reference to the constant left hand side of the comparison.
rhs | A reference to the constant right hand side of the comparison.
Returns:
true, if the two CullData are unequal, otherwise false.
Remarks:
Two CullData are considered to be equal, if they have the same nvsg::CullCode and the same number of children, and each of the children are pairwise equal.
See also:
CullData

The documentation for this class was generated from the following file:
  • CullData.h
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


Member List

CullData Member List

This is the complete list of members for CullData, including all inherited members.
addChild(CullData *cd) | CullData | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
balance(void) | CullData |
clone(const CullData *rhs) | CullData | [related]
CullData(CullCode cullCode) | CullData |
getChild(unsigned int i) const | CullData | [inline]
getCullCode(void) const | CullData | [inline]
getNumberOfChildren(void) const | CullData | [inline]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator!=(const CullData &lhs, const CullData &rhs) | CullData | [related]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator==(const CullData &lhs, const CullData &rhs) | CullData | [related]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~CullData(void) | CullData | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


CullTraverser Class Reference

Base class for culling parts of a scene. More...

#include <CullTraverser.h>

Inheritance diagram for CullTraverser:

[legend]
Collaboration diagram for CullTraverser:

[legend]
List of all members.

Protected Member Functions

NVSG_API | CullTraverser ()
Protected default constructor to prevent explicit creation.

virtual NVSG_API | ~CullTraverser (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Overrides SharedModelViewTraverser::doApply.

virtual NVSG_API void | postApply (nvsg::NodeHandle *root)
Overrides SharedModelViewTraverser::postApply.

virtual NVSG_API nvsg::CullCode | cullCode (const nvmath::Sphere3f &bs) const
Retrieves the CullCode of a bounding sphere.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Processes a Billboard for culling.

virtual NVSG_API void | handleFlipbookAnimation (const nvsg::FlipbookAnimation *p)
Processes a FlipbookAnimation for culling.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Processes a GeoNode for culling.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Processes a Group for culling.

virtual NVSG_API void | handleLOD (const nvsg::LOD *p)
Processes a LOD node for culling.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *p)
Processes a Switch for culling.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Processes a Transform for culling.

virtual NVSG_API void | handleVolumeNode (const nvsg::VolumeNode *p)
Processes a VolumeNode for culling.

virtual NVSG_API void | handleShape (const nvsg::Shape *p)
Processes a Shape for culling.

virtual NVSG_API void | traversePrimitiveSet (const nvsg::PrimitiveSet *p)
Processes PrimitiveSet for culling.

NVSG_API unsigned short | getCurrentHints () const
Retrieves the hints of the currently processed Node.

NVSG_API unsigned short | getCurrentHintsContainment () const
Retrieves the hints containment bits of the currently processed Node.

Detailed Description

Base class for culling parts of a scene.

Namespace: nvsg
Remarks:
This is the base class for a culling traverser. A CullTraverser creates a tree of nvsg::CullData, representing the culled tree. After completion, that tree of nvsg::CullData is put into the nvsg::ViewState. From then on, the Traverser pays respect to that cull tree.
That said, it is easy to concatenate two or more culling traversers, by just applying them sequentially to the scene. In each culling traversal the cull tree from a previous culling is used, that is only the cull state of objects being at least partially in are to be determined by subsequent CullTraverser traversals.
A Traverser derived from CullTraverser essentially has to override the function cullCode().
See also:
FrustumCullTraverser, ModelViewTraverser

Constructor & Destructor Documentation

NVSG_API CullTraverser ( ) [protected]

Protected default constructor to prevent explicit creation.

virtual NVSG_API ~CullTraverser ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the CullTraverser is decremented to zero.

Member Function Documentation

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Overrides SharedModelViewTraverser::doApply.

Parameters:
root Specifies the Node where to start traversal.
Remarks:
This function gets called from the Traverser framework immediately after traversal was initiated by invoking Traverser::apply. This override calls its base class for traversal, and after traversal has been completed, it evaluates the resulting cull tree. If the root is found to be trivial in, the cull tree will be dismissed.
See also:
CullData, nvsg::Node, ModelViewTraverser, nvsg::ViewState

Reimplemented from SharedTraverser.

Reimplemented in FrustumCullTraverser.

virtual NVSG_API void postApply ( nvsg::NodeHandle * root ) [protected, virtual]

Overrides SharedModelViewTraverser::postApply.

Parameters:
root Specifies the Node where traversal has started.
Remarks:
The function gets called by the Traverser framework immediately after traversal has been completed. If a valid cull tree was built during traversal, it will be assigned to the ViewState that previously was assigned to the Traverser throught Traverser::setViewState. In addition this function marks the root as dirty, if the root's LOD state has changed.

Reimplemented from Traverser.

virtual NVSG_API nvsg::CullCode cullCode ( const nvmath::Sphere3f & bs ) const [protected, virtual]

Retrieves the CullCode of a bounding sphere.

Parameters:
bs Specifies the bounding sphere to consider for CullCode determination.
Returns:
The nvsg::CullCode of the bounding sphere bs.
Remarks:
The default implementation returns the nvsg::CullCode CC_IN.

Reimplemented in FrustumCullTraverser, and NodeHintsCullTraverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Processes a Billboard for culling.

Parameters:
p Specifies the Billboard to process.
Remarks:
If the Billboard is recognized as partly visible, the function goes on traversing the children of the Billboard. After the children have been traversed, the function initiates a post-processing of the particular CullData that were generated per child, and registers them for culling.
See also:
handleGroup, handleLOD, handleSwitch, handleTransform

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleFlipbookAnimation ( const nvsg::FlipbookAnimation * p ) [protected, virtual]

Processes a FlipbookAnimation for culling.

Parameters:
p Specifies the FlipbookAnimation to process.
Remarks:
If the FlipbookAnimation is recognized as partly visible, the function goes on traversing the current child, depending on the animation frame. After that child has been traversed, the function initiates a post-processing of the particular CullData that was generated for that child, and registers it for culling.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Processes a GeoNode for culling.

Parameters:
p Specifies the GeoNode to process.
Remarks:
If the GeoNode is recognized as partly visible, the function goes on traversing the Drawables of the GeoNode. After the Drawables have been traversed, the function initiates a post-processing of the particular CullData that were generated per Drawable, and registers them for culling.
See also:
traverseShape, traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Processes a Group for culling.

Parameters:
p Specifies the Group to process.
Remarks:
If the Group is recognized as partly visible, the function goes on traversing the children of the Group. After the children have been traversed, the function initiates a post-processing of the particular CullData that were generated per child, and registers them for culling.
See also:
handleBillboard, handleLOD, handleSwitch, handleTransform

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Processes a LOD node for culling.

Parameters:
p Specifies the LOD to process.
Remarks:
If the LOD is recognized as partly visible, the function goes on traversing the actually used level of the LOD. After the used level has been traversed, the function initiates a post-processing of the particular CullData that was generated for that level, and registers them for culling. For unused levels, CullData with trivial-out CullCode will be registered.
See also:
handleBillboard, handleGroup, handleSwitch, handleTransform

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Processes a Switch for culling.

Parameters:
p Specifies the Switch to process.
Remarks:
If the Switch is recognized as partly visible, the function goes on traversing the active children of the Switch. After the active children have been traversed, the function initiates a post-processing of the particular CullData that were generated per active child, and registers them for culling. For inactive children, CullData with trivial-out CullCode (CC_OUT) will be registered.
See also:
handleBillboard, handleGroup, handleLOD, handleTransform

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Processes a Transform for culling.

Parameters:
p Specifies the Transform to process.
Remarks:
If the Transform is recognized as partly visible, the function goes on traversing the children of the Transform. After the children have been traversed, the function initiates a post-processing of the particular CullData that were generated per child, and registers them for culling.
See also:
handleBillboard, handleGroup, handleLOD, handleSwitch

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleVolumeNode ( const nvsg::VolumeNode * p ) [protected, virtual]

Processes a VolumeNode for culling.

Parameters:
p Specifies the VolumeNode to process.
Remarks:
The function generates CullData for the specified VolumeNode. The generated CullData will be stored and post-processed by the handler function of the particular parent of the VolumeNode.
See also:
handleGroup, handleTransform

Reimplemented from SharedTraverser.

virtual NVSG_API void handleShape ( const nvsg::Shape * p ) [protected, virtual]

Processes a Shape for culling.

Parameters:
p Specifies the Shape to process.
Remarks:
If the Shape is recognized as partly visible, the function goes on traversing the PrimitiveSets of the Shape. After the PrimitiveSets have been traversed, the function initiates a post-processing of the particular CullData that were generated per PrimitiveSet, and registers them for culling.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void traversePrimitiveSet ( const nvsg::PrimitiveSet * p ) [protected, virtual]

Processes PrimitiveSet for culling.

Parameters:
p Specifies the PrimitiveSet to process.
Remarks:
The function generates CullData for the specified PrimitiveSet. The generated CullData will be stored and post-processed by the handler function of the particular owner of the PrimitiveSet.
See also:
handleGeoNode, handleShape

Reimplemented from SharedTraverser.

unsigned short getCurrentHints ( ) const [inline, protected]

Retrieves the hints of the currently processed Node.

Returns:
The hint bits of the currently processed Node.
Remarks:
On traversal, the hints and the hints containment of each Node is stored in this CullTraverser, to have access to it in functions that don't have a direct access to that Node, like cullCode.
See also:
getCurrentHintsContainment

unsigned short getCurrentHintsContainment ( ) const [inline, protected]

Retrieves the hints containment bits of the currently processed Node.

Returns:
The hints containment bits of the currently handled Node.
Remarks:
On traversal, the hints and the hints containment of each Node is stored in this CullTraverser, to have access to it in functions that don't have a direct access to that Node, like cullCode.
See also:
getCurrentHints

The documentation for this class was generated from the following file:
  • CullTraverser.h
Generated on Tue Jan 15 10:29:28 2008 for NVSGSDK by NVIDIA


Member List

CullTraverser Member List

This is the complete list of members for CullTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
cullCode(const nvmath::Sphere3f &bs) const | CullTraverser | [protected, virtual]
CullTraverser() | CullTraverser | [protected]
doApply(nvsg::NodeHandle *root) | CullTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
getCurrentHints() const | CullTraverser | [inline, protected]
getCurrentHintsContainment() const | CullTraverser | [inline, protected]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SharedModelViewTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | SharedTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | CullTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *p) | CullTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | CullTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | CullTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | SharedTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | SharedTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | CullTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | SharedTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | SharedTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | SharedTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | SharedTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | CullTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *variant) | SharedTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | CullTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | CullTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | SharedTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | SharedTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | SharedTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SharedTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *p) | CullTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedModelViewTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedCamera | SharedModelViewTraverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | SharedModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | CullTraverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | SharedModelViewTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | SharedModelViewTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedModelViewTraverser() | SharedModelViewTraverser | [protected]
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | CullTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~CullTraverser(void) | CullTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedModelViewTraverser() | SharedModelViewTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:28 2008 for NVSGSDK by NVIDIA


DALData Class Reference

Device Abstraction Link Data. More...

#include <DAL.h>

Inheritance diagram for DALData:

[legend]
List of all members.

Public Member Functions

NVSG_API unsigned int | getUserID () const
Get the user ID of this DALData.

NVSG_API void | setUserID (unsigned int userID)
Set the user ID of this DALData.

NVSG_API bool | verifyCreator (const DALDataCreator *creator) const
Verifies if this DALData was created by the indicated creator.

Protected Member Functions

DALData (DALDataCreator *creator)
Constructs a DALData object.

virtual void | deleteThis ()
Induces the deletion of this DALData object.

Detailed Description

Device Abstraction Link Data.

Namespace: nvsg
Remarks:
DALData can be used to abstract device dependent data that will be linked to device independent data via a Device Abstraction Link (DAL).

Note that only a DALDataCreator is permitted to create DALData. DALData can be attached to a DAL using the interface of a DALHost.
See also:
DALHost, DALDataCreator

Constructor & Destructor Documentation

DALData ( DALDataCreator * creator ) [protected]

Constructs a DALData object.

Parameters:
creator Pointer to the DALDataCreator that creates, end hence, owns the data.
Remarks:
After DALData has been created it can be attached to Device Abstraction Link hosted by a DALHost using DALHost::storeDeviceAbstractionLink.

Member Function Documentation

unsigned int getUserID ( ) const [inline]

Get the user ID of this DALData.

Returns:
The current user ID of this DALData.
Remarks:
A DALData can hold an userID. The default value is 0. This ID can be used to identify special informations for this DALData.

For example, the CPUSkinningProcessor sets this ID to 'CPUS' in the array buffer caches, that hold the data for the skinned VertexAttributeSets. The GPUSkinningProcessor, in turn, tests if any array buffer cache of a VertexAttributeSet already available. If it is not zero, it is refilled with the (unskinned) data of that VertexAttributeSet.
See also:
setUserID

void setUserID ( unsigned int userID ) [inline]

Set the user ID of this DALData.

Parameters:
userID The user ID to use.
Remarks:
A DALData can hold an userID. The default value is 0. This ID can be used to identify special informations for this DALData.

See also:
getUserID

bool verifyCreator ( const DALDataCreator * creator ) const [inline]

Verifies if this DALData was created by the indicated creator.

Parameters:
creator Specifies the creator to test.
Returns:
The function returns true if this DALData was created by creator. Otherwise, it returns false. Use this function to check whether a DALData was created by a specific creator. This in particular is useful to verify if a DALData can be safely used in a given context.

virtual void deleteThis ( void ) [inline, protected, virtual]

Induces the deletion of this DALData object.

Remarks:
This function will be called from the DALServer framework when this DALData object is going to be released from a Device Abstraction Link hosted by a DALHost.

The default implementation calls delete on this pointer. If a custom memory manager is used, in particular a memory manager that does not issue new and delete for creating and deleting a DALData object, it is recommended to override this function so that the deletion of the DALData object will be performed correctly.

The documentation for this class was generated from the following file:
  • DAL.h
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


Member List

DALData Member List

This is the complete list of members for DALData, including all inherited members.
DALData(DALDataCreator *creator) | DALData | [protected]
deleteThis() | DALData | [inline, protected, virtual]
getUserID() const | DALData | [inline]
setUserID(unsigned int userID) | DALData | [inline]
verifyCreator(const DALDataCreator *creator) const | DALData | [inline]
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


DALDataCreator Class Reference

Represents the interface required for a creator of DALData. More...

#include <DAL.h>

Inheritance diagram for DALDataCreator:

[legend]
List of all members.

Public Member Functions

virtual void | onReleaseDAL (HDAL hDAL)
Called from the framework immediately before the Device Abstraction Link (DAL) becomes invalid.

Protected Member Functions

NVSG_API void | releaseDeviceAbstractionLinkData (HDAL hDAL, unsigned int dataID)
Releases Device Abstraction Link Data.

Detailed Description

Represents the interface required for a creator of DALData.

Namespace: nvsg
Remarks:
Objects that create DALData to attach it to a Device Abstraction Link (DAL) hosted by a DALHost must derive from this base class.

Member Function Documentation

virtual void onReleaseDAL ( HDAL hDAL ) [inline, virtual]

Called from the framework immediately before the Device Abstraction Link (DAL) becomes invalid.

Parameters:
hDAL Handle to the Device Abstraction Link that is about to become invalid.
Remarks:
Called from the framework to inform creators that the DAL identified by hDAL immediately becomes invalid. For example, this is the case when the object that hosts the DAL will be deleted.

A concrete DALDataCreator usually overrides this function to dismiss all temporary stored handles to the DALs that the DALDataCreator has attached DALData to. A DAL handle will be returned to a DALDataCreator when it attaches DALdata to the DALHost through DALHost::storeDeviceAbstractionLinkData.

Note that the creator must not explicitly delete the attached data! The deletion of the attached data will be performed by the framework, immediately after this function was called.

void releaseDeviceAbstractionLinkData | ( | HDAL | hDAL,
 |  | unsigned int | dataID
 | ) | [inline, protected]

Releases Device Abstraction Link Data.

Parameters:
hDAL | Handle to the Device Abstraction Link the data to release is attached to.
dataID | Identifies the kind of data to release.
Remarks:
Releases the data identified by dataID that was attached to the Device Abstraction Link identified by hDAL.

This function should be called by the creator immediately before this creator becomes invalid, to free all the data of kind dataID that was created by this DALDataCreator and attached to the DAL identified by hDAL. The function deletes the data and removes the according entry from the DAL.

The documentation for this class was generated from the following file:
  • DAL.h
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


Member List

DALDataCreator Member List

This is the complete list of members for DALDataCreator, including all inherited members.
onReleaseDAL(HDAL hDAL) | DALDataCreator | [inline, virtual]
releaseDeviceAbstractionLinkData(HDAL hDAL, unsigned int dataID) | DALDataCreator | [inline, protected]
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


DALHost Class Reference

Represents an object capable to host a Device Abstraction Link. More...

#include <DAL.h>

List of all members.

Public Member Functions

NVSG_API HDAL | storeDeviceAbstractionLinkData (unsigned int dataID, DALData *data)
Stores Device Abstraction Link Data.

NVSG_API void | releaseDeviceAbstractionLinkData ()
Releases Device Abstraction Link data.

template<typename DALDataType, typename TestFunc> bool | getDeviceAbstractionLinkData (unsigned int dataID, DALDataType *&cache, TestFunc test) const
Retrieves Devices Abstraction Link data from the DALHost.

NVSG_API DALData * | getLastRecentlyUsedDeviceAbstractionLinkData () const
Returns the Device Abstraction Link data that was queried last.

Detailed Description

Represents an object capable to host a Device Abstraction Link.

Namespace: nvsg
Remarks:
A DALHost is intended to host a Device Abstraction Link (DAL) to attach arbitrary DALData. A DAL links device or platform dependent DALData created by a DALDataCreator to an independent DALHost.

An Object, for example, 'is a' DALHost.

Member Function Documentation

HDAL storeDeviceAbstractionLinkData | ( | unsigned int | dataID,
 |  | DALData * | data
 | ) | [inline]

Stores Device Abstraction Link Data.

Parameters:
dataID | Identifies the kind of data to store. This is so the user can identify the kind of data, especially when stored data will be retrieved later.
data | Pointer to the DALData to store.
Returns:
The function returns a handle that identifies the Device Abstraction Link the stored data is associated with. If the function fails, HDAL_INVALID will be returned.
Remarks:
The function attaches the DALData identified by dataID, and pointed to by data. Different DALDataCreators can store data with the same dataID. In turn, a certain DALDataCreator can retrieve DALData stored by a different DALDataCreator. That is, two or more DALDataCreators can share DALData if appropriate. For example, a particular OpenGL renderer (nvutil::GLTraverser) might use OpenGL specific texture information that was stored to a certain TextureImage by another OpenGL renderer, provided the two renderers share their render contexts.

Use DALHost::getDeviceAbstractionLinkData to retrieve particular data from the DALHost.

The handle to the Device Abstraction Link (DAL) that will be returned by the function must be stored by the DALDataCreator. This handle is used, for example, to communicate to the DALDataCreator that a certain DAL hosted by a DALHost has been destroyed, and hence, stored DALData has been released as a consequence (DALDataCreator::onReleaseDAL). Or, in turn, if a DALDataCreator needs to dismiss stored DALData, this handle is used to identify the DAL that is associated to that particular data.

The behavior is undefined if invalid DALData is passed. The behavior also is undefined if the DALData pointed to by data already is hosted by another host!
See also:
DALHost::getDeviceAbstractionLinkData, DALData, DALDataCreator

void releaseDeviceAbstractionLinkData ( ) [inline]

Releases Device Abstraction Link data.

Remarks:
The function releases the host's internal Device Abstraction link with all DALData attached to it. In turn, the particular DALDataCreator will be informed that the DALData they stored with this host became invalid, so the creator can dismiss the stored handles they received at the time they stored the data using DALHost::storeDeviceAbstractionLinkData.
See also:
DALHost::storeDeviceAbstractionLinkData

bool getDeviceAbstractionLinkData | ( | unsigned int | dataID,
 |  | DALDataType *& | cache,
 |  | TestFunc | test
 | ) | const [inline]

Retrieves Devices Abstraction Link data from the DALHost.

Parameters:
dataID | Identifies the kind of data to retrieve.
cache | Reference to a pointer to DALData that receives the pointer to the stored DALData.
test | A test function of the form 'bool test(const DALDataType*)' to be applied on the requested DALData.
Returns:
The function returns true if the DALData could have been retrieved successfully. Otherwise, the function returns false.
Remarks:
DALDataCreators can use this function to retrieve back DALData they previously stored using DALHost::storeDeviceAbstractionLinkData. For this, a creator needs to pass the same dataID as used with DALHost::storeDeviceAbstractionLinkData. In addition, the creator must specify a test function of the form 'bool test(const DALDataType *)'.

The function looks up the DALData by the dataID and, if found, passes that data to the test function. If the test function returns true, the pointer to the particular DALData will be assigned to cache and the function returns true.

The reason why the test function is needed here is so that different creators can store different data having the same data ID. The test function verifies that specific data is the right data the caller is looking for. A concrete example would be some texture information that was created by one renderer and used by some other renderer.
See also:
DALHost::getLastRecentlyUsedDeviceAbstractionLinkData

DALData * getLastRecentlyUsedDeviceAbstractionLinkData ( ) const [inline]

Returns the Device Abstraction Link data that was queried last.

Returns:
The function returns a pointer to the DALData that was successfully queried last.
Remarks:
If particular, DALData could have queried successfully using DALHost::getDeviceAbstractionLinkData, so the pointer to that data is cached as the most recently used data. For performance reasons, it is recommended to always call this function prior to DALHost::getDeviceAbstractionLinkData with DALData queries.
Example:
The following code example shows how the nvtraverser::GLTraverser queries a given nvsg::PrimitiveSet for a probably attached display list information structure.
 // isDLInfoValid is used as test function while querying DLInfo data attached to a DALHost,
 // which in this particular case is a PrimitiveSet
 bool GLTraverser::isDLInfoValid(const GLTraverser::DLInfo* info)
 { // a DLInfo is valid if the name of the display list object
   // is known by the current GL render context
   return glContext==info->context // we are fine if the current context corresponds the info's context
         || !!GLIsList(info->listID); // if not, we need to go deeper
 }

 // getCachedDLInfo queries a given PrimitiveSet for DLInfo that might be attached to the
 // PrimitiveSet earlier
 GLTraverser::DLInfo * GLTraverser::getCachedDLInfo( const PrimitiveSet *p ) const
 {
   DLInfo * dlInfo = dynamic_cast<DLInfo*>(p->getLastRecentlyUsedDeviceAbstractionLinkData());

   if ( !dlInfo || !isDLInfoValid(dlInfo) )
   {
     // the last recently queried data is not valid for us, we need to go deeper
     p->getDeviceAbstractionLinkData(GL_DL, dlInfo, &GLTraverser::isDLInfoValid);
   }
   return( dlInfo );
 }
See also:
DALHost::getDeviceAbstractionLinkData

The documentation for this class was generated from the following file:
  • DAL.h
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


Member List

DALHost Member List

This is the complete list of members for DALHost, including all inherited members.
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) | DALHost | [inline]
Generated on Tue Jan 15 10:29:02 2008 for NVSGSDK by NVIDIA


DenormalizedNormalsResult Class Reference

AnalyzeResult indicating a VertexAttributeSet with denormalized normals. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for DenormalizedNormalsResult:

[legend]
Collaboration diagram for DenormalizedNormalsResult:

[legend]
List of all members.

Public Attributes

unsigned int | denormalizedNormalsCount
The number of objects with denormalized normals.

unsigned int | denormalizedNormalsNumber
The number of denormalized normals in those objects.

Detailed Description

AnalyzeResult indicating a VertexAttributeSet with denormalized normals.

Namespace: nvsg
Remarks:
Reports if there is a VertexAttributeSet with denormalized normals.
See also:
AnalyzeResult, AnalyzeTraverser

Member Data Documentation

unsigned int denormalizedNormalsCount

The number of objects with denormalized normals.

unsigned int denormalizedNormalsNumber

The number of denormalized normals in those objects.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


Member List

DenormalizedNormalsResult Member List

This is the complete list of members for DenormalizedNormalsResult, including all inherited members.
denormalizedNormalsCount | DenormalizedNormalsResult |
denormalizedNormalsNumber | DenormalizedNormalsResult |
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~DenormalizedNormalsResult() (defined in DenormalizedNormalsResult) | DenormalizedNormalsResult | [inline, virtual]
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


DepthAttribute Class Reference

StateAttribute that determines the depth settings to use. More...

#include <DepthAttribute.h>

Inheritance diagram for DepthAttribute:

[legend]
Collaboration diagram for DepthAttribute:

[legend]
List of all members.

Public Member Functions

NVSG_API | DepthAttribute ()
Default-constructs a DepthAttribute.

NVSG_API | DepthAttribute (const StateAttribute &rhs)
Constructs a DepthAttribute from a StateAttribute.

NVSG_API | DepthAttribute (const DepthAttribute &rhs)
Constructs a DepthAttribute as a copy from another DepthAttribute.

virtual NVSG_API | ~DepthAttribute ()
Destructs a DepthAttribute.

NVSG_API nvsg::DepthFunction | getDepthFunction () const
Get the nvsg::DepthFunction of this DepthAttribute.

NVSG_API void | setDepthFunction (nvsg::DepthFunction df)
Set the nvsg::DepthFunction of this DepthAttribute.

NVSG_API bool | isDepthWritingEnabled () const
Ask if depth buffer writing is enabled.

NVSG_API void | setDepthWritingEnabled (bool enabled)
Enable or disable depth buffer testing.

NVSG_API bool | isDepthTestingEnabled () const
Ask if depth buffer testing is enabled.

NVSG_API void | setDepthTestingEnabled (bool enabled)
Enable or disable depth buffer testing.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another DepthAttribute.

NVSG_API DepthAttribute & | operator= (const DepthAttribute &rhs)
Assignment operator.

Detailed Description

StateAttribute that determines the depth settings to use.

Namespace: nvsg
Remarks:
A DepthAttribute defines a nvsg::DepthFunction for the depth test and determines if the depth buffer is enabled for testing and/or writing.
By default, the nvsg::DepthFunction is DF_LESS, the depth buffer is enabled for testing and writing.
Note:
In the transparent part of the rendering pass, depth buffer writing is disabled, and can't be changed by a DepthAttribute.
See also:
BlendAttribute, DepthFunction, Material, StateAttribute

Constructor & Destructor Documentation

NVSG_API DepthAttribute ( )

Default-constructs a DepthAttribute.

Remarks:
The defaults of a DepthAttribute is DF_LESS for the depth function, depth buffer write enabled, and a depth range from 0.0 to 1.0.

NVSG_API DepthAttribute ( const StateAttribute & rhs ) [explicit]

Constructs a DepthAttribute from a StateAttribute.

Parameters:
rhs StateAttribute to construct the DepthAttribute from.
Remarks:
The DepthAttribute will be initialized with DF_LESS for the depth function, depth buffer write enabled, and a depth range from 0.0 to 1.0.

NVSG_API DepthAttribute ( const DepthAttribute & rhs )

Constructs a DepthAttribute as a copy from another DepthAttribute.

virtual NVSG_API ~DepthAttribute ( ) [virtual]

Destructs a DepthAttribute.

Member Function Documentation

DepthFunction getDepthFunction ( ) const [inline]

Get the nvsg::DepthFunction of this DepthAttribute.

Returns:
The nvsg::DepthFunction of this DepthAttribute.
See also:
nvsg::DepthFunction, setDepthFunction

NVSG_API void setDepthFunction ( nvsg::DepthFunction df )

Set the nvsg::DepthFunction of this DepthAttribute.

Parameters:
df The nvsg::DepthFunction to use.
See also:
nvsg::DepthFunction, getDepthFunction

bool isDepthWritingEnabled ( ) const [inline]

Ask if depth buffer writing is enabled.

Returns:
true, if depth buffer writing is enabled, otherwise false.
See also:
isDepthTestingEnabled, setDepthWritingEnabled

NVSG_API void setDepthWritingEnabled ( bool enabled )

Enable or disable depth buffer testing.

Parameters:
enabled If true, depth buffer testing is enabled, otherwise it is disabled.
See also:
isDepthWritingEnabled, setDepthTestingEnabled

bool isDepthTestingEnabled ( ) const [inline]

Ask if depth buffer testing is enabled.

Returns:
true, if depth buffer testing is enabled, otherwise false.
See also:
isDepthWritingEnabled, setDepthTestingEnabled

NVSG_API void setDepthTestingEnabled ( bool enabled )

Enable or disable depth buffer testing.

Parameters:
enabled If true, depth buffer testing is enabled, otherwise it is disabled.
See also:
isDepthTestingEnabled, setDepthWritingEnabled

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another DepthAttribute.

Parameters:
p | Pointer to the constant DepthAttribute to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true
deepCompare | Optional parameter to perform a deep comparsion; default is false
Returns:
true if the DepthAttribute p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as StateAttribute, they are considered to be equivalent if they the same nvsg::DepthFunction and the same state of depth buffer testing and writing.
See also:
StateAttribute, getDepthFunction, isDepthTestingEnabled, isDepthWritingEnabled

Reimplemented from Object.

NVSG_API DepthAttribute& operator= ( const DepthAttribute & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant DepthAttribute to copy from
Returns:
A reference to the assigned DepthAttribute
Remarks:
The assignment operator calls the assignment operator of StateAttribute and copies the DepthAttribute specific data then.
See also:
PrimitiveAttribute

The documentation for this class was generated from the following file:
  • DepthAttribute.h
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


Member List

DepthAttribute Member List

This is the complete list of members for DepthAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
DepthAttribute() | DepthAttribute |
DepthAttribute(const StateAttribute &rhs) | DepthAttribute | [explicit]
DepthAttribute(const DepthAttribute &rhs) | DepthAttribute |
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getDepthFunction() const | DepthAttribute | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isDepthTestingEnabled() const | DepthAttribute | [inline]
isDepthWritingEnabled() const | DepthAttribute | [inline]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | DepthAttribute | [virtual]
isTransparent(void) const | StateAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const DepthAttribute &rhs) | DepthAttribute |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setDepthFunction(nvsg::DepthFunction df) | DepthAttribute |
setDepthTestingEnabled(bool enabled) | DepthAttribute |
setDepthWritingEnabled(bool enabled) | DepthAttribute |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~DepthAttribute() | DepthAttribute | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


DestrippingTraverser Class Reference

Traverser to destripify stripped primitives. More...

#include <DestrippingTraverser.h>

Inheritance diagram for DestrippingTraverser:

[legend]
Collaboration diagram for DestrippingTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | DestrippingTraverser (void)
Default Constructor.

Protected Member Functions

virtual NVSG_API | ~DestrippingTraverser (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Override of the doApply method.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *p)
Destripify the strips of this nvsg::GeoNode.

virtual NVSG_API void | handleLineStrips (nvsg::LineStrips *p)
Gather the nvsg::LineStrips to destrip.

virtual NVSG_API void | handleQuadStrips (nvsg::QuadStrips *p)
Gather the nvsg::QuadStrips to destrip.

virtual NVSG_API void | handleTriFans (nvsg::TriFans *p)
Gather the nvsg::TriFans to destrip.

virtual NVSG_API void | handleTriStrips (nvsg::TriStrips *p)
Gather the nvsg::TriStrips to destrip.

Detailed Description

Traverser to destripify stripped primitives.

Namespace: nvsg
Remarks:
This Traverser destripifies nvsg::TriFans and nvsg::TriStrips to nvsg::Triangles, nvsg::QuadStrips to nvsg::Quads, and nvsg::LineStrips to nvsg::Lines.
Using good nvsg::TriStrips usually is more efficient than using nvsg::Triangles, but often it is more efficient to use nvsg::Triangles instead of badly stripped nvsg::TriStrips. That is, it might be worth to try to destrip all the nvsg::TriStrips to nvsg::Triangles. The same holds for the other primitive types.
See also:
OptimizeTraverser

Constructor & Destructor Documentation

NVSG_API DestrippingTraverser ( void )

Default Constructor.

Remarks:
A DestrippingTraverser potentially modifies the tree of the scene.

virtual NVSG_API ~DestrippingTraverser ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the DestrippingTraverser is decremented to zero.

Member Function Documentation

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Override of the doApply method.

Parameters:
root A pointer to the constant nvsg::NodeHandle to destripify.
Remarks:
The doApply method is the traversal entry point of a Traverser. Clears temporarily used data structures after traversing.
See also:
nvsg::Scene, Traverser

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * p ) [protected, virtual]

Destripify the strips of this nvsg::GeoNode.

Parameters:
p A pointer to the constant nvsg::GeoNode whose strips are to be destripified.
Remarks:
All nvsg::TriFans and nvsg::TriStrips of this nvsg::GeoNode are destripified to nvsg::Triangles, all nvsg::QuadStrips to nvsg::Quads, and all nvsg::LineStrips to nvsg::Lines.
See also:
handleLineStrips, handleQuadStrips, handleTriFans, handleTriStrips

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLineStrips ( nvsg::LineStrips * p ) [protected, virtual]

Gather the nvsg::LineStrips to destrip.

Parameters:
p A pointer to the constant nvsg::LineStrip to destrip.
See also:
handleQuadStrips, handleTriFans, handleTriStrips

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadStrips ( nvsg::QuadStrips * p ) [protected, virtual]

Gather the nvsg::QuadStrips to destrip.

Parameters:
p A pointer to the constant nvsg::QuadStrips to destrip.
See also:
handleLineStrips, handleTriFans, handleTriStrips

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriFans ( nvsg::TriFans * p ) [protected, virtual]

Gather the nvsg::TriFans to destrip.

Parameters:
p A pointer to the constant nvsg::TriFans to destrip.
See also:
handleLineStrips, handleQuadStrips, handleTriStrips

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriStrips ( nvsg::TriStrips * p ) [protected, virtual]

Gather the nvsg::TriStrips to destrip.

Parameters:
p A pointer to the constant nvsg::TriStrips to destrip.
See also:
handleLineStrips, handleQuadStrips, handleTriFans

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • DestrippingTraverser.h
Generated on Tue Jan 15 10:29:29 2008 for NVSGSDK by NVIDIA


Member List

DestrippingTraverser Member List

This is the complete list of members for DestrippingTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
DestrippingTraverser(void) | DestrippingTraverser |
doApply(nvsg::NodeHandle *root) | DestrippingTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *p) | DestrippingTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *p) | DestrippingTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *p) | DestrippingTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *p) | DestrippingTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *p) | DestrippingTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~DestrippingTraverser(void) | DestrippingTraverser | [protected, virtual]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:29 2008 for NVSGSDK by NVIDIA


DirectedLight Class Reference

LightSource representing a directed light. More...

#include <DirectedLight.h>

Inheritance diagram for DirectedLight:

[legend]
Collaboration diagram for DirectedLight:

[legend]
List of all members.

Public Member Functions

NVSG_API | DirectedLight ()
Default-constructs a DirectedLight.

NVSG_API | DirectedLight (const LightSource &rhs)
Constructs a DirectedLight from a LightSource.

NVSG_API | DirectedLight (const DirectedLight &rhs)
Constructs a PointLight as a copy of another PointLight.

virtual NVSG_API | ~DirectedLight ()
Destructs a PointLight.

NVSG_API nvmath::Vec3f | getDirection () const
Get the direction of the light rays.

NVSG_API void | setDirection (const nvmath::Vec3f &direction)
Set the direction of the light rays.

NVSG_API const nvmath::Quatf & | getOrientation () const
Get the orientation of the light rays.

NVSG_API void | setOrientation (const nvmath::Quatf &orientation)
Set the orientation of the light rays.

NVSG_API DirectedLight & | operator= (const DirectedLight &rhs)
Assignment operator.

Detailed Description

LightSource representing a directed light.

Namespace: nvsg
Remarks:
A DirectedLight is a LightSource with a direction (or orientation), but without a position. Its light is emitted along parallel rays from an infinite distance away.
See also:
LightSource, PointLight, SpotLight

Constructor & Destructor Documentation

NVSG_API DirectedLight ( )

Default-constructs a DirectedLight.

NVSG_API DirectedLight ( const LightSource & rhs ) [explicit]

Constructs a DirectedLight from a LightSource.

Parameters:
rhs LightSource to construct the DirectedLight from.
Remarks:
This is kind of a partial copy constructor only copying the LightSource part from the source object.

NVSG_API DirectedLight ( const DirectedLight & rhs )

Constructs a PointLight as a copy of another PointLight.

virtual NVSG_API ~DirectedLight ( ) [virtual]

Destructs a PointLight.

Member Function Documentation

nvmath::Vec3f getDirection ( ) const [inline]

Get the direction of the light rays.

Returns:
The direction of the light rays.
Remarks:
The default direction is the negative z-axis (0.0,0.0,-1.0).
See also:
getOrientation, setDirection

NVSG_API void setDirection ( const nvmath::Vec3f & direction )

Set the direction of the light rays.

Parameters:
direction A reference to the constant direction of the light rays.
Remarks:
The default direction is the negative z-axis (0.0,0.0,-1.0).
Setting the direction increases the Incarnation.
See also:
getDirection, setOrientation

const nvmath::Quatf & getOrientation ( ) const [inline]

Get the orientation of the light rays.

Returns:
The reference to the constant orientation of the light rays.
Remarks:
The orientation is the rotation from the default light direction, the negative z-axis (0.0,0.0,-1.0).
See also:
getDirection, setOrientation

NVSG_API void setOrientation ( const nvmath::Quatf & orientation )

Set the orientation of the light rays.

Parameters:
orientation A reference to the constant orientation of the light rays.
Remarks:
The orientation is the rotation from the default light direction, the negative z-axis (0.0,0.0,-1.0).
Setting the orientation increases the Incarnation.
See also:
getOrientation, setDirection

NVSG_API DirectedLight& operator= ( const DirectedLight & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant DirectedLight to copy from
Returns:
A reference to the assigned DirectedLight
Remarks:
The assignment operator just calls the assignment operator of LightSource.
See also:
LightSource

The documentation for this class was generated from the following file:
  • DirectedLight.h
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


Member List

DirectedLight Member List

This is the complete list of members for DirectedLight, including all inherited members.
addOwner(typename GroupHandle::ObjectType *obj) | OwnedObject< GroupHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< GroupHandle > | [protected]
DirectedLight() | DirectedLight |
DirectedLight(const LightSource &rhs) | DirectedLight | [explicit]
DirectedLight(const DirectedLight &rhs) | DirectedLight |
enterCS() const | Object | [inline, protected]
getAmbientColor() const | LightSource | [inline]
getAnimation() const | LightSource | [inline]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getDiffuseColor() const | LightSource | [inline]
getDirection() const | DirectedLight | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIntensity() const | LightSource | [inline]
getInverse() const | LightSource | [inline]
getName() const | Object |
getNumberOfOwners() const | OwnedObject< GroupHandle > |
getObjectCode() const | Object | [inline]
getOrientation() const | DirectedLight | [inline]
getOwner(unsigned int index) const | OwnedObject< GroupHandle > |
getSpecularColor() const | LightSource | [inline]
getTransformationMatrix() const | LightSource | [inline]
getUserData() const | Object | [inline]
invalidateAnimationContainment() | LightSource |
invalidateIncarnation() | OwnedObject< GroupHandle > | [virtual]
isDataShared() const | Object | [virtual]
isEnabled() const | LightSource | [inline]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LightSource | [virtual]
isShadowCasting() const | LightSource | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
LightSource() | LightSource | [protected]
LightSource(const LightSource &rhs) | LightSource | [protected]
m_objectCode | Object | [protected]
m_trafo | LightSource | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const DirectedLight &rhs) | DirectedLight |
nvsg::LightSource::operator=(const LightSource &rhs) | LightSource | [protected]
nvsg::OwnedObject< GroupHandle >::operator=(const OwnedObject< GroupHandle > &rhs) | OwnedObject< GroupHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< GroupHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< GroupHandle > | [protected]
OwnedObject(const OwnedObject< GroupHandle > &rhs) | OwnedObject< GroupHandle > | [protected]
OwnerIterator typedef | OwnedObject< GroupHandle > | [protected]
ownersBegin() const | OwnedObject< GroupHandle > | [inline, protected]
ownersBegin() | OwnedObject< GroupHandle > | [inline, protected]
ownersEnd() const | OwnedObject< GroupHandle > | [inline, protected]
ownersEnd() | OwnedObject< GroupHandle > | [inline, protected]
removeOwner(typename GroupHandle::ObjectType *obj) | OwnedObject< GroupHandle > | [protected]
setAmbientColor(const nvmath::Vec3f &color) | LightSource | [inline]
setAnimation(TrafoAnimationHandle *animation) | LightSource |
setAnnotation(const std::string &anno) | Object |
setDiffuseColor(const nvmath::Vec3f &color) | LightSource | [inline]
setDirection(const nvmath::Vec3f &direction) | DirectedLight |
setEnabled(bool enable) | LightSource | [inline]
setIntensity(float intensity) | LightSource | [inline]
setName(const std::string &name) | Object |
setOrientation(const nvmath::Quatf &orientation) | DirectedLight |
setShadowCasting(bool cast) | LightSource | [inline]
setSpecularColor(const nvmath::Vec3f &color) | LightSource | [inline]
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | LightSource | [virtual]
~DirectedLight() | DirectedLight | [virtual]
~LightSource() | LightSource | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< GroupHandle > | [protected]
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


Drawable Class Reference

The abstract base class of all drawable objects. More...

#include <Drawable.h>

Inheritance diagram for Drawable:

[legend]
Collaboration diagram for Drawable:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~Drawable (void)
Destructs a Drawable.

NVSG_API const nvmath::Box3f & | getBoundingBox () const
Returns the bounding box of this Drawable.

NVSG_API const nvmath::Sphere3f & | getBoundingSphere () const
Returns the bounding sphere of this Drawable.

NVSG_API void | invalidateBoundingVolumes ()
Invalidate the bounding volumes of this Drawable.

NVSG_API void | invalidateAnimationContainment ()
Invalidate the containment of an animation.

virtual NVSG_API bool | containsAnimation () const
Interface to determine if an Object contains an animation.

NVSG_API void | attachHighlightObject (HighlightObjectHandle *obj=NULL)
Attach a HighlightObject to this Drawable.

NVSG_API HighlightObjectHandle * | getHighlightObject (void) const
Get the attached HighlightObject.

virtual NVSG_API bool | validateIncarnation () const
Validate the nvutil::Incarnation.

Protected Member Functions

NVSG_API | Drawable (void)
Protected constructor to prevent explicit creation.

NVSG_API | Drawable (const Drawable &)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const=0
Interface for calculating the bounding sphere of this Drawable.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const=0
Interface for calculating the bounding sphere of this Drawable.

NVSG_API Drawable & | operator= (const Drawable &rhs)
Assignment operator.

Detailed Description

The abstract base class of all drawable objects.

Namespace: nvsg
Remarks:
All drawable objects like PrimitiveSet or Shape derive from Drawable.
When deriving from Drawable, you have to overload the member functions clone(), and calculateBoundingSphere(). Moreover, you can overload containsAnimation(), validateIncarnation(), and invalidateIncarnation().
See also:
nvutil::Incarnation, OwnedObject, PrimitiveSet, Shape

Constructor & Destructor Documentation

virtual NVSG_API ~Drawable ( void ) [virtual]

Destructs a Drawable.

NVSG_API Drawable ( void ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
Because Drawable is an abstract class, its constructor is never used explicitly, but in the constructor of derived classes.
See also:
PrimitiveSet, Shape

NVSG_API Drawable ( const Drawable & ) [protected]

Protected copy constructor to prevent explicit creation.

Remarks:
Because Drawable is an abstract class, its constructor is never used explicitly, but in the constructor of derived classes.
See also:
PrimitiveSet, Shape

Member Function Documentation

NVSG_API const nvmath::Box3f& getBoundingBox ( ) const

Returns the bounding box of this Drawable.

Returns:
Returns the axis-aligned bounding box of the concrete Drawable object.

NVSG_API const nvmath::Sphere3f& getBoundingSphere ( ) const

Returns the bounding sphere of this Drawable.

Returns:
A sphere that bounds the complete Drawable.
Remarks:
If the current bounding sphere is marked invalid, the function calls the virtual function calculateBoundingSphere to determine the actual bounding sphere. If a HiglightObject is attached to the Drawable, it will also be considered for bounding sphere calculation. After the bounding sphere has been calculated it will be marked as valid.
See also:
attachHighlightObject, calculateBoundingSphere, invalidateBoundingVolumes

NVSG_API void invalidateBoundingVolumes ( )

Invalidate the bounding volumes of this Drawable.

Remarks:
The function invalidates the bounding volumes up the tree hierarchy.
See also:
HighlightObject, calculateBoundingSphere, getBoundingSphere calculateBoundingBox, getBoundingBox

NVSG_API void invalidateAnimationContainment ( )

Invalidate the containment of an animation.

Remarks:
The animation containment of all the owners is invalidated.

Reimplemented in PrimitiveSet.

virtual NVSG_API bool containsAnimation ( ) const [virtual]

Interface to determine if an Object contains an animation.

Returns:
false, as a Drawable never can contain an animation.

Reimplemented in PrimitiveSet, and SkinnedTriangles.

NVSG_API void attachHighlightObject ( HighlightObjectHandle * obj = NULL )

Attach a HighlightObject to this Drawable.

Parameters:
obj Optional pointer to the handle to the HighlightObject to attach. Default is NULL.
Remarks:
If obj is not NULL, it is validated and its reference count is increased. The reference count of any previously attached HighlightObject is decreased. The bounding sphere of this Drawable is invalidated, because the new HighlightObject might influence that.
See also:
HighlightObject, getHighlightObject

HighlightObjectHandle * getHighlightObject ( void ) const [inline]

Get the attached HighlightObject.

Returns:
A pointer to the handle to the attached HighlightObject.
See also:
attachHighlightObject

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this Drawable is requested but marked as invalid. Then it is validated and the nvutil::Incarnation of any HighlightObject is requested to continue the validation down the tree hierarchy.
See also:
HighlightObject, nvutil::Incarnation, invalidateIncarnation

Reimplemented from Object.

Reimplemented in PrimitiveSet, Shape, and SkinnedTriangles.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, pure virtual]

Interface for calculating the bounding sphere of this Drawable.

Returns:
The function returns an axis-aligned bounding box of the Drawable.
Remarks:
This function is called by the framework as a request to calculate the bounding box of the concrete Drawable. This function must be implemented by each derived class.

Implemented in IndependentPrimitiveSet, MeshedPrimitiveSet, Shape, and StrippedPrimitiveSet.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, pure virtual]

Interface for calculating the bounding sphere of this Drawable.

Returns:
A nvmath::Sphere3f that contains the complete Drawable.
Remarks:
This function is called by the framework to determine a sphere that completely contains the Drawable. Every concrete class deriving from Drawable has to implement this function.
See also:
getBoundingSphere, invalidateBoundingVolumes

Implemented in IndependentPrimitiveSet, MeshedPrimitiveSet, Shape, and StrippedPrimitiveSet.

NVSG_API Drawable& operator= ( const Drawable & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant Drawable to copy from
Returns:
A reference to the assigned Drawable
Remarks:
The assignment operator calls the assignment operator of OwnedObject and copies the bounding sphere.
Note:
If rhs has a HighlightObject attached, this is not copied. If this has a HighlightObject attached, its reference count is decremented and it is detached.
See also:
HighlightObject, OwnedObject

The documentation for this class was generated from the following file:
  • Drawable.h
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


Member List

Drawable Member List

This is the complete list of members for Drawable, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const=0 | Drawable | [protected, pure virtual]
calculateBoundingSphere() const=0 | Drawable | [protected, pure virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | Drawable | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getUserData() const | Object | [inline]
invalidateAnimationContainment() | Drawable |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Drawable | [virtual]
~Drawable(void) | Drawable | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


EliminateTraverser Class Reference

Traverser that eliminates a number of Objects, if appropriate. More...

#include <EliminateTraverser.h>

Inheritance diagram for EliminateTraverser:

[legend]
Collaboration diagram for EliminateTraverser:

[legend]
List of all members.

Public Types

enum {
ET_GROUP = BIT0, ET_LOD = BIT1, ET_STATE_PASS = BIT2, ET_STATE_SET = BIT3,
ET_STATE_VARIANT = BIT4, ET_TEXTURE_ATTRIBUTE = BIT5, ET_TEXTURE_ATTRIBUTE_ITEM = BIT6, ET_ALL_TARGETS_MASK
}

Public Member Functions

NVSG_API | EliminateTraverser (void)
Constructor.

NVSG_API unsigned int | getEliminateTargets () const
Get the bitmask describing the targets to eliminate.

NVSG_API void | setEliminateTargets (unsigned int mask)
Set the bitmask describing the targets to eliminate.

Public Attributes

enum nvtraverser::EliminateTraverser:: { ... } | EliminateTarget

Protected Member Functions

virtual NVSG_API | ~EliminateTraverser (void)
Protected destructor to prevent instantiation of a EliminateTraverser on stack.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
If the root node is a Group with a single child, it is removed.

virtual NVSG_API void | handleAnimatedTransform (nvsg::AnimatedTransform *p)
If the AnimatedTransform holds other Groups without lights or clip planes, they are replaced by their children.

virtual NVSG_API void | handleBillboard (nvsg::Billboard *p)
If the Billboard holds Groups without lights or clip planes, they are replaced by their children.

virtual NVSG_API void | handleFlipbookAnimation (nvsg::FlipbookAnimation *p)
Traverse a FlipbookAnimation like a Group.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *p)
Handler function for a GeoNode.

virtual NVSG_API void | handleGroup (nvsg::Group *p)
If the Group holds other Groups without lights or clip planes, they are replaced by their children.

virtual NVSG_API void | handleLOD (nvsg::LOD *p)
If the LOD holds Groups with one child without lights or clip planes, they are replaced by their respective child.

virtual NVSG_API void | handleStatePass (nvsg::StatePass *p)
Handler function for a StatePass.

virtual NVSG_API void | handleStateSet (nvsg::StateSet *p)
Handler function for a StateSet.

virtual NVSG_API void | handleStateVariant (nvsg::StateVariant *p)
Handler function for a StateVariant.

virtual NVSG_API void | handleSwitch (nvsg::Switch *p)
If the Switch holds Groups with one child without lights or clip planes, they are replaced by their respective child.

virtual NVSG_API void | handleTextureAttribute (nvsg::TextureAttribute *p)
Handler function for a TextureAttribute.

virtual NVSG_API void | handleTransform (nvsg::Transform *p)
If the Transform holds Groups without lights or clip planes, they are replaced by their children.

Detailed Description

Traverser that eliminates a number of Objects, if appropriate.

Remarks:
There are a number of different object types that can be eliminated:
  • A Group, that is a child of a Group or a Transform, and that does not hold clip planes or lights, can be replaced by its children.
  • A Group, that is a child of an LOD or a Switch or is the root node of the tree, and that does not hold clip planes or lights, but exactly one child, can be replaced by that child.
  • An LOD, that holds exactly one child (and no ranges) can be replaced by that child.
  • A StateSet that holds no StateVariants can be removed.
  • A StateVariant that holds no StatePasses can be removed.
See also:

Member Enumeration Documentation

anonymous enum

Enumeration values:
ET_GROUP | EliminateTarget Group: replace redundant Groups by their child/children.
ET_LOD | EliminateTarget LOD: replace redundant LODs by its child.
ET_STATE_PASS | EliminateTarget StatePass: remove StatePasses without any StateAttributes.
ET_STATE_SET | EliminateTarget StateSet: remove StateSets without any StateVariants.
ET_STATE_VARIANT | EliminateTarget StateVariant: remove StateVariants with any StatePasses.
ET_TEXTURE_ATTRIBUTE | EliminateTarget TextureAttribute: remove TextureAttributes without any TextureAttributeItems.
ET_TEXTURE_ATTRIBUTE_ITEM | EliminateTarget TextureAttributeItem: unbind TextureAttributeItems without a TextureImage.

Constructor & Destructor Documentation

NVSG_API EliminateTraverser ( void )

Constructor.

virtual NVSG_API ~EliminateTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a EliminateTraverser on stack.

Member Function Documentation

unsigned int getEliminateTargets ( ) const [inline]

Get the bitmask describing the targets to eliminate.

Returns:
A bitmask describing the targets to eliminate.

void setEliminateTargets ( unsigned int mask ) [inline]

Set the bitmask describing the targets to eliminate.

Parameters:
mask The bitmask describing the targets to eliminate.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

If the root node is a Group with a single child, it is removed.

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleAnimatedTransform ( nvsg::AnimatedTransform * p ) [protected, virtual]

If the AnimatedTransform holds other Groups without lights or clip planes, they are replaced by their children.

An AnimatedTransform is handled as a Transform.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleBillboard ( nvsg::Billboard * p ) [protected, virtual]

If the Billboard holds Groups without lights or clip planes, they are replaced by their children.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleFlipbookAnimation ( nvsg::FlipbookAnimation * p ) [protected, virtual]

Traverse a FlipbookAnimation like a Group.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * p ) [protected, virtual]

Handler function for a GeoNode.

Parameters:
gnode A pointer to the write-locked GeoNode being traversed.
Remarks:
This function is called from the framework whenever a GeoNode is encountered on traversal. The GeoNode gnode is already write-locked.
The base implementation just calls Traverser::traverseGeoNode().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGeoNode

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGroup ( nvsg::Group * p ) [protected, virtual]

If the Group holds other Groups without lights or clip planes, they are replaced by their children.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLOD ( nvsg::LOD * p ) [protected, virtual]

If the LOD holds Groups with one child without lights or clip planes, they are replaced by their respective child.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleStatePass ( nvsg::StatePass * p ) [protected, virtual]

Handler function for a StatePass.

Parameters:
pass A pointer to the write-locked StatePass being traversed.
Remarks:
This function is called from the framework whenever a StateSet is encountered on traversal. The StatePass pass is already write-locked.
The base implementation just call Traverser::traverseStatePass().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseStatePass

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleStateSet ( nvsg::StateSet * p ) [protected, virtual]

Handler function for a StateSet.

Parameters:
stateSet A pointer to the write-locked StateSet being traversed.
Remarks:
This function is called from the framework whenever a StateSet is encountered on traversal. The StateSet stateSet is already write-locked.
The base implementation just traverses the active StateVariant.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
StateVariant

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleStateVariant ( nvsg::StateVariant * p ) [protected, virtual]

Handler function for a StateVariant.

Parameters:
variant A pointer to the write-locked StateVariant being traversed.
Remarks:
This function is called from the framework whenever a StateVariant is encountered on traversal. The StateVariant variant is already write-locked.
The base implementation just call Traverser::traverseStateVariant().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseStateVariant

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleSwitch ( nvsg::Switch * p ) [protected, virtual]

If the Switch holds Groups with one child without lights or clip planes, they are replaced by their respective child.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTextureAttribute ( nvsg::TextureAttribute * p ) [protected, virtual]

Handler function for a TextureAttribute.

Parameters:
texAttrib A pointer to the write-locked TextureAttribute being traversed.
Remarks:
This function is called from the framework whenever a TextureAttribute is encountered on traversal. The TextureAttribute texAttrib is already write-locked.
The base implementation just calls Traverser::traverseTextureAttribute().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseTextureAttribute

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTransform ( nvsg::Transform * p ) [protected, virtual]

If the Transform holds Groups without lights or clip planes, they are replaced by their children.

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • EliminateTraverser.h
Generated on Tue Jan 15 10:29:29 2008 for NVSGSDK by NVIDIA


Member List

EliminateTraverser Member List

This is the complete list of members for EliminateTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | EliminateTraverser | [protected, virtual]
EliminateTarget (defined in EliminateTraverser) | EliminateTraverser |
EliminateTraverser(void) | EliminateTraverser |
ET_ALL_TARGETS_MASK enum value (defined in EliminateTraverser) | EliminateTraverser |
ET_GROUP enum value | EliminateTraverser |
ET_LOD enum value | EliminateTraverser |
ET_STATE_PASS enum value | EliminateTraverser |
ET_STATE_SET enum value | EliminateTraverser |
ET_STATE_VARIANT enum value | EliminateTraverser |
ET_TEXTURE_ATTRIBUTE enum value | EliminateTraverser |
ET_TEXTURE_ATTRIBUTE_ITEM enum value | EliminateTraverser |
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getEliminateTargets() const | EliminateTraverser | [inline]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *p) | EliminateTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *p) | EliminateTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *p) | EliminateTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *p) | EliminateTraverser | [protected, virtual]
handleGroup(nvsg::Group *p) | EliminateTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *p) | EliminateTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *p) | EliminateTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *p) | EliminateTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *p) | EliminateTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *p) | EliminateTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *p) | EliminateTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *p) | EliminateTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setEliminateTargets(unsigned int mask) | EliminateTraverser | [inline]
setIgnoreNames(bool ignore) | OptimizeTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~EliminateTraverser(void) | EliminateTraverser | [protected, virtual]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:29 2008 for NVSGSDK by NVIDIA


EmptyResult Class Reference

AnalyzeResult indicating an empty object. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for EmptyResult:

[legend]
Collaboration diagram for EmptyResult:

[legend]
List of all members.

Public Member Functions

virtual | ~EmptyResult ()
Virtual Destructor.

Public Attributes

unsigned int | emptyCount
The number of empty objects of this type.

Detailed Description

AnalyzeResult indicating an empty object.

Namespace: nvsg
Remarks:
All empty object in the tree (e.g. Groups without children, Triangles without indices,...) are reported with an EmptyResult.
See also:
AnalyzeResult, AnalyzeTraverser

Constructor & Destructor Documentation

virtual ~EmptyResult ( ) [inline, virtual]

Virtual Destructor.

Member Data Documentation

unsigned int emptyCount

The number of empty objects of this type.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


Member List

EmptyResult Member List

This is the complete list of members for EmptyResult, including all inherited members.
emptyCount | EmptyResult |
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~EmptyResult() | EmptyResult | [inline, virtual]
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


EquivalenceResult Class Reference

AnalyzeResult indicating equivalent objects. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for EquivalenceResult:

[legend]
Collaboration diagram for EquivalenceResult:

[legend]
List of all members.

Public Member Functions

virtual | ~EquivalenceResult ()
Virtual Destructor.

Public Attributes

unsigned int | equivalentCount
The number of equivalent objects of this type.

unsigned int | reducedCount
The number of objects of this type, if equivalent objects would be combined.

Detailed Description

AnalyzeResult indicating equivalent objects.

Namespace: nvsg
Remarks:
All equivalent objects in the tree (e.g. StateAttributes with the same settings) are reported with an EquivalenceResult.
See also:
AnalyzeResult, AnalyzeTraverser

Constructor & Destructor Documentation

virtual ~EquivalenceResult ( ) [inline, virtual]

Virtual Destructor.

Member Data Documentation

unsigned int equivalentCount

The number of equivalent objects of this type.

unsigned int reducedCount

The number of objects of this type, if equivalent objects would be combined.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


Member List

EquivalenceResult Member List

This is the complete list of members for EquivalenceResult, including all inherited members.
equivalentCount | EquivalenceResult |
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
reducedCount | EquivalenceResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~EquivalenceResult() | EquivalenceResult | [inline, virtual]
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


ExclusiveModelViewTraverser Class Reference

Traverser that can handle the model view transform stack. More...

#include <ModelViewTraverser.h>

Inheritance diagram for ExclusiveModelViewTraverser:

[legend]
Collaboration diagram for ExclusiveModelViewTraverser:

[legend]
List of all members.

Protected Member Functions

NVSG_API | ExclusiveModelViewTraverser ()
Protected constructor to prevent instantiation of a ModelViewTraverser.

virtual NVSG_API | ~ExclusiveModelViewTraverser ()
Protected destructor to prevent instantiation of a ExclusiveModelViewTraverser.

virtual NVSG_API void | handleAnimatedTransform (nvsg::AnimatedTransform *p)
Provide special treatment of an AnimatedTransform node.

virtual NVSG_API void | handleBillboard (nvsg::Billboard *p)
Provide special treatment of a Billboard node.

virtual NVSG_API void | handleLOD (nvsg::LOD *lod)
Handler function for an LOD.

virtual NVSG_API void | handleTransform (nvsg::Transform *p)
Provide special treatment of a Transform node.

virtual NVSG_API bool | preTraverseTransform (const nvmath::Trafo *p)
Handles actions to take between transform stack adjustment and traversal.

virtual NVSG_API void | postTraverseTransform (const nvmath::Trafo *p)
Handles actions to take between traversal and transform stack adjustment.

virtual NVSG_API void | traverseCamera (nvsg::Camera *camera)
Handle any type of Camera on traversal.

virtual NVSG_API void | lockViewState ()
Override for locking the ViewState.

virtual NVSG_API void | unlockViewState ()
Override for unlocking the ViewState.

Protected Attributes

nvsg::Camera * m_lockedCamera
write-locked camera

nvutil::TransformStack m_transformStack
stack of transformations that holds the actual transformations while traversing a tree

Detailed Description

Traverser that can handle the model view transform stack.

Use this class as a base for traversers that need to maintain the current model view transformation.

Note:
All ModelViewTraverser based classes need a valid nvsg::ViewState . If the ViewState is not valid the runtime behaviour is not defined. Call setViewState() with a valid ViewState prior calling apply().

Constructor & Destructor Documentation

NVSG_API ExclusiveModelViewTraverser ( ) [protected]

Protected constructor to prevent instantiation of a ModelViewTraverser.

Note:
A ExclusiveModelViewTraverser doesn't change anything in the scene graph, but might be used by a modifying traverser. therefore, it gets the readOnly flag as a parameter to pass to Traverser.

virtual NVSG_API ~ExclusiveModelViewTraverser ( ) [protected, virtual]

Protected destructor to prevent instantiation of a ExclusiveModelViewTraverser.

Member Function Documentation

virtual NVSG_API void handleAnimatedTransform ( nvsg::AnimatedTransform * p ) [protected, virtual]

Provide special treatment of an AnimatedTransform node.

An AnimatedTransform is handled as a Transform.

Parameters:
p currently visited AnimatedTransform

Reimplemented from ExclusiveTraverser.

Reimplemented in AppTraverser, and BalanceTraverser.

virtual NVSG_API void handleBillboard ( nvsg::Billboard * p ) [protected, virtual]

Provide special treatment of a Billboard node.

On a Billboard the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Parameters:
p Billboard to handle

Reimplemented from ExclusiveTraverser.

Reimplemented in BalanceTraverser.

virtual NVSG_API void handleLOD ( nvsg::LOD * lod ) [protected, virtual]

Handler function for an LOD.

Parameters:
lod A pointer to the write-locked LOD being traversed.
Remarks:
This function is called from the framework whenever an LOD is encountered on traversal. The LOD lod is already write-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented from ExclusiveTraverser.

Reimplemented in BalanceTraverser.

virtual NVSG_API void handleTransform ( nvsg::Transform * p ) [protected, virtual]

Provide special treatment of a Transform node.

On a Transform the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Parameters:
p Transform to handle

Reimplemented from ExclusiveTraverser.

Reimplemented in AppTraverser, and BalanceTraverser.

virtual NVSG_API bool preTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handles actions to take between transform stack adjustment and traversal.

In this base class, this is a NOP.

Parameters:
p Trafo of node to traverse next

Reimplemented in AppTraverser.

virtual NVSG_API void postTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handles actions to take between traversal and transform stack adjustment.

When this function returns true, the subtree beneath is traversed. Otherwise it isn't.

Returns:
true
Parameters:
p Trafo of node that was traversed immediately before this call.

Reimplemented in AppTraverser.

virtual NVSG_API void traverseCamera ( nvsg::Camera * camera ) [protected, virtual]

Handle any type of Camera on traversal.

Parameters:
camera The write-locked camera to traverse.
Remarks:
This function is called by the framework while traversing any type of Camera. On traversal, no or one camera will be traversed. The stack of transforms is initialized with the world-to-view and the view-to-clip matrices. Moreover, the camera is stored, referenced, and locked for further usage. It will be unlocked and unreferenced in doApply.
See also:
lockCamera, unlockCamera

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void lockViewState ( ) [protected, virtual]

Override for locking the ViewState.

Remarks:
This function is called from the framework when the ViewState set by setViewState is to be locked.
See also:
setViewState, unlockViewState

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void unlockViewState ( ) [protected, virtual]

Override for unlocking the ViewState.

Remarks:
This function is called from the framework when the ViewState set by setViewState is to be unlocked.
See also:
setViewState, lockViewState

Reimplemented from ExclusiveTraverser.

Member Data Documentation

nvsg::Camera* m_lockedCamera [protected]

write-locked camera

nvutil::TransformStack m_transformStack [protected]

stack of transformations that holds the actual transformations while traversing a tree

The documentation for this class was generated from the following file:
  • ModelViewTraverser.h
Generated on Tue Jan 15 10:29:32 2008 for NVSGSDK by NVIDIA


Member List

ExclusiveModelViewTraverser Member List

This is the complete list of members for ExclusiveModelViewTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | ExclusiveTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveModelViewTraverser() | ExclusiveModelViewTraverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *p) | ExclusiveModelViewTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *p) | ExclusiveModelViewTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | ExclusiveTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveModelViewTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *p) | ExclusiveModelViewTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveModelViewTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedCamera | ExclusiveModelViewTraverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | ExclusiveModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | ExclusiveModelViewTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | ExclusiveModelViewTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveModelViewTraverser() | ExclusiveModelViewTraverser | [protected, virtual]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:32 2008 for NVSGSDK by NVIDIA


ExclusiveTraverser Class Reference

Base class providing an interface for read-write traversing of a given scene graph. More...

#include <Traverser.h>

Inheritance diagram for ExclusiveTraverser:

[legend]
Collaboration diagram for ExclusiveTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | ExclusiveTraverser ()
Default constructor.

Protected Member Functions

virtual NVSG_API | ~ExclusiveTraverser ()
Protected Destructor to prevent instantiation.

template<typename T, typename U> void | addObjectHandler (unsigned int objectCode, void(T::*handler)(U *))
Template function to add a handler routine for a new class derived from Object.

template<typename T, typename U, typename V> void | addObjectHandler (unsigned int objectCode, void(T::*handler)(U *, V))
Template function to add a handler routine for a new class derived from Object.

virtual NVSG_API nvsg::Object * | lockObject (nvsg::ObjectHandle *obj)
Override of the object locking interface.

virtual NVSG_API void | unlockObject (nvsg::ObjectHandle *obj)
Override of the object unlocking interface.

virtual NVSG_API void | lockViewState ()
Override of the ViewState locking interface.

virtual NVSG_API void | unlockViewState ()
Override of the ViewState unlocking interface.

virtual NVSG_API void | lockScene ()
Override of the Scene locking interface.

virtual NVSG_API void | unlockScene ()
Override of the Scene unlocking interface.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Override of the traversal initiating interface.

virtual NVSG_API void | handleParallelCamera (nvsg::ParallelCamera *camera)
Handler function for a ParallelCamera.

virtual NVSG_API void | handlePerspectiveCamera (nvsg::PerspectiveCamera *camera)
Handler function for a PerspectiveCamera.

virtual NVSG_API void | handleGroup (nvsg::Group *group)
Handler function for a Group.

virtual NVSG_API void | handleFlipbookAnimation (nvsg::FlipbookAnimation *anim)
Handler function for a FlipbookAnimation.

virtual NVSG_API void | handleTransform (nvsg::Transform *trafo)
Handler function for a Transform.

virtual NVSG_API void | handleAnimatedTransform (nvsg::AnimatedTransform *trafo)
Handler function for an AnimatedTransform.

virtual NVSG_API void | handleLOD (nvsg::LOD *lod)
Handler function for an LOD.

virtual NVSG_API void | handleSwitch (nvsg::Switch *swtch)
Handler function for a Switch.

virtual NVSG_API void | handleBillboard (nvsg::Billboard *billboard)
Handler function for a Billboard.

virtual NVSG_API void | handleDirectedLight (nvsg::DirectedLight *light)
Handler function for a DirectedLight.

virtual NVSG_API void | handlePointLight (nvsg::PointLight *light)
Handler function for a PointLight.

virtual NVSG_API void | handleSpotLight (nvsg::SpotLight *light)
Handler function for a SpotLight.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *gnode)
Handler function for a GeoNode.

virtual NVSG_API void | handleQuads (nvsg::Quads *quads)
Handler function for a Quads.

virtual NVSG_API void | handleTriangles (nvsg::Triangles *triangles)
Handler function for a Triangles.

virtual NVSG_API void | handleSkinnedTriangles (nvsg::SkinnedTriangles *triangles)
Handler function for a SkinnedTriangles.

virtual NVSG_API void | handleLines (nvsg::Lines *lines)
Handler function for a Lines.

virtual NVSG_API void | handlePoints (nvsg::Points *points)
Handler function for a Points.

virtual NVSG_API void | handleQuadMeshes (nvsg::QuadMeshes *meshes)
Handler function for a QuadsMeshes.

virtual NVSG_API void | handleQuadStrips (nvsg::QuadStrips *strips)
Handler function for a QuadStrips.

virtual NVSG_API void | handleTriFans (nvsg::TriFans *fans)
Handler function for a TriFans.

virtual NVSG_API void | handleTriStrips (nvsg::TriStrips *strips)
Handler function for a TriStrips.

virtual NVSG_API void | handleLineStrips (nvsg::LineStrips *strips)
Handler function for a LineStrips.

virtual NVSG_API void | handleShape (nvsg::Shape *shape)
Handler function for a Shape.

virtual NVSG_API void | handleStateSet (nvsg::StateSet *stateSet)
Handler function for a StateSet.

virtual NVSG_API void | handleStateVariant (nvsg::StateVariant *variant)
Handler function for a StateVariant.

virtual NVSG_API void | handleStatePass (nvsg::StatePass *pass)
Handler function for a StatePass.

virtual NVSG_API void | handleCgFx (nvsg::CgFx *cgfx)
Handler function for a CgFx.

virtual NVSG_API void | handleMaterial (nvsg::Material *material)
Handler function for a Material.

virtual NVSG_API void | handleTextureAttribute (nvsg::TextureAttribute *texAttrib)
Handler function for a TextureAttribute.

virtual NVSG_API void | handleTextureAttributeItem (nvsg::TextureAttributeItem *texAttribItem, unsigned int tu)
Handler function for a TextureAttributeItem.

virtual NVSG_API void | handleAlphaTestAttribute (nvsg::AlphaTestAttribute *alphaTestAttrib)
Handler function for a AlphaTestAttribute.

virtual NVSG_API void | handleBlendAttribute (nvsg::BlendAttribute *blendAttrib)
Handler function for a BlendAttribute.

virtual NVSG_API void | handleDepthAttribute (nvsg::DepthAttribute *depthAttrib)
Handler function for a DepthAttribute.

virtual NVSG_API void | handleFaceAttribute (nvsg::FaceAttribute *faceAttrib)
Handler function for a FaceAttribute.

virtual NVSG_API void | handleLightingAttribute (nvsg::LightingAttribute *laAttrib)
Handler function for a LightingAttribute.

virtual NVSG_API void | handleLineAttribute (nvsg::LineAttribute *lineAttrib)
Handler function for a LineAttribute.

virtual NVSG_API void | handlePointAttribute (nvsg::PointAttribute *pointAttrib)
Handler function for a PointAttribute.

virtual NVSG_API void | handleUnlitColorAttribute (nvsg::UnlitColorAttribute *unlitColor)
Handler function for an UnlitColorAttribute.

virtual NVSG_API void | handleMapArray (nvsg::MapArray *mapArray)
Handler function for a MapArray.

virtual NVSG_API void | handleMapElement (nvsg::MapElement *mapElement)
Handler function for a MapElement.

virtual NVSG_API void | handleMapMatrix (nvsg::MapMatrix *mapMatrix)
Handler function for a MapMatrix.

virtual NVSG_API void | handleMapList (nvsg::MapList *mapList)
Handler function for a MapList.

virtual NVSG_API void | handleVertexAttributeSet (nvsg::VertexAttributeSet *vas)
Handler function for a VertexAttributeSet.

virtual NVSG_API void | handleAnimatedVertexAttributeSet (nvsg::AnimatedVertexAttributeSet *avas)
Handler function for an AnimatedVertexAttributeSet.

virtual NVSG_API void | handleSkin (nvsg::Skin *skin)
Handler function for a Skin.

virtual NVSG_API void | handleFramedIndexAnimation (nvsg::FramedAnimation< unsigned int > *anim)
Handler function for a FramedAnimation<unsigned int>.

virtual NVSG_API void | handleFramedTrafoAnimation (nvsg::FramedAnimation< nvmath::Trafo > *trafo)
Handler function for a FramedAnimation<nvmath::Trafo>.

virtual NVSG_API void | handleFramedVertexAttributeAnimation (nvsg::FramedAnimation< nvsg::VertexAttribute > *p)
Handler function for a FramedAnimation<VertexAttribute>.

virtual NVSG_API void | handleLinearInterpolatedTrafoAnimation (nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo)
Handler function for a LinearInterpolatedAnimation<nvmath::Trafo>.

virtual NVSG_API void | handleLinearInterpolatedVertexAttributeAnimation (nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p)
Handler function for a LinearInterpolatedAnimation<VertexAttribute>.

virtual NVSG_API void | handleHighlightBox (nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset)
Handler function for a HighlightBox.

virtual NVSG_API void | handleHighlightEdges (nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset)
Handler function for a HighlightEdges.

virtual NVSG_API void | handleVolumeNode (nvsg::VolumeNode *vnode)
Handler function for a VolumeNode.

virtual NVSG_API void | traverseCamera (nvsg::Camera *camera)
Function for common handling of Camera classes.

virtual NVSG_API void | traverseLight (nvsg::LightSource *light)
Function for common handling of LightSource classes.

virtual NVSG_API void | traversePrimitiveSet (nvsg::PrimitiveSet *pset)
Function for common handling of PrimitiveSet classes.

virtual NVSG_API void | traverseHighlightObject (nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset)
Function for common handling of HighlightObject classes.

Protected Attributes

nvsg::Scene * m_lockedScene
A pointer to the write-locked Scene currently traversed.

nvsg::ViewState * m_lockedViewState
A pointer to the write-locked ViewState used in the current traversal.

Detailed Description

Base class providing an interface for read-write traversing of a given scene graph.

Remarks:
The SharedTraverser class offers base functionality for all traversers that intend to provide read-write operations on a given scene graph. For all known and concrete Objects this class provides a set of overloadable handler routines, each ensuring that all components following the actual object in the graph hierarchy will be traversed correctly. Hence, for derived traversers it is recommended to always call the base implementation of an overloaded handler routine for traversing purposes.
To provide new read-write operations to be applied on known and concrete components or objects arranged in a scene graph, it is sufficient to derive a new traverser from either ExclusiveTraverser or one of its derived traversers, and overload the corresponding handler routines as needed.
See also:
SharedTraverser

Constructor & Destructor Documentation

NVSG_API ExclusiveTraverser ( )

Default constructor.

virtual NVSG_API ~ExclusiveTraverser ( ) [inline, protected, virtual]

Protected Destructor to prevent instantiation.

Member Function Documentation

void addObjectHandler | ( | unsigned int | objectCode,
 |  | void(T::* | handler)(U *)
 | ) | [inline, protected]

Template function to add a handler routine for a new class derived from Object.

Parameters:
objectCode | Object code to identify an object type at run-time.
handler | Specifies the address of the handler routine.
Remarks:
The function registers the handler routine specified by handler to handle a concrete class, derived from Object, that is explicitly identified by objectCode.
A handler routine must be a member function of a Traverser-derived class. It must return void and expect a pointer to the concrete object as a first parameter, and can have one additional (optional) argument of arbitrary type. A handler routine must not have a default argument! If a handler routine is intended to remain overloadable, it should be declared virtual.
For derived classes intended to provide new operations for known objects arranged in a scene graph, it is strongly recommended not to add new handler routines for those objects but to overload the corresponding handler routine. In this context, we refer to 'known objects' as objects that are known by the Traverser base class and for which a corresponding handler routine is provided.
However, addObjectHandler is indispensable if newly invented objects, and hence, objects that are unknown by the Traverser base class, need to be considered for traversing.
Note:
Any previously registered handler routine for the specified object code will be overridden by the new handler.
Example:
    addObjectHandler(
      OC_NEWGROUP   // object code for the new object NewGroup
                    // this must be provided by the author of NewGroup
      , &MyExclusiveTraverser::handleNewGroup // handler function
    );

void addObjectHandler | ( | unsigned int | objectCode,
 |  | void(T::* | handler)(U *, V)
 | ) | [inline, protected]

Template function to add a handler routine for a new class derived from Object.

Parameters:
objectCode | Object code to identify an object type at run-time.
handler | Specifies the address of the handler routine.
Remarks:
The function registers the handler routine specified by handler to handle a concrete class, derived from Object, that is explicitly identified by objectCode.
A handler routine must be a member function of a Traverser-derived class. It must return void and expect a pointer to the concrete object as a first parameter, and can have one additional (optional) argument of arbitrary type. A handler routine must not have a default argument! If a handler routine is intended to remain overloadable, it should be declared virtual.
For derived classes intended to provide new operations for known objects arranged in a scene graph, it is strongly recommended not to add new handler routines for those objects but to overload the corresponding handler routine. In this context, we refer to 'known objects' as objects that are known by the Traverser base class and for which a corresponding handler routine is provided.
However, addObjectHandler is indispensable if newly invented objects, and hence, objects that are unknown by the Traverser base class, need to be considered for traversing.
Note:
Any previously registered handler routine for the specified object code will be overridden by the new handler.
Example:
    addObjectHandler(
      OC_NEWGROUP   // object code for the new object NewGroup
                    // this must be provided by the author of NewGroup
      , &MyExclusiveTraverser::handleNewGroup // handler function
    );

virtual NVSG_API nvsg::Object* lockObject ( nvsg::ObjectHandle * obj ) [protected, virtual]

Override of the object locking interface.

Parameters:
obj A pointer to the ObjectHandle to lock.
Returns:
A pointer to a write-locked Object.
Remarks:
This function is called from the framework just before traversal of obj. The ExclusiveTraverser locks the Object for writing.
See also:
unlockObject

Implements Traverser.

virtual NVSG_API void unlockObject ( nvsg::ObjectHandle * obj ) [protected, virtual]

Override of the object unlocking interface.

Parameters:
obj A pointer to the ObjectHandle to unlock.
Remarks:
This function is called from the framework right after traversal of obj. The ExclusiveTraverser unlocks the Object from writing.
See also:
lockObject

Implements Traverser.

virtual NVSG_API void lockViewState ( ) [protected, virtual]

Override of the ViewState locking interface.

Remarks:
This function is called from the framework to lock the current ViewState, if any, for writing.
See also:
setViewState, unlockViewState

Implements Traverser.

Reimplemented in ExclusiveModelViewTraverser.

virtual NVSG_API void unlockViewState ( ) [protected, virtual]

Override of the ViewState unlocking interface.

Remarks:
This function is called from the framework to unlock the current ViewState, if any, from writing.
See also:
setViewState, lockViewState

Implements Traverser.

Reimplemented in ExclusiveModelViewTraverser.

virtual NVSG_API void lockScene ( ) [protected, virtual]

Override of the Scene locking interface.

Remarks:
This function is called from the framework to lock the current Scene, if any, for writing.
See also:
setScene, unlockScene

Implements Traverser.

virtual NVSG_API void unlockScene ( ) [protected, virtual]

Override of the Scene unlocking interface.

Remarks:
This function is called from the framework to unlock the current Scene, if any, from writing.
See also:
setScene, lockScene

Implements Traverser.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Override of the traversal initiating interface.

Parameters:
root A pointer to the NodeHandle to start traversal at.
Remarks:
This function is called from the framework after the Scene and the ViewState, if set, are locked. The actual traversal is done here.
See also:
preApply, postApply, lockScene, unlockScene, lockViewState, unlockViewState

Implements Traverser.

Reimplemented in WRLLoadTraverser, AppTraverser, DestrippingTraverser, EliminateTraverser, NormalizeTraverser, OptimizeTraverser, SmoothTraverser, UnifyTraverser, and VertexUnifyTraverser.

virtual NVSG_API void handleParallelCamera ( nvsg::ParallelCamera * camera ) [protected, virtual]

Handler function for a ParallelCamera.

Parameters:
camera A pointer to the write-locked ParallelCamera being traversed.
Remarks:
This function is called from the framework whenever a ParallelCamera is encountered on traversal. The ParallelCamera camera is already write-locked.
The base implementation traverses through all the head lights of this camera.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handlePerspectiveCamera

virtual NVSG_API void handlePerspectiveCamera ( nvsg::PerspectiveCamera * camera ) [protected, virtual]

Handler function for a PerspectiveCamera.

Parameters:
camera A pointer to the write-locked PerspectiveCamera being traversed.
Remarks:
This function is called from the framework whenever a PerspectiveCamera is encountered on traversal. The PerspectiveCamera camera is already write-locked.
The base implementation traverses through all the head lights of this camera.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handleParallelCamera

virtual NVSG_API void handleGroup ( nvsg::Group * group ) [protected, virtual]

Handler function for a Group.

Parameters:
group A pointer to the write-locked Group being traversed.
Remarks:
This function is called from the framework whenever a Group is encountered on traversal. The Group group is already write-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup

Reimplemented in WRLLoadTraverser, BalanceTraverser, CombineTraverser, EliminateTraverser, IdentityToGroupTraverser, and UnifyTraverser.

virtual NVSG_API void handleFlipbookAnimation ( nvsg::FlipbookAnimation * anim ) [protected, virtual]

Handler function for a FlipbookAnimation.

Parameters:
anim A pointer to the write-locked FlipbookAnimation being traversed.
Remarks:
This function is called from the framework whenever a FlipbookAnimation is encountered on traversal. The FlipbookAnimation anim is already write-locked.
The base implementation first traverses the associated IndexAnimation, and then calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup, IndexAnimation

Reimplemented in BalanceTraverser, EliminateTraverser, and UnifyTraverser.

virtual NVSG_API void handleTransform ( nvsg::Transform * trafo ) [protected, virtual]

Handler function for a Transform.

Parameters:
trafo A pointer to the write-locked Transform being traversed.
Remarks:
This function is called from the framework whenever a Transform is encountered on traversal. The Transform trafo is already write-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented in WRLLoadTraverser, AppTraverser, BalanceTraverser, CombineTraverser, EliminateTraverser, IdentityToGroupTraverser, ExclusiveModelViewTraverser, and UnifyTraverser.

virtual NVSG_API void handleAnimatedTransform ( nvsg::AnimatedTransform * trafo ) [protected, virtual]

Handler function for an AnimatedTransform.

Parameters:
trafo A pointer to the write-locked AnimatedTransform being traversed.
Remarks:
This function is called from the framework whenever an AnimatedTransform is encountered on traversal. The AnimatedTransform trafo is already write-locked.
The base implementation first traverses the associated TrafoAnimation, and then calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup, TrafoAnimation

Reimplemented in WRLLoadTraverser, AppTraverser, BalanceTraverser, CombineTraverser, EliminateTraverser, IdentityToGroupTraverser, ExclusiveModelViewTraverser, and UnifyTraverser.

virtual NVSG_API void handleLOD ( nvsg::LOD * lod ) [protected, virtual]

Handler function for an LOD.

Parameters:
lod A pointer to the write-locked LOD being traversed.
Remarks:
This function is called from the framework whenever an LOD is encountered on traversal. The LOD lod is already write-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented in NVBLoadTraverser, BalanceTraverser, CombineTraverser, EliminateTraverser, IdentityToGroupTraverser, ExclusiveModelViewTraverser, and UnifyTraverser.

virtual NVSG_API void handleSwitch ( nvsg::Switch * swtch ) [protected, virtual]

Handler function for a Switch.

Parameters:
swtch A pointer to the write-locked Switch being traversed.
Remarks:
This function is called from the framework whenever a Switch is encountered on traversal. The Switch switch is already write-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented in NVBLoadTraverser, BalanceTraverser, EliminateTraverser, IdentityToGroupTraverser, and UnifyTraverser.

virtual NVSG_API void handleBillboard ( nvsg::Billboard * billboard ) [protected, virtual]

Handler function for a Billboard.

Parameters:
billboard A pointer to the write-locked Billboard being traversed.
Remarks:
This function is called from the framework whenever a Billboard is encountered on traversal. The Billboard billboard is already write-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented in WRLLoadTraverser, BalanceTraverser, CombineTraverser, EliminateTraverser, IdentityToGroupTraverser, ExclusiveModelViewTraverser, and UnifyTraverser.

virtual NVSG_API void handleDirectedLight ( nvsg::DirectedLight * light ) [protected, virtual]

Handler function for a DirectedLight.

Parameters:
light A pointer to the write-locked DirectedLight being traversed.
Remarks:
This function is called from the framework whenever a DirectedLight is encountered on traversal. The DirectedLight light is already write-locked.
The base implementation just calls traverseLight().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseLight

virtual NVSG_API void handlePointLight ( nvsg::PointLight * light ) [protected, virtual]

Handler function for a PointLight.

Parameters:
light A pointer to the write-locked PointLight being traversed.
Remarks:
This function is called from the framework whenever a PointLight is encountered on traversal. The PointLight light is already write-locked.
The base implementation just calls traverseLight().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseLight

virtual NVSG_API void handleSpotLight ( nvsg::SpotLight * light ) [protected, virtual]

Handler function for a SpotLight.

Parameters:
light A pointer to the write-locked SpotLight being traversed.
Remarks:
This function is called from the framework whenever a SpotLight is encountered on traversal. The SpotLight light is already write-locked.
The base implementation just calls traverseLight().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseLight

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * gnode ) [protected, virtual]

Handler function for a GeoNode.

Parameters:
gnode A pointer to the write-locked GeoNode being traversed.
Remarks:
This function is called from the framework whenever a GeoNode is encountered on traversal. The GeoNode gnode is already write-locked.
The base implementation just calls Traverser::traverseGeoNode().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGeoNode

Reimplemented in NVBLoadTraverser, AppTraverser, BalanceTraverser, CombineTraverser, DestrippingTraverser, EliminateTraverser, SmoothTraverser, StrippingTraverser, TriangulateTraverser, and UnifyTraverser.

virtual NVSG_API void handleQuads ( nvsg::Quads * quads ) [protected, virtual]

Handler function for a Quads.

Parameters:
quads A pointer to the write-locked Quads being traversed.
Remarks:
This function is called from the framework whenever a Quads is encountered on traversal. The Quads quads is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in BalanceTraverser, CombineTraverser, SmoothTraverser, StrippingTraverser, TriangulateTraverser, and UnifyTraverser.

virtual NVSG_API void handleTriangles ( nvsg::Triangles * triangles ) [protected, virtual]

Handler function for a Triangles.

Parameters:
triangles A pointer to the write-locked Triangles being traversed.
Remarks:
This function is called from the framework whenever a Triangles is encountered on traversal. The Triangles quads is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NVBLoadTraverser, BalanceTraverser, CombineTraverser, SmoothTraverser, StrippingTraverser, and UnifyTraverser.

virtual NVSG_API void handleSkinnedTriangles ( nvsg::SkinnedTriangles * triangles ) [protected, virtual]

Handler function for a SkinnedTriangles.

Parameters:
triangles A pointer to the write-locked Triangles being traversed.
Remarks:
This function is called from the framework whenever a SkinnedTriangles is encountered on traversal. The SkinnedTriangles triangles is already write-locked.
The base implementation first traverses each TrafoAnimation of each bone of each skin, and then calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in AppTraverser, UnifyTraverser, and VertexUnifyTraverser.

virtual NVSG_API void handleLines ( nvsg::Lines * lines ) [protected, virtual]

Handler function for a Lines.

Parameters:
lines A pointer to the write-locked Lines being traversed.
Remarks:
This function is called from the framework whenever a Lines is encountered on traversal. The Lines lines is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in BalanceTraverser, CombineTraverser, and UnifyTraverser.

virtual NVSG_API void handlePoints ( nvsg::Points * points ) [protected, virtual]

Handler function for a Points.

Parameters:
points A pointer to the write-locked Points being traversed.
Remarks:
This function is called from the framework whenever a Points is encountered on traversal. The Points points is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in BalanceTraverser, CombineTraverser, and UnifyTraverser.

virtual NVSG_API void handleQuadMeshes ( nvsg::QuadMeshes * meshes ) [protected, virtual]

Handler function for a QuadsMeshes.

Parameters:
meshes A pointer to the write-locked QuadsMeshes being traversed.
Remarks:
This function is called from the framework whenever a QuadsMeshes is encountered on traversal. The QuadsMeshes meshes is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in BalanceTraverser, CombineTraverser, and UnifyTraverser.

virtual NVSG_API void handleQuadStrips ( nvsg::QuadStrips * strips ) [protected, virtual]

Handler function for a QuadStrips.

Parameters:
strips A pointer to the write-locked QuadStrips being traversed.
Remarks:
This function is called from the framework whenever a QuadStrips is encountered on traversal. The QuadStrips strips is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in BalanceTraverser, CombineTraverser, DestrippingTraverser, SmoothTraverser, TriangulateTraverser, and UnifyTraverser.

virtual NVSG_API void handleTriFans ( nvsg::TriFans * fans ) [protected, virtual]

Handler function for a TriFans.

Parameters:
fans A pointer to the write-locked TriFans being traversed.
Remarks:
This function is called from the framework whenever a TriFans is encountered on traversal. The TriFans fans is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in BalanceTraverser, CombineTraverser, DestrippingTraverser, SmoothTraverser, and UnifyTraverser.

virtual NVSG_API void handleTriStrips ( nvsg::TriStrips * strips ) [protected, virtual]

Handler function for a TriStrips.

Parameters:
strips A pointer to the write-locked TriStrips being traversed.
Remarks:
This function is called from the framework whenever a TriStrips is encountered on traversal. The TriStrips strips is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in BalanceTraverser, CombineTraverser, DestrippingTraverser, SmoothTraverser, and UnifyTraverser.

virtual NVSG_API void handleLineStrips ( nvsg::LineStrips * strips ) [protected, virtual]

Handler function for a LineStrips.

Parameters:
strips A pointer to the write-locked LineStrips being traversed.
Remarks:
This function is called from the framework whenever a LineStrips is encountered on traversal. The LineStrips strips is already write-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in BalanceTraverser, CombineTraverser, DestrippingTraverser, and UnifyTraverser.

virtual NVSG_API void handleShape ( nvsg::Shape * shape ) [protected, virtual]

Handler function for a Shape.

Parameters:
shape A pointer to the write-locked Shape being traversed.
Remarks:
This function is called from the framework whenever a Shape is encountered on traversal. The Shape shape is already write-locked.
The base implementation just calls Traverser::traverseShape().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseShape

virtual NVSG_API void handleStateSet ( nvsg::StateSet * stateSet ) [protected, virtual]

Handler function for a StateSet.

Parameters:
stateSet A pointer to the write-locked StateSet being traversed.
Remarks:
This function is called from the framework whenever a StateSet is encountered on traversal. The StateSet stateSet is already write-locked.
The base implementation just traverses the active StateVariant.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
StateVariant

Reimplemented in NVBLoadTraverser, EliminateTraverser, and UnifyTraverser.

virtual NVSG_API void handleStateVariant ( nvsg::StateVariant * variant ) [protected, virtual]

Handler function for a StateVariant.

Parameters:
variant A pointer to the write-locked StateVariant being traversed.
Remarks:
This function is called from the framework whenever a StateVariant is encountered on traversal. The StateVariant variant is already write-locked.
The base implementation just call Traverser::traverseStateVariant().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseStateVariant

Reimplemented in EliminateTraverser, and UnifyTraverser.

virtual NVSG_API void handleStatePass ( nvsg::StatePass * pass ) [protected, virtual]

Handler function for a StatePass.

Parameters:
pass A pointer to the write-locked StatePass being traversed.
Remarks:
This function is called from the framework whenever a StateSet is encountered on traversal. The StatePass pass is already write-locked.
The base implementation just call Traverser::traverseStatePass().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseStatePass

Reimplemented in EliminateTraverser, and UnifyTraverser.

virtual NVSG_API void handleCgFx ( nvsg::CgFx * cgfx ) [protected, virtual]

Handler function for a CgFx.

Parameters:
cgfx A pointer to the write-locked CgFx being traversed.
Remarks:
This function is called from the framework whenever a CgFx is encountered on traversal. The CgFx cgfx is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NVBLoadTraverser, and AppTraverser.

virtual NVSG_API void handleMaterial ( nvsg::Material * material ) [protected, virtual]

Handler function for a Material.

Parameters:
material A pointer to the write-locked Material being traversed.
Remarks:
This function is called from the framework whenever a Material is encountered on traversal. The Material material is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleTextureAttribute ( nvsg::TextureAttribute * texAttrib ) [protected, virtual]

Handler function for a TextureAttribute.

Parameters:
texAttrib A pointer to the write-locked TextureAttribute being traversed.
Remarks:
This function is called from the framework whenever a TextureAttribute is encountered on traversal. The TextureAttribute texAttrib is already write-locked.
The base implementation just calls Traverser::traverseTextureAttribute().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseTextureAttribute

Reimplemented in EliminateTraverser, and UnifyTraverser.

virtual NVSG_API void handleTextureAttributeItem | ( | nvsg::TextureAttributeItem * | texAttribItem,
 |  | unsigned int | tu
 | ) | [protected, virtual]

Handler function for a TextureAttributeItem.

Parameters:
texAttribItem | A pointer to the write-locked TextureAttributeItem being traversed.
tu | Index of the texture unit to use.
Remarks:
This function is called from the framework whenever a TextureAttributeItem is encountered on traversal. The TextureAttributeItem texAttribItem is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleAlphaTestAttribute ( nvsg::AlphaTestAttribute * alphaTestAttrib ) [protected, virtual]

Handler function for a AlphaTestAttribute.

Parameters:
alphaTestAttrib A pointer to the write-locked AlphaTestAttribute being traversed.
Remarks:
This function is called from the framework whenever a AlphaTestAttribute is encountered on traversal. The AlphaTestAttribute alphaTestAttrib is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleBlendAttribute ( nvsg::BlendAttribute * blendAttrib ) [protected, virtual]

Handler function for a BlendAttribute.

Parameters:
blendAttrib A pointer to the write-locked BlendAttribute being traversed.
Remarks:
This function is called from the framework whenever a BlendAttribute is encountered on traversal. The BlendAttribute blendAttrib is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleDepthAttribute ( nvsg::DepthAttribute * depthAttrib ) [protected, virtual]

Handler function for a DepthAttribute.

Parameters:
depthAttrib A pointer to the write-locked DepthAttribute being traversed.
Remarks:
This function is called from the framework whenever a DepthAttribute is encountered on traversal. The DepthAttribute depthAttrib is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleFaceAttribute ( nvsg::FaceAttribute * faceAttrib ) [protected, virtual]

Handler function for a FaceAttribute.

Parameters:
faceAttrib A pointer to the write-locked FaceAttribute being traversed.
Remarks:
This function is called from the framework whenever a FaceAttribute is encountered on traversal. The FaceAttribute faceAttrib is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleLightingAttribute ( nvsg::LightingAttribute * laAttrib ) [protected, virtual]

Handler function for a LightingAttribute.

Parameters:
laAttrib A pointer to the read-locked LightingAttribute being traversed.
Remarks:
This function is called from the framework whenever a LightingAttribute is encountered on traversal. The LightingAttribute laAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleLineAttribute ( nvsg::LineAttribute * lineAttrib ) [protected, virtual]

Handler function for a LineAttribute.

Parameters:
lineAttrib A pointer to the write-locked LineAttribute being traversed.
Remarks:
This function is called from the framework whenever a LineAttribute is encountered on traversal. The LineAttribute lineAttrib is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handlePointAttribute ( nvsg::PointAttribute * pointAttrib ) [protected, virtual]

Handler function for a PointAttribute.

Parameters:
pointAttrib A pointer to the write-locked PointAttribute being traversed.
Remarks:
This function is called from the framework whenever a PointAttribute is encountered on traversal. The PointAttribute pointAttrib is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleUnlitColorAttribute ( nvsg::UnlitColorAttribute * unlitColor ) [protected, virtual]

Handler function for an UnlitColorAttribute.

Parameters:
unlitColor A pointer to the write-locked UnlitColorAttribute being traversed.
Remarks:
This function is called from the framework whenever an UnlitColorAttribute is encountered on traversal. The UnlitColorAttribute unlitColor is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

virtual NVSG_API void handleMapArray ( nvsg::MapArray * mapArray ) [protected, virtual]

Handler function for a MapArray.

Parameters:
mapArray A pointer to the write-locked MapArray being traversed.
Remarks:
This function is called from the framework whenever a MapArray is encountered on traversal. The MapArray mapArray is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handleMapElement, handleMapMatrix

virtual NVSG_API void handleMapElement ( nvsg::MapElement * mapElement ) [protected, virtual]

Handler function for a MapElement.

Parameters:
mapElement A pointer to the write-locked MapElement being traversed.
Remarks:
This function is called from the framework whenever a MapElement is encountered on traversal. The MapElement mapElement is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handleMapArray, handleMapMatrix

virtual NVSG_API void handleMapMatrix ( nvsg::MapMatrix * mapMatrix ) [protected, virtual]

Handler function for a MapMatrix.

Parameters:
mapMatrix A pointer to the write-locked MapMatrix being traversed.
Remarks:
This function is called from the framework whenever a MapMatrix is encountered on traversal. The MapMatrix mapMatrix is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handleMapArray, handleMapElement

virtual NVSG_API void handleMapList ( nvsg::MapList * mapList ) [protected, virtual]

Handler function for a MapList.

Parameters:
mapList A pointer to the write-locked MapList being traversed.
Remarks:
This function is called from the framework whenever a MapList is encountered on traversal. The MapList mapList is already write-locked.
The base implementation just calls Traverser::traverseMapList().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseMapList

virtual NVSG_API void handleVertexAttributeSet ( nvsg::VertexAttributeSet * vas ) [protected, virtual]

Handler function for a VertexAttributeSet.

Parameters:
vas A pointer to the write-locked VertexAttributeSet being traversed.
Remarks:
This function is called from the framework whenever a VertexAttributeSet is encountered on traversal. The VertexAttributeSet vas is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NormalizeTraverser, UnifyTraverser, and VertexUnifyTraverser.

virtual NVSG_API void handleAnimatedVertexAttributeSet ( nvsg::AnimatedVertexAttributeSet * avas ) [protected, virtual]

Handler function for an AnimatedVertexAttributeSet.

Parameters:
avas A pointer to the write-locked AnimatedVertexAttributeSet being traversed.
Remarks:
This function is called from the framework whenever an AnimatedVertexAttributeSet is encountered on traversal. The AnimatedVertexAttributeSet avas is already write-locked.
The base implementation traverses each VertexAttributeAnimationHandle of avas and holds the index of the currently traversed VertexAttributeAnimationHandle in the protected member variable m_currentAttrib.

Reimplemented in NormalizeTraverser, StrippingTraverser, and UnifyTraverser.

virtual NVSG_API void handleSkin ( nvsg::Skin * skin ) [protected, virtual]

Handler function for a Skin.

Parameters:
skin A pointer to the read-locked Skin being traversed.
Remarks:
This function is called from the framework whenever a Skin is encountered on traversal. The Skin skin is already read-locked.
The base implementation just does nothing.

Reimplemented in StrippingTraverser.

virtual NVSG_API void handleFramedIndexAnimation ( nvsg::FramedAnimation< unsigned int > * anim ) [protected, virtual]

Handler function for a FramedAnimation<unsigned int>.

Parameters:
anim A pointer to the write-locked FramedAnimation<unsigned int> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<unsigned int> is encountered on traversal. The FramedAnimation<unsigned int> anim is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in AppTraverser.

virtual NVSG_API void handleFramedTrafoAnimation ( nvsg::FramedAnimation< nvmath::Trafo > * trafo ) [protected, virtual]

Handler function for a FramedAnimation<nvmath::Trafo>.

Parameters:
trafo A pointer to the write-locked FramedAnimation<nvmath::Trafo> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<nvmath::Trafo> is encountered on traversal. The FramedAnimation<nvmath::Trafo> trafo is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in AppTraverser.

virtual NVSG_API void handleFramedVertexAttributeAnimation ( nvsg::FramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Handler function for a FramedAnimation<VertexAttribute>.

Parameters:
p A pointer to the write-locked FramedAnimation<VertexAttribute> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<VertexAttribute> is encountered on traversal. The FramedAnimation<VertexAttribute> p is already write-locked.
The base implementation just does nothing
See also:
handleLinearInterpolatedVertexAttributeAnimation

Reimplemented in AppTraverser, and NormalizeTraverser.

virtual NVSG_API void handleLinearInterpolatedTrafoAnimation ( nvsg::LinearInterpolatedAnimation< nvmath::Trafo > * trafo ) [protected, virtual]

Handler function for a LinearInterpolatedAnimation<nvmath::Trafo>.

Parameters:
trafo A pointer to the write-locked LinearInterpolatedAnimation<nvmath::Trafo> being traversed.
Remarks:
This function is called from the framework whenever a LinearInterpolatedAnimation<nvmath::Trafo> is encountered on traversal. The LinearInterpolatedAnimation<nvmath::Trafo> trafo is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in AppTraverser.

virtual NVSG_API void handleLinearInterpolatedVertexAttributeAnimation ( nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Handler function for a LinearInterpolatedAnimation<VertexAttribute>.

Parameters:
p A pointer to the write-locked LinearInterpolatedAnimation<VertexAttribute> being traversed.
Remarks:
This function is called from the framework whenever a LinearInterpolatedAnimation<VertexAttribute> is encountered on traversal. The LinearInterpolatedAnimation<VertexAttribute> p is already write-locked.
The base implementation just does nothing
See also:
handleFramedVertexAttributeAnimation

Reimplemented in AppTraverser, and NormalizeTraverser.

virtual NVSG_API void handleHighlightBox | ( | nvsg::HighlightBox * | hlBox,
 |  | const nvsg::PrimitiveSet * | pset
 | ) | [protected, virtual]

Handler function for a HighlightBox.

Parameters:
hlBox | A pointer to the write-locked HighlightBox being traversed.
pset | A pointer to the write-locked PrimitiveSet, that hlBox is associated to.
Remarks:
This function is called from the framework whenever a HighlightBox is encountered on traversal. The HighlightBox hlBox is already write-locked.
The base implementation just calls traverseHighlightObject().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseHighlightObject

virtual NVSG_API void handleHighlightEdges | ( | nvsg::HighlightEdges * | hlEdges,
 |  | const nvsg::PrimitiveSet * | pset
 | ) | [protected, virtual]

Handler function for a HighlightEdges.

Parameters:
hlEdges | A pointer to the write-locked HighlightEdges being traversed.
pset | A pointer to the write-locked PrimitiveSet, that hlEdges is associated to.
Remarks:
This function is called from the framework whenever a HighlightEdges is encountered on traversal. The HighlightEdges hlEdges is already write-locked.
The base implementation just calls traverseHighlightObject().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseHighlightObject

virtual NVSG_API void handleVolumeNode ( nvsg::VolumeNode * vnode ) [protected, virtual]

Handler function for a VolumeNode.

Parameters:
vnode A pointer to the write-locked VolumeNode being traversed.
Remarks:
This function is called from the framework whenever a VolumeNode is encountered on traversal. The VolumeNode vnode is already write-locked.
The base implementation just calls Traverser::traverseVolumeNode().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseVolumeNode

Reimplemented in AppTraverser.

virtual NVSG_API void traverseCamera ( nvsg::Camera * camera ) [protected, virtual]

Function for common handling of Camera classes.

Parameters:
camera A pointer to the write-locked Camera being traversed.
Remarks:
This function is called from the framework whenever a Camera is encountered on traversal. The Camera camera is already write-locked.
The base implementation traverses the headlights of camera.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
LightSource

Reimplemented in ExclusiveModelViewTraverser.

virtual NVSG_API void traverseLight ( nvsg::LightSource * light ) [protected, virtual]

Function for common handling of LightSource classes.

Parameters:
light A pointer to the write-locked LightSource being traversed.
Remarks:
This function is called from the framework whenever a LightSource is encountered on traversal. The LightSource light is already write-locked.
The base implementation traverses the Animation associated with light, if there is one.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
TrafoAnimation

virtual NVSG_API void traversePrimitiveSet ( nvsg::PrimitiveSet * pset ) [protected, virtual]

Function for common handling of PrimitiveSet classes.

Parameters:
pset A pointer to the write-locked PrimitiveSet being traversed.
Remarks:
This function is called from the framework whenever a PrimitiveSet is encountered on traversal. The PrimitiveSet pset is already write-locked.
The base implementation first traverses the Skin, if there is one, and then the VertexAttributeSet of pset, if there is one. If pset is highlighted, the associated HighlightObject is traversed.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
VertexAttributeSet, HighlightObject

Reimplemented in AppTraverser, and UnifyTraverser.

virtual NVSG_API void traverseHighlightObject | ( | nvsg::HighlightObject * | hlObject,
 |  | const nvsg::PrimitiveSet * | pset
 | ) | [protected, virtual]

Function for common handling of HighlightObject classes.

Parameters:
hlObject | A pointer to the write-locked HighlightObject being traversed.
pset | A pointer to the read-locked PrimitiveSet to be highlighted.
Remarks:
This function is called from the framework whenever a HighlightObject is encountered on traversal. The HighlightObject hlObject is already write-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Member Data Documentation

nvsg::Scene* m_lockedScene [protected]

A pointer to the write-locked Scene currently traversed.

nvsg::ViewState* m_lockedViewState [protected]

A pointer to the write-locked ViewState used in the current traversal.

The documentation for this class was generated from the following file:
  • Traverser.h
Generated on Tue Jan 15 10:29:39 2008 for NVSGSDK by NVIDIA


Member List

ExclusiveTraverser Member List

This is the complete list of members for ExclusiveTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | ExclusiveTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | ExclusiveTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:39 2008 for NVSGSDK by NVIDIA


ExtractGeometryTraverser Class Reference

Traverser that can handle the model view transform stack. More...

#include <ExtractGeometryTraverser.h>

Inheritance diagram for ExtractGeometryTraverser:

[legend]
Collaboration diagram for ExtractGeometryTraverser:

[legend]
List of all members.

Protected Member Functions

NVSG_API | ExtractGeometryTraverser ()
Protected constructor to prevent instantiation of a ModelViewTraverser.

virtual NVSG_API | ~ExtractGeometryTraverser ()
Protected destructor to prevent instantiation of a ExtractGeometryTraverser.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Provide special treatment of an AnimatedTransform node.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Provide special treatment of a Billboard node.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *p)
Provide special treatment of a Switch node.

virtual NVSG_API void | handleLOD (const nvsg::LOD *lod)
Handler function for an LOD.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Provide special treatment of a Transform node.

virtual NVSG_API bool | preTraverseTransform (const nvmath::Trafo *p)
Handles actions to take between transform stack adjustment and traversal.

virtual NVSG_API void | postTraverseTransform (const nvmath::Trafo *p)
Handles actions to take between traversal and transform stack adjustment.

virtual NVSG_API void | traversePrimitiveSet (const nvsg::PrimitiveSet *pset)
Function for common handling of PrimitiveSet classes.

virtual NVSG_API void | submitIndexedTriangleSet (const std::vector< unsigned int > &indices, const std::vector< nvmath::Vec3f > &verts, const std::vector< nvmath::Vec3f > &normals)=0
virtual NVSG_API void | submitDynamicObject (unsigned int id, const std::string &annotation, nvmath::Trafo &m_trafo, const std::vector< unsigned int > &indices, const std::vector< nvmath::Vec3f > &verts, const std::vector< nvmath::Vec3f > &normals)=0

Protected Attributes

nvutil::TransformStack m_transformStack
stack of transformations that holds the actual transformations while traversing a tree

bool | m_inObject
nvmath::Trafo | m_trafo
unsigned int | m_id
unsigned int | m_idCount
std::string | m_annotation

Detailed Description

Traverser that can handle the model view transform stack.

Use this class as a base for traversers that need to maintain the current model view transformation.

Note:
All ModelViewTraverser based classes need a valid nvsg::ViewState . If the ViewState is not valid the runtime behaviour is not defined. Call setViewState() with a valid ViewState prior calling apply().

Constructor & Destructor Documentation

NVSG_API ExtractGeometryTraverser ( ) [protected]

Protected constructor to prevent instantiation of a ModelViewTraverser.

Note:
A ExtractGeometryTraverser doesn't change anything in the scene graph, but might be used by a modifying traverser. therefore, it gets the readOnly flag as a parameter to pass to Traverser.

virtual NVSG_API ~ExtractGeometryTraverser ( ) [protected, virtual]

Protected destructor to prevent instantiation of a ExtractGeometryTraverser.

Member Function Documentation

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Provide special treatment of an AnimatedTransform node.

An AnimatedTransform is handled as a Transform.

Parameters:
p currently visited AnimatedTransform

Reimplemented from SharedTraverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Provide special treatment of a Billboard node.

On a Billboard the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Parameters:
p Billboard to handle

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Provide special treatment of a Switch node.

Parameters:
p Billboard to handle

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * lod ) [protected, virtual]

Handler function for an LOD.

Parameters:
lod A pointer to the read-locked LOD being traversed.
Remarks:
This function is called from the framework whenever an LOD is encountered on traversal. The LOD lod is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Provide special treatment of a Transform node.

On a Transform the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Parameters:
p Transform to handle

Reimplemented from SharedTraverser.

virtual NVSG_API bool preTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handles actions to take between transform stack adjustment and traversal.

In this base class, this is a NOP.

Parameters:
p Trafo of node to traverse next

virtual NVSG_API void postTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handles actions to take between traversal and transform stack adjustment.

When this function returns true, the subtree beneath is traversed. Otherwise it isn't.

Returns:
true
Parameters:
p Trafo of node that was traversed immediately before this call.

virtual NVSG_API void traversePrimitiveSet ( const nvsg::PrimitiveSet * pset ) [protected, virtual]

Function for common handling of PrimitiveSet classes.

Parameters:
pset A pointer to the read-locked PrimitiveSet being traversed.
Remarks:
This function is called from the framework whenever a PrimitiveSet is encountered on traversal. The PrimitiveSet pset is already read-locked.
The base implementation first traverses the Skin, if there is one, and then the VertexAttributeSet of pset, if there is one. If pset is highlighted, the associated HighlightObject is traversed.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
VertexAttributeSet, HighlightObject

Reimplemented from SharedTraverser.

Member Data Documentation

nvutil::TransformStack m_transformStack [protected]

stack of transformations that holds the actual transformations while traversing a tree

The documentation for this class was generated from the following file:
  • ExtractGeometryTraverser.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

ExtractGeometryTraverser Member List

This is the complete list of members for ExtractGeometryTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | SharedTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExtractGeometryTraverser() | ExtractGeometryTraverser | [protected]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | ExtractGeometryTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | SharedTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | ExtractGeometryTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *anim) | SharedTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *gnode) | SharedTraverser | [protected, virtual]
handleGroup(const nvsg::Group *group) | SharedTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | SharedTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | SharedTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *lod) | ExtractGeometryTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | SharedTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | SharedTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | SharedTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | SharedTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *variant) | SharedTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | ExtractGeometryTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | ExtractGeometryTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | SharedTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | SharedTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | SharedTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SharedTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *vnode) | SharedTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedTraverser | [protected, virtual]
m_annotation (defined in ExtractGeometryTraverser) | ExtractGeometryTraverser | [protected]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_id (defined in ExtractGeometryTraverser) | ExtractGeometryTraverser | [protected]
m_idCount (defined in ExtractGeometryTraverser) | ExtractGeometryTraverser | [protected]
m_inObject (defined in ExtractGeometryTraverser) | ExtractGeometryTraverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_trafo (defined in ExtractGeometryTraverser) | ExtractGeometryTraverser | [protected]
m_transformStack | ExtractGeometryTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | ExtractGeometryTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | ExtractGeometryTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedTraverser() | SharedTraverser |
submitDynamicObject(unsigned int id, const std::string &annotation, nvmath::Trafo &m_trafo, const std::vector< unsigned int > &indices, const std::vector< nvmath::Vec3f > &verts, const std::vector< nvmath::Vec3f > &normals)=0 (defined in ExtractGeometryTraverser) | ExtractGeometryTraverser | [protected, pure virtual]
submitIndexedTriangleSet(const std::vector< unsigned int > &indices, const std::vector< nvmath::Vec3f > &verts, const std::vector< nvmath::Vec3f > &normals)=0 (defined in ExtractGeometryTraverser) | ExtractGeometryTraverser | [protected, pure virtual]
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *pset) | ExtractGeometryTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExtractGeometryTraverser() | ExtractGeometryTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


TemplateFace class Reference

Face Class Template Reference

Simple helper class for Lines, Quads, and Triangles. More...

#include <Face.h>

List of all members.

Public Member Functions

template<typename T> unsigned int & | operator[] (T i)
Random access operator to the indices of the Face.

template<typename T> const unsigned int & | operator[] (T i) const
Constant random access operator to the indices of the Face.

Public Attributes

unsigned int | m_indices [n]
Indices into a vertex array, forming the Face.

Detailed Description

template<unsigned char n>
class nvsg::Face< n >

Simple helper class for Lines, Quads, and Triangles.

Namespace: nvsg
Remarks:
A Face is a template class to hold n indices, with n being the template parameter. Interpreting these indices as indices into a vertex array, they form a face.
See also:
Lines, Quads, Triangles, Segment, Face3, Face4

Member Function Documentation

unsigned int & operator[] ( T i ) [inline]

Random access operator to the indices of the Face.

Parameters:
i The vertex of the Face to get the index for.
Returns:
A reference to the index of a vertex in a vertex array.
Note:
The behavior is undefined if i is greater than or equal to the number of indices n of this Face.

const unsigned int & operator[] ( T i ) const [inline]

Constant random access operator to the indices of the Face.

Parameters:
i The vertex of the Face to get the index for.
Returns:
A reference to the constant index of a vertex in a vertex array.
Note:
The behavior is undefined if i is greater than or equal to the number of indices n of this Face.

Member Data Documentation

unsigned int m_indices[n]

Indices into a vertex array, forming the Face.

The documentation for this class was generated from the following file:
  • Face.h
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


Member List

Face Member List

This is the complete list of members for Face, including all inherited members.
m_indices | Face |
operator[](T i) | Face | [inline]
operator[](T i) const | Face | [inline]
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


FaceAttribute Class Reference

PrimitiveAttribute specific for Drawables with faces, like Triangles or QuadStrips. More...

#include <FaceAttribute.h>

Inheritance diagram for FaceAttribute:

[legend]
Collaboration diagram for FaceAttribute:

[legend]
List of all members.

Public Member Functions

NVSG_API | FaceAttribute ()
Default-constructs a FaceAttribute.

NVSG_API | FaceAttribute (const PrimitiveAttribute &rhs)
Constructs a FaceAttribute from a PrimitiveAttribute.

NVSG_API | FaceAttribute (const FaceAttribute &rhs)
Copy-constructs a FaceAttribute from another FaceAttribute.

virtual NVSG_API | ~FaceAttribute ()
Destructs a FaceAttribute.

NVSG_API bool | isFrontFaceCulling () const
Ask if the front faces are culled.

NVSG_API bool | isBackFaceCulling () const
Ask if the back faces are culled.

NVSG_API void | setCullMode (bool frontCulling, bool backCulling)
Set the culling mode for front and back faces.

NVSG_API FaceMode | getFrontFaceMode () const
Get the mode front faces are to be displayed.

NVSG_API FaceMode | getBackFaceMode () const
Get the mode back faces are to be displayed.

NVSG_API void | setFaceMode (FaceMode frontMode, FaceMode backMode)
Set the mode front and back faces are to be displayed.

NVSG_API bool | isPolygonOffset () const
Query if polygon offset is on.

NVSG_API float | getPolygonOffsetFactor () const
Get the polygon offset scale factor.

NVSG_API float | getPolygonOffsetUnits () const
Get the polygon offset units.

NVSG_API void | setPolygonOffset (bool onOff)
Switch polygon offset on or off.

NVSG_API void | setPolygonOffset (float factor, float units)
Set the polygon offset scale factor and units.

NVSG_API bool | isTwoSidedLighting () const
Query of two-sided lighting is enabled.

NVSG_API void | setTwoSidedLighting (bool onOff)
Switch two-sided lighting on or off.

NVSG_API FaceAttribute & | operator= (const FaceAttribute &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another FaceAttribute.

Detailed Description

PrimitiveAttribute specific for Drawables with faces, like Triangles or QuadStrips.

Namespace: nvsg
Remarks:
A FaceAttribute holds the face-specific attributes of a StatePass.
Note:
Lines and Points are not affected by a FaceAttribute.
See also:
LineAttribute, PointAttribute, PrimitiveAttribute, StatePass

Constructor & Destructor Documentation

NVSG_API FaceAttribute ( )

Default-constructs a FaceAttribute.

Remarks:
A default constructed FaceAttribute has back-face culling on, front-face culling off, polygon mode disabled, and two-sided lighting off.

NVSG_API FaceAttribute ( const PrimitiveAttribute & rhs ) [explicit]

Constructs a FaceAttribute from a PrimitiveAttribute.

Parameters:
rhs Source PrimitiveAttribute
Remarks:
After instantiation, the FaceAttribute has back-face culling on, front-face culling off, polygon mode disabled, and two-sided lighting off.

NVSG_API FaceAttribute ( const FaceAttribute & rhs )

Copy-constructs a FaceAttribute from another FaceAttribute.

virtual NVSG_API ~FaceAttribute ( ) [virtual]

Destructs a FaceAttribute.

Member Function Documentation

bool isFrontFaceCulling ( ) const [inline]

Ask if the front faces are culled.

Returns:
true, if front faces are culled, otherwise false.
Remarks:
By convention, faces whose vertices appear in counterclockwise order on the screen are called front-facing. When front face culling is on, those faces are not drawn.
By default front face culling is off.
See also:
isBackFaceCulling, setCullMode

bool isBackFaceCulling ( ) const [inline]

Ask if the back faces are culled.

Returns:
true, if back faces are culled, otherwise false.
Remarks:
By convention, faces whose vertices appear in clockwise order on the screen are called back-facing. When back face culling is on, those faces are not drawn.
By default back face culling is on.
See also:
isFrontFaceCulling, setCullMode

void setCullMode | ( | bool | frontCulling,
 |  | bool | backCulling
 | ) | [inline]

Set the culling mode for front and back faces.

Parameters:
frontCulling | If true, enables front face culling, otherwise disables it.
backCulling | If true, enables back face culling, otherwise disables it.
Remarks:
By convention, faces whose vertices appear in counterclockwise order on the screen are called front-facing, and faces whose vertices appear in clockwise order on the screen are called back-facing. With frontCulling, culling of the front faces can be enabled and disabled, and with backCulling, culling of the back faces can be enabled and disabled.
By default front face culling is off, and back face culling is on.
See also:
isBackFaceCulling, isFrontFaceCulling

FaceMode getFrontFaceMode ( ) const [inline]

Get the mode front faces are to be displayed.

Returns:
The FaceMode that is used for the front faces.
Remarks:
A face can be displayed as a number of zero dimensional points (FM_POINT), one dimensional lines (FM_LINE), or as a two dimensional face (FM_FACE). This can be selected independently for front and back faces.
The default for both front and back faces is FM_FACE.
See also:
getBackFaceMode, isFrontFaceCulling, setFaceMode

FaceMode getBackFaceMode ( ) const [inline]

Get the mode back faces are to be displayed.

Returns:
The FaceMode that is used for the back faces.
Remarks:
A face can be displayed as a number of zero dimensional points (FM_POINT), one dimensional lines (FM_LINE), or as a two dimensional face (FM_FACE). This can be selected independently for front and back faces.
The default for both front and back faces is FM_FACE.
See also:
getFrontFaceMode, isBackFaceCulling, setFaceMode

void setFaceMode | ( | FaceMode | frontMode,
 |  | FaceMode | backMode
 | ) | [inline]

Set the mode front and back faces are to be displayed.

Parameters:
frontMode | The FaceMode for the front faces.
backMode | The FaceMode for the back faces.
Remarks:
A face can be displayed as a number of zero dimensional points (FM_POINT), one dimensional lines (FM_LINE), or as a two dimensional face (FM_FACE). This can be selected independently for front and back faces.
The default for both front and back faces is FM_FACE.
See also:
getFrontFaceMode, getBackFaceMode, setCullMode

bool isPolygonOffset ( ) const [inline]

Query if polygon offset is on.

Returns:
true, if polygon offset is on, otherwise false.
Remarks:
The polygon offset flag specifies how polygon offset is handled. If it is false, no polygon offset is used. Otherwise, each fragment's depth value will be offset after it is interpolated from the depth values of the appropriate vertices. The offset is added before the depth test is performed and before the value is written into the depth buffer. The default is false.
See also:
getPolygonOffsetFactor, getPolygonOffsetUnits, setPolygonOffset

float getPolygonOffsetFactor ( ) const [inline]

Get the polygon offset scale factor.

Returns:
The polygon offset scale factor
Remarks:
The polygon offset scale factor is used to create a variable depth offset for each polygon. The default is 0.0.
See also:
getPolygonOffsetUnits, isPolygonOffset, setPolygonOffset

float getPolygonOffsetUnits ( ) const [inline]

Get the polygon offset units.

Returns:
The polygon offset units
Remarks:
The polygon offset units is multiplied by an implementation-specific value to create a constant depth offset. The default is 0.0.
See also:
getPolygonOffsetFactor, isPolygonOffset, setPolygonOffset

void setPolygonOffset ( bool onOff ) [inline]

Switch polygon offset on or off.

Parameters:
onOff true to switch polygon offset on, false to switch it off.
Remarks:
The polygon offset flag specifies how polygon offset is handled. If it is false, no polygon offset is used. Otherwise, each fragment's depth value will be offset after it is interpolated from the depth values of the appropriate vertices. The offset is added before the depth test is performed and before the value is written into the depth buffer. The default is false. Setting the polygon offset flag increases the nvutil::Incarnation.
See also:
isPolygonOffset, setPolygonOffset

void setPolygonOffset | ( | float | factor,
 |  | float | units
 | ) | [inline]

Set the polygon offset scale factor and units.

Parameters:
factor | The polygon offset scale factor.
units | The polygon offset units.
Remarks:
The polygon offset scale factor is used to create a variable depth offset for each polygon. The default is 0.0. The polygon offset units is multiplied by an implementation-specific value to create a constant depth offset. The default is 0.0.
Setting the polygon offset values increases the nvutil::Incarnation.
See also:
isPolygonOffset, getPolygonOffsetFactor, getPolygonOffsetUnits

bool isTwoSidedLighting ( ) const [inline]

Query of two-sided lighting is enabled.

Returns:
true, if two-sided lighting is enabled, otherwise false.
Remarks:
The two-sided lighting flag specifies whether one or two-sided lighting calculations are performed for polygons. If it is disabled, one-sided lighting is specified. Otherwise, two-sided lighting is specified. In that case, vertices of back-facing polygons are lighted, and have their normals reversed before the lighting equation is evaluated. Vertices of front-facing polygons are always lighted, with no change to their normals. The default is false.
Setting the two-sided lighting flag increases the nvutil::Incarnation.
See also:
setTwoSidedLighting

void setTwoSidedLighting ( bool onOff ) [inline]

Switch two-sided lighting on or off.

Parameters:
onOff true to switch two-sided lighting on, false to switch it off.
Remarks:
The two-sided lighting flag specifies whether one or two-sided lighting calculations are performed for polygons. If it is disabled, one-sided lighting is specified. Otherwise, two-sided lighting is specified. In that case, vertices of back-facing polygons are lighted, and have their normals reversed before the lighting equation is evaluated. Vertices of front-facing polygons are always lighted, with no change to their normals. The default is false.
See also:
isTwoSidedLighting

NVSG_API FaceAttribute& operator= ( const FaceAttribute & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant FaceAttribute to copy from
Returns:
A reference to the assigned FaceAttribute
Remarks:
The assignment operator calls the assignment operator of PrimitiveAttribute and copies the FaceAttribute specific data then.
See also:
PrimitiveAttribute

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another FaceAttribute.

Parameters:
p | A reference to the constant FaceAttribute to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the FaceAttribute p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as PrimitiveAttribute, they are equivalent if they have the same cull mode, face mode, polygon offset settings, and two-sided lighting setting.
Note:
The behavior is undefined if p is not an FaceAttribute nor derived from one.
See also:
PrimitiveAttribute

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • FaceAttribute.h
Generated on Tue Jan 15 10:29:04 2008 for NVSGSDK by NVIDIA


Member List

FaceAttribute Member List

This is the complete list of members for FaceAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
FaceAttribute() | FaceAttribute |
FaceAttribute(const PrimitiveAttribute &rhs) | FaceAttribute | [explicit]
FaceAttribute(const FaceAttribute &rhs) | FaceAttribute |
getAnnotation() const | Object |
getBackFaceMode() const | FaceAttribute | [inline]
getDataID() const | Object | [virtual]
getFrontFaceMode() const | FaceAttribute | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getPolygonOffsetFactor() const | FaceAttribute | [inline]
getPolygonOffsetUnits() const | FaceAttribute | [inline]
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isBackFaceCulling() const | FaceAttribute | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | FaceAttribute | [virtual]
isFrontFaceCulling() const | FaceAttribute | [inline]
isPolygonOffset() const | FaceAttribute | [inline]
isTransparent(void) const | StateAttribute | [virtual]
isTwoSidedLighting() const | FaceAttribute | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const FaceAttribute &rhs) | FaceAttribute |
nvsg::PrimitiveAttribute::operator=(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
PrimitiveAttribute() | PrimitiveAttribute | [protected]
PrimitiveAttribute(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setCullMode(bool frontCulling, bool backCulling) | FaceAttribute | [inline]
setFaceMode(FaceMode frontMode, FaceMode backMode) | FaceAttribute | [inline]
setName(const std::string &name) | Object |
setPolygonOffset(bool onOff) | FaceAttribute | [inline]
setPolygonOffset(float factor, float units) | FaceAttribute | [inline]
setTwoSidedLighting(bool onOff) | FaceAttribute | [inline]
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~FaceAttribute() | FaceAttribute | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~PrimitiveAttribute() | PrimitiveAttribute | [virtual]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:04 2008 for NVSGSDK by NVIDIA


FileMapping Class Reference

Helper class to ease efficient reading and writing of large files. More...

#include <FileMapping.h>

Inheritance diagram for FileMapping:

[legend]
List of all members.

Public Member Functions

NVSG_API unsigned int | getLastError () const
Get the last error.

NVSG_API bool | isValid () const
Test if a FileMapping is valid.

NVSG_API void | mapOut (const void *offsetPtr)
Maps out a previously mapped in part of a file.

Protected Member Functions

NVSG_API | FileMapping ()
Protected default constructor.

NVSG_API | ~FileMapping ()
Protected destructor.

NVSG_API void * | mapIn (size_t offset, size_t numBytes)
Protected base function to map in part of the file.

Protected Attributes

unsigned int | m_accessType
read-only or read/write

HANDLE | m_file
file handle returned by CreateFile

HANDLE | m_fileMapping
handle of file mapping object returned by CreateFileMapping

size_t | m_mappingSize
actual size of the file mapping

bool | m_isValid
file mapping is valid

Detailed Description

Helper class to ease efficient reading and writing of large files.

Remarks:
This is the base class for class ReadMapping and class WriteMapping, that can be used to hide platform dependencies on reading or writing. This is done by selectively mapping parts of a file in and out.
Note:
This class is not intended to be directly instantiated.
See also:
ReadMapping, WriteMapping

Constructor & Destructor Documentation

NVSG_API FileMapping ( ) [protected]

Protected default constructor.

Remarks:
The constructor of FileMapping is protected to prevent explicit instantiation.
See also:
ReadMapping, WriteMapping

NVSG_API ~FileMapping ( ) [protected]

Protected destructor.

Remarks:
The destructor of FileMapping is protected to prevent explicit instantiation.
See also:
ReadMapping, WriteMapping

Member Function Documentation

unsigned int getLastError ( ) const [inline]

Get the last error.

Returns:
An platform dependent unsigned int that describes the last error on using a mapped file.
Example:
const void * ptr = rm->mapIn( offset, count*sizeof(int) ); if ( ! ptr ) { unsigned int errCode = rm->getLastError(); // ... }

bool isValid ( ) const [inline]

Test if a FileMapping is valid.

Returns:
true, if the FileMapping is currently valid, otherwise false.
Remarks:
Before using a FileMapping, you should test for its validity.
Example:
    ReadMapping rm = new ReadMapping( fileName );
    if ( rm->isValid() )
    {...}

NVSG_API void mapOut ( const void * offsetPtr )

Maps out a previously mapped in part of a file.

Parameters:
offsetPtr The constant pointer to void that was previously returned by a call to mapIn.
Example:
  const void * ptr = rm->mapIn( offset, count*sizeof(int) );
  if ( ptr )
  {
    // ...
    rm->mapOut( ptr );
  }
See also:
mapIn

NVSG_API void* mapIn | ( | size_t | offset,
 |  | size_t | numBytes
 | ) | [protected]

Protected base function to map in part of the file.

Parameters:
offset | The offset that has to be part of the mapping.
numBytes | The number of bytes that, starting from offset, are to be part of the mapping.
Returns:
A pointer to the mapped memory location, or NULL if the mapping failed.
See also:
mapOut

Reimplemented in ReadMapping, and WriteMapping.

Member Data Documentation

unsigned int m_accessType [protected]

read-only or read/write

HANDLE m_file [protected]

file handle returned by CreateFile

HANDLE m_fileMapping [protected]

handle of file mapping object returned by CreateFileMapping

size_t m_mappingSize [protected]

actual size of the file mapping

bool m_isValid [protected]

file mapping is valid

The documentation for this class was generated from the following file:
  • FileMapping.h
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


Member List

FileMapping Member List

This is the complete list of members for FileMapping, including all inherited members.
FileMapping() | FileMapping | [protected]
getLastError() const | FileMapping | [inline]
isValid() const | FileMapping | [inline]
m_accessType | FileMapping | [protected]
m_file | FileMapping | [protected]
m_fileMapping | FileMapping | [protected]
m_isValid | FileMapping | [protected]
m_mappingSize | FileMapping | [protected]
mapIn(size_t offset, size_t numBytes) | FileMapping | [protected]
mapOut(const void *offsetPtr) | FileMapping |
~FileMapping() | FileMapping | [protected]
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


FixedAllocator Class Reference

Manages allocation requests for objects of a certain size only. More...

#include <Allocator.h>

Collaboration diagram for FixedAllocator:

[legend]
List of all members.

Public Member Functions

FixedAllocator ()
default constructs a FixedAllocator object

~FixedAllocator ()
destructor - last chunk memory cleanup

void * | alloc ()
Allocate one memory block of size blockSize.

void | dealloc (void *p)
Free the single memory block pointed to by p.

void | init (size_t blockSize)
one time initialization

Detailed Description

Manages allocation requests for objects of a certain size only.

Constructor & Destructor Documentation

FixedAllocator ( )

default constructs a FixedAllocator object

~FixedAllocator ( )

destructor - last chunk memory cleanup

Member Function Documentation

void* alloc ( )

Allocate one memory block of size blockSize.

void dealloc ( void * p )

Free the single memory block pointed to by p.

void init ( size_t blockSize ) [inline]

one time initialization

FixedAllocator::init()

one time initialization

The documentation for this class was generated from the following file:
  • Allocator.h
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


Member List

FixedAllocator Member List

This is the complete list of members for FixedAllocator, including all inherited members.
alloc() | FixedAllocator |
dealloc(void *p) | FixedAllocator |
FixedAllocator() | FixedAllocator |
init(size_t blockSize) | FixedAllocator | [inline]
~FixedAllocator() | FixedAllocator |
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


FlightCameraManipulator Class Reference

Simulate flight like camera-mouse interaction. More...

#include <FlightCameraManipulator.h>

Inheritance diagram for FlightCameraManipulator:

[legend]
Collaboration diagram for FlightCameraManipulator:

[legend]
List of all members.

Public Types

enum {
_NO_BTN_KEY = 0x0000, _LEFT_MOUSE_BTN = 0x0001, _MIDDLE_MOUSE_BTN = 0x0002, _W_KEY = 0x0004,
_S_KEY = 0x0008
}
Keys for flying. More...

Public Member Functions

NVSG_API | FlightCameraManipulator (UINT screenSizeX=1280, UINT screenSizeY=1024)
Constructor .

NVSG_API | ~FlightCameraManipulator ()
Default destructor.

virtual NVSG_API bool | updateFrame ()
Apply changes for the next frame.

virtual NVSG_API bool | isActive ()
Give feedback of the activeness of the Manipulator.

NVSG_API void | reset ()
Reset the camera manipulator to the default values.

virtual NVSG_API bool | isFly ()
Test if the Manipulator is in fly mode.

virtual NVSG_API bool | isFlyForward ()
Test if the Manipulator is in fly forward mode.

virtual NVSG_API bool | isFlyBackward ()
Test if the Manipulator is in fly backward mode.

void | setWorldUpVector (nvmath::Vec3f up)
Define the up direction of the world.

const nvmath::Vec3f & | getWorldUpVector ()
Get the current up vector of the world.

void | setSpeedIncreaseFactor (float factor)
Define speed increase factor for flying.

float | getSpeedIncreaseFactor ()
Get the current speed increase factor for flying.

void | setHSensitivity (float sensitivity)
Define horizontal sensitivity of the mouse.

float | getHSensitivity ()
Get the horizontal sensitivity of the mouse.

void | setVSensitivity (float sensitivity)
Define vertical sensitivity of the mouse.

float | getVSensitivity ()
Get vertical sensitivity of the mouse.

void | setSpeed (float speed)
Set the flying speed.

float | getSpeed ()
Get the current flying speed.

NVSG_API void | keyDown (UINT key)
Handle key press events.

NVSG_API void | keyUp (UINT key)
Handle key release events.

NVSG_API void | mouseButtonDown (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseButtonUp (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseMotion (int x, int y)
Handle mouse motion.

Protected Member Functions

virtual NVSG_API bool | fly ()
Do the fly.

Protected Attributes

UINT | m_ScreenSizeX
Width of the screen in pixel.

UINT | m_ScreenSizeY
Height of the screen in pixel.

nvmath::Vec3f m_worldUpVector
Up-vector of the world.

float | m_speedIncreaseFactor
Factor that influences the stepping. Default: 2.0 NOTE: This factor must not be 0!

float | m_hSensitivity
Factor that influences the horizontal rotation. Default: 1.0.

float | m_vSensitivity
Factor that influences the vertical rotation. Default: 1.0.

float | m_speed
//!< Flight speed. Default: 1.f.

nvui::MouseInput m_mouseInput
Track mouse input.

nvui::KeyInput m_keyInput
Track keyboard input.

Static Protected Attributes

NVSG_API const UINT | FLYFORWARD
Key/button configuration for flying forward (_LEFT_MOUSE_BTN).

NVSG_API const UINT | FLYBACKWARD
Key/button configuration for flying backward (_MIDDLE_MOUSE_BTN).

NVSG_API const UINT | INCREASESPEED
Key/button configuration for increasing speed (_W_KEY).

NVSG_API const UINT | DECREASESPEED
Key/button configuration for decreasing speed (_S_KEY).

NVSG_API const float | AREAOFPEACE
Size if the area where the mouse does not trigger the manipulator. (40 pixels).

Detailed Description

Simulate flight like camera-mouse interaction.

Namespace: nvui
Remarks:
This manipulator is a special Manipulator that interprets/converts mouse movement into flight just like camera movements. The user can simulate flying forward, flying backward, flying curves, increasing speed, and decreasing speed.

Keys & Buttons
Left mouse button : Fly forward.
Middle mouse button : Fly backward.
W-key : Increase speed.
S-key : Decrease speed.

When the Manipulator is in flight mode (forward or backward), one can determine the flight direction by moving the mouse to the left or right. One can also increase or decrease the flight speed by pressing the W-key or the S-key on the keyboard.

If you use this manipulator your application must use a mechanism, such as using OnIdle() that calls updateFrame(). If updateFrame() returns true, you should call triggerRedraw of the render area so the updated frame will be drawn. You will find some code samples in the description of the Manipulator class. Also the SimpleViewer tutorial source code shows how to use a manipulator with MFC, the ConsoleViewer tutorial source code shows the details on how to use a manipulator, and the ManipSampleViewer tutorial source code shows how to derive a new Manipulator class.
The FlightCameraManipulator needs a kind of continuous redraw to work. See the sample code in the documentation on FlightCameraManipulator::updateFrame.
See also:
Manipulator

Member Enumeration Documentation

anonymous enum

Keys for flying.

Enumeration values:
_NO_BTN_KEY | No button or key pressed.
_LEFT_MOUSE_BTN | Left mouse button.
_MIDDLE_MOUSE_BTN | Middle mouse button.
_W_KEY | Speed up.
_S_KEY | Slow down.

Constructor & Destructor Documentation

NVSG_API FlightCameraManipulator | ( | UINT | screenSizeX = 1280,
 |  | UINT | screenSizeY = 1024
 | ) |

Constructor .

Parameters:
screenSizeX | Screen x-resolution in pixel; default is 1280 pixels. The value must be greater than 0.
screenSizeY | Screen y-resolution in pixel; default is 1024 pixels. The value must be greater than 0.
Remarks:
Initialize the FlightCameraManipulator object. The screen resolution is used for the input sensitivity of the manipulator. The default for the world up direction is (0.f, 1.f, 0.f), so by default you are flying in the x-z-plane and the ceiling/heaven is expected to be in the y-direction.

NVSG_API ~FlightCameraManipulator ( )

Default destructor.

Member Function Documentation

virtual NVSG_API bool updateFrame ( ) [virtual]

Apply changes for the next frame.

Returns:
If there is a change regarding the last frame this function returns true.
Remarks:
This function updates the nvsg::Camera. The application should call this function from your idle handler, for example. If it returns with a positive result - true - the application should call RenderArea::triggerRedraw.
Example
This is a piece of code that demonstrates the usage with MFC. The AnimationManipulator needs a method to draw constantly. In MFC - OnIdle() it is enough to return TRUE. The application can also use a kind of animation thread to provide continuous redraw.
  m_pFlightManip->nextFrame();
  if (m_pFlightManip->updateFrame())
  {
    m_pRA->triggerRedraw();
  }
  return TRUE;  // Return TRUE, continues redraw - we are not done
                // we need to draw the next frame.
                // See the return values of OnIdle() in the MSDN documentation
See also the sample code in the Manipulator class description and the ManipSampleViewer, SimpleViewer and ConsoleViewer tutorial source code.
See also:
RenderArea::triggerRedraw

Implements Manipulator.

virtual NVSG_API bool isActive ( ) [virtual]

Give feedback of the activeness of the Manipulator.

Returns:
This function returns true when the Manipulator is in active mode.
Remarks:
The FlightCameraManipulator is active when he is internally in fly mode.

Implements Manipulator.

NVSG_API void reset ( )

Reset the camera manipulator to the default values.

Remarks:
This function resets all the internal states to default (e.g. speed, speed increase factor, key and button states, etc...) The screen resolution and the mouse position will not be reset.
This function does not reset the mouse position since the mouse position will be updated via the mouseMotion function all the time. If you reset the mouse position manually, you will see undesirable camera jumps.

virtual NVSG_API bool isFly ( ) [virtual]

Test if the Manipulator is in fly mode.

Returns:
This function returns true when the manipulator is in fly forward or fly backward mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in fly mode.

Fly:
  • Left mouse button (fly forward)
  • Middle mouse button (fly backward)

virtual NVSG_API bool isFlyForward ( ) [virtual]

Test if the Manipulator is in fly forward mode.

Returns:
This function returns true when the manipulator is in fly forward mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in fly forward mode.

Fly forward: Left mouse button (fly forward)

virtual NVSG_API bool isFlyBackward ( ) [virtual]

Test if the Manipulator is in fly backward mode.

Returns:
This function returns true when the manipulator is in fly backward mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in fly backward mode.

Fly backward: Middle mouse button (fly backward)

void setWorldUpVector ( nvmath::Vec3f up ) [inline]

Define the up direction of the world.

Parameters:
up The vector that points into the up direction of the world. (0,0,0) is an invalid value.
Remarks:
This function sets the world's up direction. The default up direction is the (0,1,0)-direction, meaning the y-achsis points to the 'sky' and you are flying in the x-z-plane. It is a right handed coordinate system.
See also:
getWorldUpVector

const nvmath::Vec3f & getWorldUpVector ( ) [inline]

Get the current up vector of the world.

Returns:
The current up vector of the world.
Remarks:
The world's up vector is the vector that points into direction of the 'sky'. It is a right handed coordinate system.
See also:
setWorldUpVector

void setSpeedIncreaseFactor ( float factor ) [inline]

Define speed increase factor for flying.

Parameters:
factor Speed increase factor - default is 2.f. This factor must not be 0.f!
Remarks:
The current speed will be multiplied or divided by this factor. So with the default increase factor of 2.f, the current flying speed will be doubled whenever the user accelerates the flying speed by pressing the W-key, for example, or halved when pressing the S-key.
See also:
getSpeedIncreaseFactor

float getSpeedIncreaseFactor ( ) [inline]

Get the current speed increase factor for flying.

Remarks:
The current speed will be multiplied or divided by this factor. So with the default increase factor of 2.f, the current flying speed will be doubled whenever the user accelerates the flying speed by pressing the W-key, for example, or halved when pressing the S-key.
See also:
setSpeedIncreaseFactor

void setHSensitivity ( float sensitivity ) [inline]

Define horizontal sensitivity of the mouse.

Parameters:
sensitivity Sensitivity factor - default is 1.f.
Remarks:
The horizontal sensitivity factor is used to control how sensitive the mouse reacts when you are in fly mode and you move your mouse to the left or right. The larger the factor, the greater the sensitivity and the smaller the curve you can fly with a minimum of mouse movement.
See also:
getHSensitivity

float getHSensitivity ( ) [inline]

Get the horizontal sensitivity of the mouse.

Returns:
The current sensitivity of the mouse.
Remarks:
The horizontal sensitivity factor is used to control how sensitive the mouse reacts when you are in fly mode and move your mouse to the left or right. The larger the factor, the greater the sensitivity and the smaller the curve you can fly with a minimum of mouse movement.
See also:
setHSensitivity

void setVSensitivity ( float sensitivity ) [inline]

Define vertical sensitivity of the mouse.

Parameters:
sensitivity Sensitivity factor - default is 1.f.
Remarks:
The horizontal sensitivity factor is used to control how sensitive the mouse reacts when you are in fly mode and move your mouse to the left or right. The larger the factor, the greater the sensitivity and the faster the manipulator simulates the pitch of the virtual aircraft with a minimum of mouse movement.
See also:
getVSensitivity

float getVSensitivity ( ) [inline]

Get vertical sensitivity of the mouse.

Returns:
The current sensitivity of the mouse.
Remarks:
The horizontal sensitivity factor is used to control how sensitive the mouse reacts when you are in fly mode and move your mouse to the left or right. The larger the factor, the greater the sensitivity and the faster the manipulator simulates the pitch of the virtual aircraft with a minimum of mouse movement.
See also:
setVSensitivity

void setSpeed ( float speed ) [inline]

Set the flying speed.

Parameters:
speed The flying speed; default is 1.f.
Remarks:
The application can set the flying speed via this function.
See also:
getSpeed

float getSpeed ( ) [inline]

Get the current flying speed.

Returns:
The current flying speed.
See also:
setSpeed

NVSG_API void keyDown ( UINT key )

Handle key press events.

Parameters:
key The key code of the pressed key. This Manipulator accepts only the _W_KEY and _S_KEY. Other key codes will lead to undefined behavior.
Remarks:
This function routes the key codes to the KeyInput class so the manipulator can react on keyboard input.
See also:
keyUp, KeyInput::keyDown

NVSG_API void keyUp ( UINT key )

Handle key release events.

Parameters:
key The key code of the released key. This Manipulator accepts only the _W_KEY and _S_KEY. Other key codes will lead to undefined behavior.
Remarks:
This function routes the key codes to the KeyInput class so the manipulator can react on keyboard input.
See also:
keyDown, KeyInput::keyUp

NVSG_API void mouseButtonDown | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code of the pressed button(s). This Manipulator accepts only the _LEFT_MOUSE_BTN and _MIDDLE_MOUSE_BTN. Other button codes will lead to undefined behavior.
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse button code and the current mouse cursor position to the MouseInput object to store the events. Call this function from your mouse button handler of your application.
See also:
mouseButtonUp, MouseInput::mouseButtonUp

NVSG_API void mouseButtonUp | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code of the released button(s). This Manipulator accepts only the _LEFT_MOUSE_BTN and _MIDDLE_MOUSE_BTN. Other button codes will lead to undefined behavior.
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse button code and the current mouse cursor position to the MouseInput object to store the events. Call this function from your mouse button handler of your application.
See also:
mouseButtonDown, MouseInput::mouseButtonDown

NVSG_API void mouseMotion | ( | int | x,
 |  | int | y
 | ) |

Handle mouse motion.

Parameters:
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse motion to the MouseInput object. Call this function from your mouse motion handler of your application. Call this function only when the FlightCameraManipulator is active, meaning in flight mode.
See also:
MouseInput::mouseMotion

virtual NVSG_API bool fly ( ) [protected, virtual]

Do the fly.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the fly functionality.

Member Data Documentation

NVSG_API const UINT FLYFORWARD [static, protected]

Key/button configuration for flying forward (_LEFT_MOUSE_BTN).

NVSG_API const UINT FLYBACKWARD [static, protected]

Key/button configuration for flying backward (_MIDDLE_MOUSE_BTN).

NVSG_API const UINT INCREASESPEED [static, protected]

Key/button configuration for increasing speed (_W_KEY).

NVSG_API const UINT DECREASESPEED [static, protected]

Key/button configuration for decreasing speed (_S_KEY).

NVSG_API const float AREAOFPEACE [static, protected]

Size if the area where the mouse does not trigger the manipulator. (40 pixels).

UINT m_ScreenSizeX [protected]

Width of the screen in pixel.

UINT m_ScreenSizeY [protected]

Height of the screen in pixel.

nvmath::Vec3f m_worldUpVector [protected]

Up-vector of the world.

float m_speedIncreaseFactor [protected]

Factor that influences the stepping. Default: 2.0 NOTE: This factor must not be 0!

float m_hSensitivity [protected]

Factor that influences the horizontal rotation. Default: 1.0.

float m_vSensitivity [protected]

Factor that influences the vertical rotation. Default: 1.0.

float m_speed [protected]

//!< Flight speed. Default: 1.f.

nvui::MouseInput m_mouseInput [protected]

Track mouse input.

nvui::KeyInput m_keyInput [protected]

Track keyboard input.

The documentation for this class was generated from the following file:
  • FlightCameraManipulator.h
Generated on Tue Jan 15 10:29:41 2008 for NVSGSDK by NVIDIA


Member List

FlightCameraManipulator Member List

This is the complete list of members for FlightCameraManipulator, including all inherited members.
_LEFT_MOUSE_BTN enum value | FlightCameraManipulator |
_MIDDLE_MOUSE_BTN enum value | FlightCameraManipulator |
_NO_BTN_KEY enum value | FlightCameraManipulator |
_S_KEY enum value | FlightCameraManipulator |
_W_KEY enum value | FlightCameraManipulator |
AREAOFPEACE | FlightCameraManipulator | [protected, static]
DECREASESPEED | FlightCameraManipulator | [protected, static]
FlightCameraManipulator(UINT screenSizeX=1280, UINT screenSizeY=1024) | FlightCameraManipulator |
fly() | FlightCameraManipulator | [protected, virtual]
FLYBACKWARD | FlightCameraManipulator | [protected, static]
FLYFORWARD | FlightCameraManipulator | [protected, static]
getHSensitivity() | FlightCameraManipulator | [inline]
getSpeed() | FlightCameraManipulator | [inline]
getSpeedIncreaseFactor() | FlightCameraManipulator | [inline]
getVSensitivity() | FlightCameraManipulator | [inline]
getWorldUpVector() | FlightCameraManipulator | [inline]
INCREASESPEED | FlightCameraManipulator | [protected, static]
isActive() | FlightCameraManipulator | [virtual]
isFly() | FlightCameraManipulator | [virtual]
isFlyBackward() | FlightCameraManipulator | [virtual]
isFlyForward() | FlightCameraManipulator | [virtual]
keyDown(UINT key) | FlightCameraManipulator |
keyUp(UINT key) | FlightCameraManipulator |
m_hSensitivity | FlightCameraManipulator | [protected]
m_keyInput | FlightCameraManipulator | [protected]
m_mouseInput | FlightCameraManipulator | [protected]
m_renderArea | Manipulator | [protected]
m_ScreenSizeX | FlightCameraManipulator | [protected]
m_ScreenSizeY | FlightCameraManipulator | [protected]
m_speed | FlightCameraManipulator | [protected]
m_speedIncreaseFactor | FlightCameraManipulator | [protected]
m_vSensitivity | FlightCameraManipulator | [protected]
m_worldUpVector | FlightCameraManipulator | [protected]
Manipulator() | Manipulator |
mouseButtonDown(UINT btn, int x, int y) | FlightCameraManipulator |
mouseButtonUp(UINT btn, int x, int y) | FlightCameraManipulator |
mouseMotion(int x, int y) | FlightCameraManipulator |
reset() | FlightCameraManipulator |
setHSensitivity(float sensitivity) | FlightCameraManipulator | [inline]
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
setSpeed(float speed) | FlightCameraManipulator | [inline]
setSpeedIncreaseFactor(float factor) | FlightCameraManipulator | [inline]
setVSensitivity(float sensitivity) | FlightCameraManipulator | [inline]
setWorldUpVector(nvmath::Vec3f up) | FlightCameraManipulator | [inline]
updateFrame() | FlightCameraManipulator | [virtual]
~FlightCameraManipulator() | FlightCameraManipulator |
~Manipulator() | Manipulator | [virtual]
Generated on Tue Jan 15 10:29:41 2008 for NVSGSDK by NVIDIA


FlipbookAnimation Class Reference

Class representing a flipbook animation. More...

#include <FlipbookAnimation.h>

Inheritance diagram for FlipbookAnimation:

[legend]
Collaboration diagram for FlipbookAnimation:

[legend]
List of all members.

Public Member Functions

NVSG_API | FlipbookAnimation ()
Default-constructs a FlipbookAnimation.

NVSG_API | FlipbookAnimation (const FlipbookAnimation &rhs)
Constructs a FlipbookAnimation as a copy of another FlipbookAnimation.

virtual NVSG_API | ~FlipbookAnimation ()
Destructs a FlipbookAnimation.

NVSG_API IndexAnimationHandle * | getAnimation () const
Get a pointer to the constant Animation.

NVSG_API void | setAnimation (IndexAnimationHandle *animation)
Set the Animation.

virtual NVSG_API bool | determineAnimationContainment () const
Query if this objects contains an animation.

NVSG_API FlipbookAnimation & | operator= (const FlipbookAnimation &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another FlipbookAnimation.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

NVSG_API NodeHandle * | getCurrentChild () const
Get the child for the current animation frame.

Detailed Description

Class representing a flipbook animation.

Namespace: nvsg
Remarks:
A FlipbookAnimation is a kind of Group that holds an Animation of indices. For a given animation step the corresponding index specifies which child of the FlipbookAnimation is to use.
See also:
Animation, Group

Constructor & Destructor Documentation

NVSG_API FlipbookAnimation ( )

Default-constructs a FlipbookAnimation.

NVSG_API FlipbookAnimation ( const FlipbookAnimation & rhs )

Constructs a FlipbookAnimation as a copy of another FlipbookAnimation.

virtual NVSG_API ~FlipbookAnimation ( ) [virtual]

Destructs a FlipbookAnimation.

Member Function Documentation

IndexAnimationHandle * getAnimation ( ) const [inline]

Get a pointer to the constant Animation.

Returns:
A pointer to the constant Animation, or NULL if there is none
See also:
Animation

NVSG_API void setAnimation ( IndexAnimationHandle * animation )

Set the Animation.

Parameters:
animation Pointer to the constant Animation to set
Remarks:
The reference count of the Animation animation is incremented and the reference count of any previous Animation is decremented. If these two Animation objects hold a different number of frames, the number of frames is invalidated. The current frame is reset to zero.
Note:
The behavior is undefined if animation is not a valid pointer.
See also:
Animation, invalidateAnimationContainment, addRef, removeRef

virtual NVSG_API bool determineAnimationContainment ( ) const [virtual]

Query if this objects contains an animation.

Returns:
true.
Remarks:
As a FlipbookAnimation always holds an Animation, this always is true.

Reimplemented from Group.

NVSG_API FlipbookAnimation& operator= ( const FlipbookAnimation & rhs )

Assignment operator.

Parameters:
rhs Reference to a constant FlipbookAnimation to copy from
Returns:
A reference to the assigned FlipbookAnimation
Remarks:
The assignment operator first calls the assignment operator of Group. Then the reference count of the current Animation is decremented, the Animation of rhs is cloned, and it's reference count is incremented.
See also:
Animation, Group, addRef, removeRef

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another FlipbookAnimation.

Parameters:
p | Pointer to the constant FlipbookAnimation to test for equivalence with
ignoreNames | Optional parameter to ignore the names of the objects; default is true
deepCompare | Optional parameter to perform a deep comparsion; default is false
Returns:
true if the FlipbookAnimation p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Group objects, their Animation objects are tested for equivalence. If deepCompare is false, they are considered to be equivalent if they are the same pointers. Otherwise, a full equivalence test is performed.
Note:
The behavior is undefined if p is not a FlipbookAnimation nor derived from one.
See also:
Animation, Object

Reimplemented from Group.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and is marked as invalid. Then it is validated and the Incarnation of the Animation is requested to continue validation down the tree hierarchy.
See also:
Incarnation

Reimplemented from Group.

NVSG_API NodeHandle* getCurrentChild ( ) const

Get the child for the current animation frame.

Returns:
A pointer to the NodeHandle to be used for the current animation frame.

The documentation for this class was generated from the following file:
  • FlipbookAnimation.h
Generated on Tue Jan 15 10:29:04 2008 for NVSGSDK by NVIDIA


Member List

FlipbookAnimation Member List

This is the complete list of members for FlipbookAnimation, including all inherited members.
activateClipPlane(unsigned int index) | Group |
addChild(NodeHandle *child, unsigned int position=~0) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addLightSource(LightSourceHandle *lsHdl) | Group |
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const | Group | [protected, virtual]
calculateBoundingSphere() const | Group | [protected, virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
deactivateClipPlane(unsigned int index) | Group |
determineAnimationContainment() const | FlipbookAnimation | [virtual]
determineCgFxContainment() const | Group | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineLightContainment() const | Group | [protected, virtual]
determineLODContainment() const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
determineVolumeNodeContainment() const | Group | [protected, virtual]
enterCS() const | Object | [inline, protected]
FlipbookAnimation() | FlipbookAnimation |
FlipbookAnimation(const FlipbookAnimation &rhs) | FlipbookAnimation |
getAnimation() const | FlipbookAnimation | [inline]
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getChild(unsigned int position) const | Group | [inline]
getChildPositions(NodeHandle *node, std::vector< unsigned int > &positions) const | Group |
getClipPlane(unsigned int index) const | Group | [inline]
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getCurrentChild() const | FlipbookAnimation |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getLightSource(unsigned int index) const | Group | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfLightSources() const | Group | [inline]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getUserData() const | Object | [inline]
Group() | Group |
Group(const Node &rhs) | Group | [explicit]
Group(const Group &rhs) | Group |
hasChild(NodeHandle *node) const | Group | [inline]
hasLightSource(LightSourceHandle *lsHdl) const | Group | [inline]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCaches(NodeHandle *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isClipPlaneActive(unsigned int index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | FlipbookAnimation | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const FlipbookAnimation &rhs) | FlipbookAnimation |
nvsg::Group::operator=(const Group &rhs) | Group |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
postAddChild(unsigned int position) | Group | [protected, virtual]
postRemoveChild(unsigned int position) | Group | [protected, virtual]
preAddChild(unsigned int position) | Group | [protected, virtual]
preRemoveChild(unsigned int position) | Group | [protected, virtual]
removeChild(NodeHandle *child) | Group |
removeChild(unsigned int position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeLightSource(unsigned int index) | Group |
replaceChild(NodeHandle *newChild, NodeHandle *oldChild) | Group |
replaceChild(NodeHandle *newChild, unsigned int position) | Group |
replaceLightSource(unsigned int index, LightSourceHandle *lsHdl) | Group |
replaceLightSource(LightSourceHandle *newHdl, LightSourceHandle *oldHdl) | Group |
setAnimation(IndexAnimationHandle *animation) | FlipbookAnimation |
setAnnotation(const std::string &anno) | Object |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | FlipbookAnimation | [virtual]
~FlipbookAnimation() | FlipbookAnimation | [virtual]
~Group() | Group | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:04 2008 for NVSGSDK by NVIDIA


TemplateFramedAnimation class Reference

FramedAnimation Class Template Reference

Template class of an Animation that holds a complete data set for each frame. More...

#include <FramedAnimation.h>

Inheritance diagram for FramedAnimation:

[legend]
Collaboration diagram for FramedAnimation:

[legend]
List of all members.

Public Member Functions

FramedAnimation ()
Default-constructs a FramedAnimation.

FramedAnimation (const Animation< T > &rhs)
Explicit constructor.

FramedAnimation (const FramedAnimation< T > &rhs)
Constructs a FramedAnimation as a copy of another FramedAnimation.

virtual | ~FramedAnimation ()
void | addStep (const T &value)
Add a single step to the end of the Animation.

void | addSteps (unsigned int numberOfSteps, const T *values)
Add a number of steps to the end of the Animation.

virtual const T & | getCurrentValue () const
Get the current value of this Animation.

virtual T | getStepValue (unsigned int step) const
Get the value of a FramedAnimation at the specified step.

const T * | getStepValues () const
Get a pointer to the animation values.

virtual void | replaceStep (unsigned int step, const T &value)
Replace the value of a specified step.

void | replaceSteps (unsigned int step, unsigned int numberOfSteps, const T *values)
Replace the values of a number of consecutive steps.

virtual void | removeStep (unsigned int step)
Remove a single step from the Animation.

void | removeSteps (unsigned int step, unsigned int numberOfSteps)
Remove a number of consecutive steps.

void | reserveSteps (unsigned int numberOfSteps)
Reserve space for a specified number of steps.

virtual bool | isCompatible (const Animation< T > *p) const
Test for compatibility with an other Animation.

virtual bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other FramedAnimation of type T.

FramedAnimation< T > & | operator= (const FramedAnimation< T > &rhs)
Assignment operator.

Detailed Description

template<typename T>
class nvsg::FramedAnimation< T >

Template class of an Animation that holds a complete data set for each frame.

Namespace: nvsg
Remarks:
A FramedAnimation holds a data set of type T, where T is the template parameter, for each frame.
Note:
The FramedAnimation of type T performs no reference counting on the frame values of type T.
See also:
Animation, InterpolatedAnimation

Constructor & Destructor Documentation

FramedAnimation ( ) [inline]

Default-constructs a FramedAnimation.

FramedAnimation ( const Animation< T > & rhs ) [inline, explicit]

Explicit constructor.

FramedAnimation ( const FramedAnimation< T > & rhs ) [inline]

Constructs a FramedAnimation as a copy of another FramedAnimation.

~FramedAnimation ( ) [inline, virtual]

Destructs a FramedAnimation

Member Function Documentation

void addStep ( const T & value ) [inline]

Add a single step to the end of the Animation.

Parameters:
value The value to add as the last step.
See also:
addSteps, reserveSteps

void addSteps | ( | unsigned int | numberOfSteps,
 |  | const T * | values
 | ) | [inline]

Add a number of steps to the end of the Animation.

Parameters:
numberOfSteps | The number of steps to add as the last steps.
values | A pointer to the values to add as the last steps.
See also:
addStep, reserveSteps

const T & getCurrentValue ( ) const [inline, virtual]

Get the current value of this Animation.

Returns:
The current value of this Animation.
Remarks:
The current value is used in the current animation step.
See also:
getCurrentStep

Implements Animation.

T getStepValue ( unsigned int step ) const [inline, virtual]

Get the value of a FramedAnimation at the specified step.

Parameters:
step Index of the step to get the value at.
Returns:
The value at the specified step.
Note:
The behavior is undefined if step is larger than or equal to the current number of steps.
See also:
getNumberOfSteps, getStepValues

Implements Animation.

const T * getStepValues ( ) const [inline]

Get a pointer to the animation values.

Returns:
A constant pointer to the animation values.
See also:
getStepValue

void replaceStep | ( | unsigned int | step,
 |  | const T & | value
 | ) | [inline, virtual]

Replace the value of a specified step.

Parameters:
step | The step to change the value at.
value | The value to change to.
Note:
The behavior is undefined if step is larger than or equal to the current number of steps.
See also:
replaceSteps

Implements Animation.

void replaceSteps | ( | unsigned int | step,
 |  | unsigned int | numberOfSteps,
 |  | const T * | values
 | ) | [inline]

Replace the values of a number of consecutive steps.

Parameters:
step | The first step to change the value of.
numberOfSteps | The number of steps to change.
values | A constant pointer to the values to use.
Note:
The behavior is undefined if step + numberOfSteps is larger than or equal to the current number of steps.
See also:
replaceStep

void removeStep ( unsigned int step ) [inline, virtual]

Remove a single step from the Animation.

Parameters:
step The step to remove from the Animation.
Note:
The behavior is undefined if step is larger than or equal to the current number of steps.
See also:
removeSteps, getNumberOfSteps

void removeSteps | ( | unsigned int | step,
 |  | unsigned int | numberOfSteps
 | ) | [inline]

Remove a number of consecutive steps.

Parameters:
step | The first step to remove.
numberOfSteps | The number of steps to remove.
Note:
The behavior is undefined if step + numberOfSteps is larger than or equal to the current number of steps.
See also:
removeStep, getNumberOfSteps

void reserveSteps ( unsigned int numberOfSteps ) [inline]

Reserve space for a specified number of steps.

Parameters:
numberOfSteps Reserve space for that number of steps.
See also:
addStep, addSteps

bool isCompatible ( const Animation< T > * p ) const [inline, virtual]

Test for compatibility with an other Animation.

Parameters:
p A pointer to the other Animation.
Returns:
true if this and p are compatible, otherwise false.
Remarks:
A FramedAnimation is compatible with an other, if the Animation parts of them are equivalent.
See also:
isEquivalent

Implements Animation.

bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [inline, virtual]

Test for equivalence with an other FramedAnimation of type T.

Parameters:
p | A reference to the constant FramedAnimation of type T to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the FramedAnimation of type T p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Animation of type T, they are equivalent if they have the same number of frames, and each frame has the same value of type T.
Note:
The behavior is undefined if p is not a FramedAnimation of type T nor derived from one.
See also:
Animation

Reimplemented from Animation.

FramedAnimation< T > & operator= ( const FramedAnimation< T > & rhs ) [inline]

Assignment operator.

Parameters:
rhs A reference to the constant FramedAnimation of type T to copy from.
Returns:
A reference to the assigned FramedAnimation of type T.
Remarks:
The assignment operator calls the assignment operator of Animation of type T and then copies the vector of values of type T .
See also:
Animation

The documentation for this class was generated from the following file:
  • FramedAnimation.h
Generated on Tue Jan 15 10:29:04 2008 for NVSGSDK by NVIDIA


Member List

FramedAnimation Member List

This is the complete list of members for FramedAnimation, including all inherited members.
addStep(const T &value) | FramedAnimation | [inline]
addSteps(unsigned int numberOfSteps, const T *values) | FramedAnimation | [inline]
Animation(void) | Animation | [inline, protected]
FramedAnimation() | FramedAnimation | [inline]
FramedAnimation(const Animation< T > &rhs) | FramedAnimation | [inline, explicit]
FramedAnimation(const FramedAnimation< T > &rhs) | FramedAnimation | [inline]
getCurrentValue() const | FramedAnimation | [inline, virtual]
getFrameValue(unsigned int frame) const | Animation | [inline]
getStepValue(unsigned int step) const | FramedAnimation | [inline, virtual]
getStepValues() const | FramedAnimation | [inline]
isCompatible(const Animation< T > *p) const | FramedAnimation | [inline, virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | FramedAnimation | [inline, virtual]
operator=(const FramedAnimation< T > &rhs) | FramedAnimation | [inline]
nvsg::Animation::operator=(const Animation< T > &rhs) | Animation | [inline, protected]
removeStep(unsigned int step) | FramedAnimation | [inline, virtual]
removeSteps(unsigned int step, unsigned int numberOfSteps) | FramedAnimation | [inline]
replaceStep(unsigned int step, const T &value) | FramedAnimation | [inline, virtual]
replaceSteps(unsigned int step, unsigned int numberOfSteps, const T *values) | FramedAnimation | [inline]
reserveSteps(unsigned int numberOfSteps) | FramedAnimation | [inline]
~Animation() | Animation | [inline, virtual]
~FramedAnimation() | FramedAnimation | [inline, virtual]
Generated on Tue Jan 15 10:29:04 2008 for NVSGSDK by NVIDIA


FrustumCullTraverser Class Reference

CullTraverser culling on frustum information. More...

#include <FrustumCullTraverser.h>

Inheritance diagram for FrustumCullTraverser:

[legend]
Collaboration diagram for FrustumCullTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | FrustumCullTraverser (void)
Default Constructor.

Protected Member Functions

virtual NVSG_API | ~FrustumCullTraverser (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Overrides SharedModelViewTraverser::doApply.

virtual NVSG_API bool | preTraverseTransform (const nvmath::Trafo *p)
Re-implementation of the preTraverseTransform method.

virtual NVSG_API void | postTraverseTransform (const nvmath::Trafo *p)
Re-implementation of the postTraverseTransform method.

virtual NVSG_API nvsg::CullCode | cullCode (const nvmath::Sphere3f &bs) const
Re-implementation of the cullCode method.

Detailed Description

CullTraverser culling on frustum information.

Namespace: nvsg
Remarks:
The FrustumCullTraverser determines the nvsg::CullCode of all nvsg::Node objects in a nvsg::Scene with respect to the view frustum. As a CullTraverser, it creates a tree of nvsg::CullData from those nvsg::CullCode.
Note:
The FrustumCullTraverser needs a valid ViewState, so use setViewState() prior to apply().
See also:
CullTraverser, nvsg::CullCode, nvsg::CullData

Constructor & Destructor Documentation

NVSG_API FrustumCullTraverser ( void )

Default Constructor.

Remarks:
A FrustumCullTraverser does not change the Scene.

virtual NVSG_API ~FrustumCullTraverser ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the FrustumCullTraverser is decremented to zero.

Member Function Documentation

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Overrides SharedModelViewTraverser::doApply.

Parameters:
root Specifies the Node where to start traversal.
Remarks:
This function gets called from the Traverser framework immediately after traversal was initiated by invoking Traverser::apply. This override calls its base class for traversal, and after traversal has been completed, it evaluates the resulting cull tree. If the root is found to be trivial in, the cull tree will be dismissed.
See also:
CullData, nvsg::Node, ModelViewTraverser, nvsg::ViewState

Reimplemented from CullTraverser.

virtual NVSG_API bool preTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Re-implementation of the preTraverseTransform method.

Parameters:
p A pointer to the constant nvmath::Trafo of the nvsg::Transform to traverse.
Returns:
true, if the nvsg::Transform can be traversed, otherwise false.
Remarks:
This method stores the scaling information of the nvmath::Trafo p for usage in the nvsg::CullCode calculations and then returns the result of CullTraverser::preTraverseTransform().
See also:
ModelViewTraverser

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void postTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Re-implementation of the postTraverseTransform method.

Parameters:
p A pointer to the constant nvmath::Trafo of the nvsg::Transform just traversed.
Remarks:
This method calls CullTraverser::postTraverseTransform() and restores the scaling information to the state without this nvsg::Transform.
See also:
ModelViewTraverser

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API nvsg::CullCode cullCode ( const nvmath::Sphere3f & bs ) const [protected, virtual]

Re-implementation of the cullCode method.

Parameters:
bs A constant reference to the bounding sphere to determine the nvsg::CullCode of.
Returns:
The nvsg::CullCode of the bounding sphere bs relative to the view frustum.
Note:
If bs is empty, it is considered to be in.
See also:
CullTraverser

Reimplemented from CullTraverser.

The documentation for this class was generated from the following file:
  • FrustumCullTraverser.h
Generated on Tue Jan 15 10:29:29 2008 for NVSGSDK by NVIDIA


Member List

FrustumCullTraverser Member List

This is the complete list of members for FrustumCullTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
cullCode(const nvmath::Sphere3f &bs) const | FrustumCullTraverser | [protected, virtual]
CullTraverser() | CullTraverser | [protected]
doApply(nvsg::NodeHandle *root) | FrustumCullTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
FrustumCullTraverser(void) | FrustumCullTraverser |
getCurrentHints() const | CullTraverser | [inline, protected]
getCurrentHintsContainment() const | CullTraverser | [inline, protected]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SharedModelViewTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | SharedTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | CullTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *p) | CullTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | CullTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | CullTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | SharedTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | SharedTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | CullTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | SharedTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | SharedTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | SharedTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | SharedTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | CullTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *variant) | SharedTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | CullTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | CullTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | SharedTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | SharedTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | SharedTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SharedTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *p) | CullTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedModelViewTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedCamera | SharedModelViewTraverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | SharedModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | CullTraverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | FrustumCullTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | FrustumCullTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedModelViewTraverser() | SharedModelViewTraverser | [protected]
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | CullTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~CullTraverser(void) | CullTraverser | [protected, virtual]
~FrustumCullTraverser(void) | FrustumCullTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedModelViewTraverser() | SharedModelViewTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:29 2008 for NVSGSDK by NVIDIA


geometrySet_t Struct Reference

The geometrySet_t structure specifies how a geometry set is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t stateSet
Specifies the file offset to the corresponding NBFStateSet object.

uint_t numDrawables
Specifies the number of this geometry's NBFDrawable objects.

uint_t drawables
Specifies the file offset to the offsets to the NBFDrawable objects.

Detailed Description

The geometrySet_t structure specifies how a geometry set is stored in a .NBF file.

Geometry sets, in this context, need to be considered in conjunction with NBFGeoNode objects.

Member Data Documentation

uint_t stateSet

Specifies the file offset to the corresponding NBFStateSet object.

uint_t numDrawables

Specifies the number of this geometry's NBFDrawable objects.

uint_t drawables

Specifies the file offset to the offsets to the NBFDrawable objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

geometrySet_t Member List

This is the complete list of members for geometrySet_t, including all inherited members.
drawables | geometrySet_t
numDrawables | geometrySet_t
stateSet | geometrySet_t
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


GeoNode Class Reference

Leaf Node to maintain geometry. More...

#include <GeoNode.h>

Inheritance diagram for GeoNode:

[legend]
Collaboration diagram for GeoNode:

[legend]
List of all members.

Public Member Functions

NVSG_API | GeoNode ()
Default-constructs a GeoNode.

NVSG_API | GeoNode (const Node &rhs)
Constructs a GeoNode from a Node.

NVSG_API | GeoNode (const GeoNode &rhs)
Constructs a GeoNode as a copy of another GeoNode.

virtual NVSG_API | ~GeoNode ()
Destructs a GeoNode.

NVSG_API unsigned int | getNumberOfGeometries () const
Retrieves the number of geometries contained.

NVSG_API unsigned int | getNumberOfDrawables (unsigned int index) const
Retrieves the number of Drawables added to the indicated geometry.

NVSG_API void | addGeometry (DrawableHandle *drawable, StateSetHandle *stateSet=NULL)
Adds indicated geometry to the GeoNode.

NVSG_API bool | removeGeometry (StateSetHandle *stateSet)
Removes the specified geometry.

NVSG_API bool | removeGeometry (DrawableHandle *drawable)
Removes a single Drawable.

NVSG_API void | clearGeometries ()
Removes the complete geometry from the GeoNode.

NVSG_API void | replaceStateSet (StateSetHandle *newStateSet, StateSetHandle *oldStateSet)
Replaces a StateSet by another.

NVSG_API void | replaceDrawable (DrawableHandle *newDrawable, DrawableHandle *oldDrawable)
Replaces a Drawable by another.

NVSG_API StateSetHandle * | getStateSet (unsigned int index) const
Returns the StateSet at given zero-based index.

NVSG_API StateSetHandle * | getStateSet (DrawableHandle *drawable) const
Returns the StateSet associated with a specified Drawable.

NVSG_API DrawableHandle * | getDrawable (unsigned int geometryIndex, unsigned int drawableIndex) const
Returns the Drawable inside the specified geometry at the indicated position.

NVSG_API void | clearTexCoords (unsigned int tu=0)
Clear texture coordinates on all Drawable objects.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other GeoNode.

NVSG_API GeoNode & | operator= (const GeoNode &rhs)
Assignment operator.

virtual NVSG_API bool | validateIncarnation () const
Validate the nvutil::Incarnation.

Protected Member Functions

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Interface to calculate the bounding box of this GeoNode.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Interface to calculate the bounding sphere of this GeoNode.

virtual NVSG_API bool | determineTransparencyContainment () const
Determine the transparency containment status.

virtual NVSG_API bool | determineCgFxContainment () const
Determines the CgFx containment status.

virtual NVSG_API bool | determineAnimationContainment () const
Determine the animation containment of this object.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (GeoNode *gn, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2, bool overwrite=true)
Generate tangents and binormals for all QuadMeshes, Quads, QuadStrips, Triangles, TriFans, and TriStrips in a GeoNode.

NVSG_API void | generateNormals (GeoNode *gn)
Generate normals for all QuadMeshes, Quads, QuadStrip, Triangles, TriFans, and TriStrip in a GeoNode.

NVSG_API void | generateTexCoords (GeoNode *gn, TextureCoordType tct, unsigned int tu=0, bool overwrite=true)
Generate texture coordinates on all Drawable objects.

Detailed Description

Leaf Node to maintain geometry.

Namespace: nvsg
Remarks:
A GeoNode represents a leaf Node containing Drawable objects associated to StateSets, where an arbitrary number of Drawable objects can be asssociated to a single StateSet. Such a compound we also refer to as a 'geometry'. StateSets as well as Drawables are unique within a GeoNode.
A GeoNode provides an API to add, replace, and remove geometry. It also provides an API to iterate through the contained StateSets and Drawables, as well as accessing the contained StateSets and Drawables for further processing.
See also:
Drawable, Node, Scene, StateSet

Constructor & Destructor Documentation

NVSG_API GeoNode ( )

Default-constructs a GeoNode.

NVSG_API GeoNode ( const Node & rhs ) [explicit]

Constructs a GeoNode from a Node.

Parameters:
rhs Node to construct the GeoNode from.
Remarks:
This is kind of a partial copy constructor only copying the Node part from the source object.

NVSG_API GeoNode ( const GeoNode & rhs )

Constructs a GeoNode as a copy of another GeoNode.

virtual NVSG_API ~GeoNode ( ) [virtual]

Destructs a GeoNode.

Member Function Documentation

unsigned int getNumberOfGeometries ( ) const [inline]

Retrieves the number of geometries contained.

Returns:
The number of geometries contained in this GeoNode.
Remarks:
We denote a 'geometry' to be the compound of a single StateSet with an arbitrary number of Drawable objects. We also use the term that a number of Drawables is associated to a single StateSet.

This in mind, a geometry always is one-to-one to a StateSet. Though, Drawables inside a GeoNode can be associated to a NULL StateSet. At render time, these Drawables fall back to get rendered with a 'default' StateSet then.

StateSets and Drawables are unique within a GeoNode. The GeoNode API that allows you to add and replace geometry takes care of this. Though, you need to keep in mind that replacing a StateSet or a Drawable inside a GeoNode can actually end up with having one geometry less after such an operation.
See also:
Drawable, StateSet

unsigned int getNumberOfDrawables ( unsigned int index ) const [inline]

Retrieves the number of Drawables added to the indicated geometry.

Parameters:
index Zero-based index to identify the geometry to query.
Returns:
The number of Drawables in the index'th geometry.
Remarks:
You must not pass an index equal to or greater than the number of geometries that is actually contained in the GeoNode. Doing so would result in undefined behavior. Use getNumberOfGeometries to retrieve the current number of geometries contained.
See also:
Drawable, getGeometryIndex

NVSG_API void addGeometry | ( | DrawableHandle * | drawable,
 |  | StateSetHandle * | stateSet = NULL
 | ) |

Adds indicated geometry to the GeoNode.

Parameters:
drawable | Specifies the Drawable to add.
stateSet | Specifies an optional StateSet to which to associate the Drawable right after it has been added.
Remarks:
The function adds the Drawable specified by drawable to the GeoNode and associates it with the StateSet indicated by stateSet. If drawable specifies an invalid pointer, the behavior of this function is undefined.

You can add multiple Drawables, all associated to the same StateSet. However, a single Drawable can occur only once in a GeoNode, even if associated to a different StateSet. In the case a Drawable is added twice to the same GeoNode, the previously added Drawable will be removed from the GeoNode again, and unassociated from the StateSet that was specified with the previous call. If there are no additional Drawables left associated to that specific StateSet, the corresponding geometry will be removed from the GeoNode and the StateSet will be unreferenced along with this operation. If, in this case, the StateSet is not referenced anywhere else, it will be destroyed.
See also:
Drawable, StateSet

NVSG_API bool removeGeometry ( StateSetHandle * stateSet )

Removes the specified geometry.

Returns:
true, if the StateSet was part of this GeoNode and is removed, otherwise false.
Parameters:
stateSet Specifies the StateSet to identify the geometry to remove.
Remarks:
The function removes all Drawables from the GeoNode that were previously added and associated to the StateSet specified by stateSet. The indicated StateSet and all removed Drawables will be unreferenced along with this operation.
See also:
Drawable, StateSet

NVSG_API bool removeGeometry ( DrawableHandle * drawable )

Removes a single Drawable.

Returns:
true, if the Drawable was part of this GeoNode and is removed, otherwise false.
Parameters:
drawable Specifies the Drawable to remove.
Remarks:
The function unreferences the indicated Drawable and removes it from the GeoNode and hence unassociates it from the StateSet it was previously associated through a addGeometry call. If there are no additional Drawables left associated to that specific StateSet, the corresponding geometry will be removed from the GeoNode and the StateSet will be unreferenced along with this operation. If, in this case, the StateSet is not referenced anywhere else, it will be destroyed. The behavior will be undefined if a NULL pointer is passed through drawable.
See also:
Drawable, StateSet

NVSG_API void clearGeometries ( )

Removes the complete geometry from the GeoNode.

Remarks:
The function unreferences all previously added Drawables and associated StateSets, and removes them from the GeoNode. Objects that are not referenced anywhere else, will be irretrievably destroyed along with this operation.
See also:
Drawable, StateSet

NVSG_API void replaceStateSet | ( | StateSetHandle * | newStateSet,
 |  | StateSetHandle * | oldStateSet
 | ) |

Replaces a StateSet by another.

Parameters:
newStateSet | Specifies the StateSet to replace oldStateSet.
oldStateSet | Specifies the StateSet to be replaced by newStateSet.
Remarks:
The function re-associates all Drawables, that, at the time of calling, are associated with oldStateSet, with newStateSet, thereby unreferencing oldStateSet.

If newStateSet already is contained in the GeoNode, no additional reference is added to newStateSet. It just inherits all the Drawables from oldStateSet. In this particular case, the geometry that corresponds to oldStateSet will be cleared, and the GeoNode ends-up containing one geometry less after the call, which in turn invalidates previously retrieved geometry indices.
See also:
Drawable, StateSet

NVSG_API void replaceDrawable | ( | DrawableHandle * | newDrawable,
 |  | DrawableHandle * | oldDrawable
 | ) |

Replaces a Drawable by another.

Parameters:
newDrawable | Specifies the Drawable to replace oldDrawable.
oldDrawable | Specifies the Drawable to be replaced by newDrawable.
Remarks:
The function performs a GeoNode-wise replacement of oldDrawable by newDrawable, thereby unreferencing oldDrawable. newDrawable gets associated with the StateSet, oldDrawable was associated to at the time of calling.

If newDrawable already is contained in the GeoNode, but associated to a different StateSet, newDrawable gets re-associated to the StateSet, oldDrawable is associated with at the time of calling. If through this operation the StateSet, newDrawable previously was associated with, left without any further Drawables associated with it, the corresponding geometry will be removed from the GeoNode. In this particular case, that StateSet will be unreferenced, and the GeoNode ends-up containing one geometry less after the call, which in turn invalidates previously retrieved geometry indices.
See also:
Drawable, replaceStateSet

StateSetHandle * getStateSet ( unsigned int index ) const [inline]

Returns the StateSet at given zero-based index.

Parameters:
index The zero-based index of the geometry to retrieve the StateSet from.
Returns:
The function returns the handle to the queried StateSet. A NULL handle is a valid return value since geometry can be specified without a valid StateSet.

You must not pass an index equal to or greater than the number of geometries that is actually contained in the GeoNode. Doing so would result in undefined behavior. Use getNumberOfGeometries to retrieve the current number of geometries contained.
See also:
StateSet, getNumberOfGeometries

StateSetHandle * getStateSet ( DrawableHandle * drawable ) const [inline]

Returns the StateSet associated with a specified Drawable.

Parameters:
drawable Specifies the Drawable to identify the requested StateSet.
Returns:
The function returns the StateSet associated with the indicated Drawable, or NULL if no StateSet is associated with that Drawable.
Remarks:
You want to use this function if you need to know what the associated StateSet is for a given Drawable.
See also:
Drawable, StateSet, getGeometryIndex

DrawableHandle * getDrawable | ( | unsigned int | geometryIndex,
 |  | unsigned int | drawableIndex
 | ) | const [inline]

Returns the Drawable inside the specified geometry at the indicated position.

Parameters:
geometryIndex | Zero-based index of the geometry to query
drawableIndex | Zero-based index of the Drawable to query
Returns:
The function returns the Drawable inside the specified geometry at the indicated position.
Remarks:
You want to use this function to iterate through all Drawables inside a given geometry. To iterate through all Drawables of a certain GeoNode, you typically do something like this:
  GeoNodeHandle * hgnode;
  // ...
  // assume hgnode a valid GeoNodeHandle if we get here

  ReadableObject<GeoNode> gnode(hgnode); // get read-access to the GeoNode API

  for ( unsigned int i=0; i < gnode->getNumberOfGeometries(); ++i )
  {
      for ( unsigned int j=0; j < gnode->getNumberOfDrawables(i); ++j )
      {
          ReadableObject<Drawable> drwbl(gnode->getDrawable(i, j)); // get read-access to the Drawable API
          // ...
      }
  }

You must not pass a geometry index equal to or greater than the number of geometries that is actually contained in the GeoNode, and you must not pass a Drawable index equal or greater than the number of Drawables contained in the indicated geometry. Doing so would result in undefined behavior. Use getNumberOfGeometries to retrieve the current number of geometries contained in the GeoNode, and getNumberOfDrawables to retrieve the current number of Drawables contained in the indicated geometry.
See also:
Drawable, getNumberOfGeometries, getNumberOfDrawables

NVSG_API void clearTexCoords ( unsigned int tu = 0 )

Clear texture coordinates on all Drawable objects.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other GeoNode.

Parameters:
p | A reference to the constant GeoNode to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparison; default is false.
Returns:
true if the GeoNode p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Node, and they have the same number of StateSet objects with the same number of Drawable objects assigned, they are each tested for equivalence. If deepCompare is false, they are considered to be equivalent if they are the same pointers. Otherwise a full equivalence test is performed.
Note:
The behavior is undefined if p is not a GeoNode nor derived from one.
See also:
Node

Reimplemented from Object.

NVSG_API GeoNode& operator= ( const GeoNode & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant GeoNode to copy from
Returns:
A reference to the assigned GeoNode
Remarks:
The assignment operator calls the assignment operator of Node and copies all geometries from rhs. On all StateSet and Drawable objects previously in this, the reference count is decremented.
See also:
Drawable, Node, StateSet

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this GeoNode is requested but marked as invalid. Then it is validated and the nvutil::Incarnation of all StateSet and Drawable objects is requested to continue the validation down the tree hierarchy.
See also:
Drawable, Node, StateSet, nvutil::Incarnation, invalidateIncarnation

Reimplemented from Node.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Interface to calculate the bounding box of this GeoNode.

Returns:
The bounding box of this GeoNode
Remarks:
This function is called by the framework to determine the actual bounding box of this GeoNode.
See also:
getBoundingBox, invalidateBoundingVolumes

Implements Node.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Interface to calculate the bounding sphere of this GeoNode.

Returns:
A sphere that contains the complete GeoNode.
Remarks:
This function is called by the framework to determine a sphere that completely contains the GeoNode.
See also:
getBoundingSphere, invalidateBoundingVolumes

Implements Node.

virtual NVSG_API bool determineTransparencyContainment ( ) const [protected, virtual]

Determine the transparency containment status.

Returns:
true, if this GeoNode holds any transparent geometry, otherwise false.
Remarks:
This function is called by the framework to determine the transparency containment state of a Node when the transparency containment cache is marked as invalid.
See also:
Node, containsTransparentGeometry, isTransparent

Implements Node.

virtual NVSG_API bool determineCgFxContainment ( ) const [protected, virtual]

Determines the CgFx containment status.

Returns:
true, if this GeoNode holds at least one CgFx, otherwise false.
Remarks:
This overrides Node::determineCgFxContainment, since a GeoNode can contain a CgFx in at least one of its owned StateSets.

Reimplemented from Node.

virtual NVSG_API bool determineAnimationContainment ( ) const [protected, virtual]

Determine the animation containment of this object.

Returns:
true, if at least on of the geometries contains an Animation, otherwise false.

Reimplemented from Node.

Friends And Related Function Documentation

NVSG_API void calculateTangentSpace | ( | GeoNode * | gn,
 |  | unsigned int | tu = 0,
 |  | unsigned int | tg = 1,
 |  | unsigned int | bn = 2,
 |  | bool | overwrite = true
 | ) | [related]

Generate tangents and binormals for all QuadMeshes, Quads, QuadStrips, Triangles, TriFans, and TriStrips in a GeoNode.

Parameters:
gn | A pointer to the constant GeoNode to create tangents and binormals for.
tu | The optional texture unit that holds texture coordinates to use; default is 0.
tg | The optional texture unit that is going to hold the tangents; default is 1.
bn | The optional texture unit that is going to hold the binormals; default is 2.
overwrite | An optional flag that marks if texture coordinates are to be overwritten.
Remarks:
On all VertexAttributeSets that have at least two-dimensional texture coordinates in texture unit tu, tangents and binormals can be calculated. If overwrite is true (the default), tangents and binormals are calculated. If otherwise overwrite is false they are only calculated, if there are no texture coordinates in the texture units tg and bn.
Note:
The behavior is undefined if a VertexAttributeSet has no normals.
See also:
GeoNode, QuadMeshes, Quads, QuadStrips, Triangles, TriFans, TriStrips, generateNormals, generateTexCoords

NVSG_API void generateNormals ( GeoNode * gn ) [related]

Generate normals for all QuadMeshes, Quads, QuadStrip, Triangles, TriFans, and TriStrip in a GeoNode.

Parameters:
gn A pointer to the constant GeoNode to create normals for.
See also:
GeoNode, QuadMeshes, Quads, QuadStrips, Triangles, TriFans, TriStrips, generateTexCoords

NVSG_API void generateTexCoords | ( | GeoNode * | gn,
 |  | TextureCoordType | tct,
 |  | unsigned int | tu = 0,
 |  | bool | overwrite = true
 | ) | [related]

Generate texture coordinates on all Drawable objects.

Parameters:
gn | A pointer to the constant GeoNode to generate texture coordinates for.
tct | The TextureCoordType to use for texture coordinate generation.
tu | The optional texture unit to fill with texture coordinates; default is 0.
overwrite | An optional flag that marks if texture coordinates are to be overwritten.
Remarks:
If overwrite is true (the default), on all VertexAttributeSets in this GeoNode texture coordinates are generated on texture unit /a tu. If otherwise overwrite is false, texture coordinates are only generated on those VertexAttributeSets that do not already have texture coordinates on texture unit tu. The texture coordinates can be created as cylindrical, planar, or spherical, determined by tct. The coordinates are created relative to the bounding sphere of the complete GeoNode.
See also:
PrimitiveSet, TextureCoordType

The documentation for this class was generated from the following file:
  • GeoNode.h
Generated on Tue Jan 15 10:29:04 2008 for NVSGSDK by NVIDIA


Member List

GeoNode Member List

This is the complete list of members for GeoNode, including all inherited members.
addAsParentTo(NodeHandle *child) | Node | [protected]
addGeometry(DrawableHandle *drawable, StateSetHandle *stateSet=NULL) | GeoNode |
addHints(unsigned short hints) | Node | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const | GeoNode | [protected, virtual]
calculateBoundingSphere() const | GeoNode | [protected, virtual]
calculateTangentSpace(GeoNode *gn, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2, bool overwrite=true) | GeoNode | [related]
clearGeometries() | GeoNode |
clearTexCoords(unsigned int tu=0) | GeoNode |
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
determineAnimationContainment() const | GeoNode | [protected, virtual]
determineCgFxContainment() const | GeoNode | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineLightContainment() const | Node | [protected, virtual]
determineLODContainment() const | Node | [protected, virtual]
determineTransparencyContainment() const | GeoNode | [protected, virtual]
determineVolumeNodeContainment() const | Node | [protected, virtual]
enterCS() const | Object | [inline, protected]
generateNormals(GeoNode *gn) | GeoNode | [related]
generateTexCoords(GeoNode *gn, TextureCoordType tct, unsigned int tu=0, bool overwrite=true) | GeoNode | [related]
GeoNode() | GeoNode |
GeoNode(const Node &rhs) | GeoNode | [explicit]
GeoNode(const GeoNode &rhs) | GeoNode |
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getDrawable(unsigned int geometryIndex, unsigned int drawableIndex) const | GeoNode | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getName() const | Object |
getNumberOfDrawables(unsigned int index) const | GeoNode | [inline]
getNumberOfGeometries() const | GeoNode | [inline]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getStateSet(unsigned int index) const | GeoNode | [inline]
getStateSet(DrawableHandle *drawable) const | GeoNode | [inline]
getUserData() const | Object | [inline]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | GeoNode | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const GeoNode &rhs) | GeoNode |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
removeAsParentFrom(NodeHandle *child) | Node | [protected]
removeGeometry(StateSetHandle *stateSet) | GeoNode |
removeGeometry(DrawableHandle *drawable) | GeoNode |
removeHints(unsigned short hints) | Node | [inline]
replaceDrawable(DrawableHandle *newDrawable, DrawableHandle *oldDrawable) | GeoNode |
replaceStateSet(StateSetHandle *newStateSet, StateSetHandle *oldStateSet) | GeoNode |
setAnnotation(const std::string &anno) | Object |
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | GeoNode | [virtual]
~GeoNode() | GeoNode | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:04 2008 for NVSGSDK by NVIDIA


GLContext Class Reference

Wrapper for OpenGL functions to provide caching, extension handling, and, in debug mode, error handling per context. More...

#include <GLContext.h>

Collaboration diagram for GLContext:

[legend]
List of all members.

Public Member Functions

Display * | getDisplay ()
Get the Display of this GLContext (Linux only).

Friends

NVSG_API void | GLAccum (GLenum op, GLfloat value)
Replacement of glAccum.

NVSG_API void | GLActiveStencilFace (GLenum face)
Replacement of glActiveStencilFaceEXT.

NVSG_API void | GLActiveTexture (GLenum texture)
Replacement of glActiveTexture.

NVSG_API void | GLActiveVarying (GLuint program, const GLchar *name)
Replacement of glActiveVaryingNV.

NVSG_API void | GLAddSwapHintRect (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glSwapHintRectWin.

NVSG_API void | GLAlphaFunc (GLenum func, GLclampf ref)
Replacement of glAlphaFunc.

NVSG_API GLboolean | GLAreProgramsResident (GLsizei n, const GLuint *programs, GLboolean *residences)
Replacement of glAreProgramsResidentNV.

NVSG_API GLboolean | GLAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences)
Replacement of glAreTexturesResident.

NVSG_API void | GLArrayElement (GLint i)
Replacement of glArrayElement.

NVSG_API void | GLAttachObject (GLhandleARB containerObj, GLhandleARB attachedObj)
Replacement of glAttachObjectARB.

NVSG_API void | GLAttachShader (GLuint program, GLuint shader)
Replacement of glAttachShader.

NVSG_API void | GLBegin (GLenum mode)
Replacement of glBegin.

NVSG_API void | GLBeginOcclusionQuery (GLuint id)
Replacement of glBeginOcclusionQueryNV.

NVSG_API void | GLBeginQuery (GLenum target, GLuint id)
Replacement of glBeginQuery.

NVSG_API void | GLBeginTransformFeedback (GLenum primitiveMode)
Replacement of glBeginTransformFeedbackNV.

NVSG_API void | GLBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
Replacement of glBlendColor.

NVSG_API void | GLBindArraySet (GLuint buffer)
Replacement of glBindArraySetARB.

NVSG_API void | GLBindAttribLocation (GLuint program, GLuint index, const GLchar *name)
Replacement of glBindAttribLocation.

NVSG_API void | GLBindBuffer (GLenum target, GLuint id)
Replacement of glBindBuffer.

NVSG_API void | GLBindBufferBase (GLenum target, GLuint index, GLuint buffer)
Replacement of glBindBufferBaseNV.

NVSG_API void | GLBindBufferOffset (GLenum target, GLuint index, GLuint buffer, GLintptr offset)
Replacement of glBindBufferOffsetNV.

NVSG_API void | GLBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
Replacement of glBindBufferRangeNV.

NVSG_API void | GLBindFragDataLocation (GLuint program, GLuint color, const GLchar *name)
Replacement of glBindFragDataLocationEXT.

NVSG_API void | GLBindProgram (GLenum target, GLuint id)
Replacement of glBindProgramNV.

NVSG_API void | GLBindTexture (GLenum target, GLuint texture)
Replacement of glBindTexture.

NVSG_API void | GLBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
Replacement of glBitmap.

NVSG_API void | GLBlendEquation (GLenum mode)
Replacement of glBlendEquation.

NVSG_API void | GLBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
Replacement of glBlendEquationSeparate.

NVSG_API void | GLBlendFunc (GLenum sfactor, GLenum dfactor)
Replacement of glBlendFunc.

NVSG_API void | GLBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
Replacement of glBlendFunc.

NVSG_API void | GLBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
Replacement of glBlitFramebufferEXT.

NVSG_API void | GLBufferData (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage)
Replacement of glBufferData.

NVSG_API void | GLBufferSubData (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data)
Replacement of glBufferSubData.

NVSG_API void | GLCallList (GLuint list)
Replacement of glCallList.

NVSG_API void | GLCallLists (GLsizei n, GLenum type, const GLvoid *lists)
Replacement of glCallLists.

NVSG_API void | GLClampColor (GLenum target, GLenum clamp)
Replacement of glClampColorARB.

NVSG_API void | GLClear (GLbitfield mask)
Replacement of glClear.

NVSG_API void | GLClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Replacement of glClearAccum.

NVSG_API void | GLClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
Replacement of glClearColor.

NVSG_API void | GLClearColorIi (GLint red, GLint green, GLint blue, GLint alpha)
Replacement of glClearColorIiEXT.

NVSG_API void | GLClearColorIui (GLuint red, GLuint green, GLuint blue, GLuint alpha)
Replacement of glClearColorIuiEXT.

NVSG_API void | GLClearDepth (GLclampd depth)
Replacement of glClearDepth.

NVSG_API void | GLClearDepthd (GLdouble depth)
Replacement of glClearDepthd.

NVSG_API void | GLClearIndex (GLfloat c)
Replacement of glClearIndex.

NVSG_API void | GLClearStencil (GLint s)
Replacement of glClearStencil.

NVSG_API void | GLClientActiveTexture (GLenum texture)
Replacement of glClientActiveTexture.

NVSG_API void | GLClipPlane (GLenum plane, const GLdouble *equation)
Replacement of glClipPlane.

NVSG_API void | GLColor3b (GLbyte red, GLbyte green, GLbyte blue)
Replacement of glColor3b.

NVSG_API void | GLColor3bv (const GLbyte *v)
Replacement of glColor3bv.

NVSG_API void | GLColor3d (GLdouble red, GLdouble green, GLdouble blue)
Replacement of glColor3d.

NVSG_API void | GLColor3dv (const GLdouble *v)
Replacement of glColor3dv.

NVSG_API void | GLColor3f (GLfloat red, GLfloat green, GLfloat blue)
Replacement of glColor3f.

NVSG_API void | GLColor3fv (const GLfloat *v)
Replacement of glColor3fv.

NVSG_API void | GLColor3h (GLhalf red, GLhalf green, GLhalf blue)
Replacement of glColor3hNV.

NVSG_API void | GLColor3hv (const GLhalf *v)
Replacement of glColor3hv.

NVSG_API void | GLColor3i (GLint red, GLint green, GLint blue)
Replacement of glColor3i.

NVSG_API void | GLColor3iv (const GLint *v)
Replacement of glColor3iv.

NVSG_API void | GLColor3s (GLshort red, GLshort green, GLshort blue)
Replacement of glColor3s.

NVSG_API void | GLColor3sv (const GLshort *v)
Replacement of glColor3sv.

NVSG_API void | GLColor3ub (GLubyte red, GLubyte green, GLubyte blue)
Replacement of glColor3ub.

NVSG_API void | GLColor3ubv (const GLubyte *v)
Replacement of glColor3ubv.

NVSG_API void | GLColor3ui (GLuint red, GLuint green, GLuint blue)
Replacement of glColor3ui.

NVSG_API void | GLColor3uiv (const GLuint *v)
Replacement of glColor3uiv.

NVSG_API void | GLColor3us (GLushort red, GLushort green, GLushort blue)
Replacement of glColor3us.

NVSG_API void | GLColor3usv (const GLushort *v)
Replacement of glColor3usv.

NVSG_API void | GLColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
Replacement of glColor4b.

NVSG_API void | GLColor4bv (const GLbyte *v)
Replacement of glColor4bv.

NVSG_API void | GLColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
Replacement of glColor4d.

NVSG_API void | GLColor4dv (const GLdouble *v)
Replacement of glColor4dv.

NVSG_API void | GLColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Replacement of glColor4f.

NVSG_API void | GLColor4fv (const GLfloat *v)
Replacement of glColor4fv.

NVSG_API void | GLColor4h (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha)
Replacement of glColor4hNV.

NVSG_API void | GLColor4hv (const GLhalf *v)
Replacement of glColor4hv.

NVSG_API void | GLColor4i (GLint red, GLint green, GLint blue, GLint alpha)
Replacement of glColor4i.

NVSG_API void | GLColor4iv (const GLint *v)
Replacement of glColor4iv.

NVSG_API void | GLColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha)
Replacement of glColor4s.

NVSG_API void | GLColor4sv (const GLshort *v)
Replacement of glColor4sv.

NVSG_API void | GLColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
Replacement of glColor4ub.

NVSG_API void | GLColor4ubv (const GLubyte *v)
Replacement of glColor4ubv.

NVSG_API void | GLColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha)
Replacement of glColor4ui.

NVSG_API void | GLColor4uiv (const GLuint *v)
Replacement of glColor4uiv.

NVSG_API void | GLColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha)
Replacement of glColor4us.

NVSG_API void | GLColor4usv (const GLushort *v)
Replacement of glColor4usv.

NVSG_API void | GLColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
Replacement of glColorMask.

NVSG_API void | GLColorMaskIndexed (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
Replacement of glColorMaskIndexedEXT.

NVSG_API void | GLColorMaterial (GLenum face, GLenum mode)
Replacement of glColorMaterial.

NVSG_API void | GLColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glColorPointer.

NVSG_API void | GLColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
Replacement of glColorSubTable.

NVSG_API void | GLColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
Replacement of glColorTable.

NVSG_API void | GLColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params)
Replacement of glColorTableParameterfv.

NVSG_API void | GLColorTableParameteriv (GLenum target, GLenum pname, const GLint *params)
Replacement of glColorTableParameteriv.

NVSG_API void | GLCombinerInput (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
Replacement of glCombinerInput.

NVSG_API void | GLCombinerOutput (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)
Replacement of glCombinerOutput.

NVSG_API void | GLCombinerParameterf (GLenum pname, GLfloat param)
Replacement of glCombinerParameterf.

NVSG_API void | GLCombinerParameterfv (GLenum pname, const GLfloat *params)
Replacement of glCombinerParameterfv.

NVSG_API void | GLCombinerParameteri (GLenum pname, GLint param)
Replacement of glCombinerParameteri.

NVSG_API void | GLCombinerParameteriv (GLenum pname, const GLint *params)
Replacement of glCombinerParameteriv.

NVSG_API void | GLCombinerStageParameterfv (GLenum stage, GLenum pname, const GLfloat *params)
Replacement of glCombinerStageParameterfv.

NVSG_API void | GLCompileShader (GLuint shader)
Replacement of glCompileShader.

NVSG_API void | GLCompressedTexImage1D (GLenum target, int level, GLenum internalformat, GLsizei width, int border, GLsizei imageSize, const void *data)
Replacement of glCompressedTexImage1D.

NVSG_API void | GLCompressedTexImage2D (GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, int border, GLsizei imageSize, const void *data)
Replacement of glCompressedTexImage2D.

NVSG_API void | GLCompressedTexImage3D (GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLsizei imageSize, const void *data)
Replacement of glCompressedTexImage3D.

NVSG_API void | GLCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
Replacement of glCompressedTexSubImage1D.

NVSG_API void | GLCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
Replacement of glCompressedTexSubImage2D.

NVSG_API void | GLCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
Replacement of glCompressedTexSubImage3D.

NVSG_API void | GLConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
Replacement of glConvolutionFilter1D.

NVSG_API void | GLConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
Replacement of glConvolutionFilter2D.

NVSG_API void | GLConvolutionParameterf (GLenum target, GLenum pname, GLfloat params)
Replacement of glConvolutionParameterf.

NVSG_API void | GLConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params)
Replacement of glConvolutionParameterfv.

NVSG_API void | GLConvolutionParameteri (GLenum target, GLenum pname, GLint params)
Replacement of glConvolutionParameteri.

NVSG_API void | GLConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params)
Replacement of glConvolutionParameteriv.

NVSG_API void | GLCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
Replacement of glCopyColorSubTable.

NVSG_API void | GLCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
Replacement of glCopyColorTable.

NVSG_API void | GLCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
Replacement of glCopyConvolutionFilter1D.

NVSG_API void | GLCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glCopyConvolutionFilter2D.

NVSG_API void | GLCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
Replacement of glCopyPixels.

NVSG_API void | GLCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
Replacement of glCopyTexImage1D.

NVSG_API void | GLCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
Replacement of glCopyTexImage2D.

NVSG_API void | GLCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
Replacement of glCopyTexSubImage1D.

NVSG_API void | GLCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glCopyTexSubImage2D.

NVSG_API void | GLCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glCopyTexSubImage2D.

NVSG_API GLuint | GLCreateProgram ()
Replacement of glCreateProgram.

NVSG_API GLhandleARB | GLCreateProgramObject ()
Replacement of glCreateProgramObjectARB.

NVSG_API GLuint | GLCreateShader (GLenum type)
Replacement of glCreateShader.

NVSG_API GLhandleARB | GLCreateShaderObject (GLenum shaderType)
Replacement of glCreateShaderObjectARB.

NVSG_API void | GLCullFace (GLenum mode)
Replacement of glCullFace.

NVSG_API void | GLCullFaceLock (GLenum mode)
Helper function to set the cull face mode and lock it.

NVSG_API void | GLCullFaceUnlock (GLenum mode)
Helper function to unlock the cull face and set it.

NVSG_API void | GLDeleteArraySets (GLsizei n, const GLuint *buffers)
Replacement of glDeleteArraySetsARB.

NVSG_API void | GLDeleteBuffers (GLsizei n, const GLuint *buffers)
Replacement of glDeleteBuffers.

NVSG_API void | GLDeleteFences (GLsizei n, const GLuint *fences)
Replacement of glDeleteFencesNV.

NVSG_API void | GLDeleteLists (GLuint list, GLsizei range)
Replacement of glDeleteLists.

NVSG_API void | GLDeleteObject (GLhandleARB obj)
Replacement of glDeleteObjectARB.

NVSG_API void | GLDeleteOcclusionQueries (GLsizei n, const GLuint *ids)
Replacement of glDeleteOcclusionQueriesNV.

NVSG_API void | GLDeleteProgram (GLuint program)
Replacement of glDeleteProgram.

NVSG_API void | GLDeletePrograms (GLsizei n, const GLuint *ids)
Replacement of glDeleteProgramsNV.

NVSG_API void | GLDeleteQueries (GLsizei n, const GLuint *ids)
Replacement of glDeleteQueries.

NVSG_API void | GLDeleteShader (GLuint shader)
Replacement of glDeleteShader.

NVSG_API void | GLDeleteTextures (GLsizei n, const GLuint *textures)
Replacement of glDeleteTextures.

NVSG_API void | GLDepthBounds (GLclampd zmin, GLclampd zmax)
Replacement of glDepthBounds.

NVSG_API void | GLDepthBoundsd (GLdouble zmin, GLdouble zmax)
Replacement of glDepthBoundsd.

NVSG_API void | GLDepthFunc (GLenum func)
Replacement of glDepthFunc.

NVSG_API void | GLDepthMask (GLboolean flag)
Replacement of glDepthMask.

NVSG_API void | GLDepthRange (GLclampd znear, GLclampd zfar)
Replacement of glDepthRange.

NVSG_API void | GLDepthRanged (GLdouble zNear, GLdouble zFar)
Replacement of glDepthRandedNV.

NVSG_API void | GLDetachObject (GLhandleARB containerObj, GLhandleARB attachedObj)
Replacement of glDetachObjectARB.

NVSG_API void | GLDetachShader (GLuint program, GLuint shader)
Replacement of glDetachShader.

NVSG_API void | GLDisable (GLenum cap)
Replacement of glDisable.

NVSG_API void | GLDisableAlphaTest (void)
Cached version of GLDisable( GL_ALPHA_TEST ).

NVSG_API void | GLDisableAutoNormal (void)
Cached version of GLDisable( GL_AUTO_NORMAL ).

NVSG_API void | GLDisableBlend (void)
Cached version of GLDisable( GL_BLEND ).

NVSG_API void | GLDisableClientState (GLenum array)
Replacement of glDisableClientState.

NVSG_API void | GLDisableClipPlane (GLenum plane)
Cached version of GLDisable( GL_CLIP_PLANEi ).

NVSG_API void | GLDisableColorArray (void)
Cached version of GLDisableClientState( GL_COLOR_ARRAY ).

NVSG_API void | GLDisableColorLogicOp (void)
Cached version of GLDisable( GL_COLOR_LOGIC_OP ).

NVSG_API void | GLDisableColorMaterial (void)
Cached version of GLDisable( GL_COLOR_MATERIAL ).

NVSG_API void | GLDisableCullFace (void)
Cached version of GLDisable( GL_CULL_FACE ).

NVSG_API void | GLDisableCullFaceLock (void)
Helper function to disable the cull face and lock it.

NVSG_API void | GLDisableCullFaceUnlock (void)
Helper function to unlock the cull face and set it.

NVSG_API void | GLDisableDepthTest (void)
Cached version of GLDisable( GL_DEPTH_TEST ).

NVSG_API void | GLDisableFogCoordinateArray (void)
Cached version of GLDisableClientState( GL_FOG_COORDINATE_ARRAY ).

NVSG_API void | GLDisableNormalArray (void)
Cached version of GLDisableClientState( GL_NORMAL_ARRAY ).

NVSG_API void | GLDisableDither (void)
Cached version of GLDisable( GL_DITHER ).

NVSG_API void | GLDisableFog (void)
Cached version of GLDisable( GL_FOG ).

NVSG_API void | GLDisableIndexed (GLenum target, GLuint index)
Replacement of glDiableIndexed.

NVSG_API void | GLDisableLight (GLenum light)
Cached version of GLDisable( GL_LIGHTi ).

NVSG_API void | GLDisableLighting (void)
Cached version of GLDisable( GL_LIGHTING ).

NVSG_API void | GLDisableLightingLock (void)
Helper function to disable lighting and lock it.

NVSG_API void | GLDisableLightingUnlock (void)
Helper function to unlock the lighting and disable it.

NVSG_API void | GLDisableLineSmooth (void)
Cached version of GLDisable( GL_LINE_SMOOTH ).

NVSG_API void | GLDisableLineStipple (void)
Cached version of GLDisable( GL_LINE_STIPPLE ).

NVSG_API void | GLDisableLogicOp (void)
Cached version of GLDisable( GL_LOGIC_OP ).

NVSG_API void | GLDisableNormalize (void)
Cached version of GLDisable( GL_NORMALIZE ).

NVSG_API void | GLDisablePointSmooth (void)
Cached version of GLDisable( GL_POINT_SMOOTH ).

NVSG_API void | GLDisablePolygonOffsetFill (void)
Cached version of GLDisable( GL_POLYGON_OFFSET_FILL ).

NVSG_API void | GLDisablePolygonOffsetLine (void)
Cached version of GLDisable( GL_POLYGON_OFFSET_LINE ).

NVSG_API void | GLDisablePolygonOffsetPoint (void)
Cached version of GLDisable( GL_POLYGON_OFFSET_POINT ).

NVSG_API void | GLDisablePolygonSmooth (void)
Cached version of GLDisable( GL_POLYGON_SMOOTH ).

NVSG_API void | GLDisablePolygonStipple (void)
Cached version of GLDisable( GL_POLYGON_STIPPLE ).

NVSG_API void | GLDisableScissorTest (void)
Cached version of GLDisable( GL_SCISSOR_TEST ).

NVSG_API void | GLDisableSecondaryColorArray (void)
Cached version of GLDisableClientState( GL_SECONDARY_COLOR_ARRAY ).

NVSG_API void | GLDisableStencilTest (void)
Cached version of GLDisable( GL_STENCIL_TEST ).

NVSG_API void | GLDisableTexture (GLenum target)
NVSG_API void | GLDisableTextureCoordArray (void)
Cached version of GLDisableClientState( GL_TEXTURE_COORD_ARRAY ).

NVSG_API void | GLDisableTextureGen (GLenum target)
Cached version of GLDisable( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

NVSG_API void | GLDisableVertexArray (void)
Cached version of GLDisableClientState( GL_VERTEX_ARRAY ).

NVSG_API void | GLDisableVertexAttribArray (GLuint index)
Replacement of glDisableVertexAttribArray.

NVSG_API void | GLDrawArrays (GLenum mode, GLint first, GLsizei count)
Replacement of glDrawArrays.

NVSG_API void | GLDrawArraysInstanced (GLenum mode, GLint start, GLsizei count, GLsizei primcount)
Replacement of glDrawArraysInstancedEXT.

NVSG_API void | GLDrawBuffer (GLenum mode)
Replacement of glDrawBuffer.

NVSG_API void | GLDrawBuffers (GLsizei n, const GLenum *bufs)
Replacement of glDrawBuffersARB.

NVSG_API void | GLDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
Replacement of glDrawElements.

NVSG_API void | GLDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)
Replacement of glDrawElementsInstancedEXT.

NVSG_API void | GLDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glDrawPixels.

NVSG_API void | GLDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
Replacement of glDrawRangeElements.

NVSG_API void | GLEdgeFlagPointer (GLsizei stride, const GLboolean *pointer)
Replacement of glEdgeFlagPointer.

NVSG_API void | GLEdgeFlag (GLboolean flag)
Replacement of glEdgeFlag.

NVSG_API void | GLEdgeFlagv (const GLboolean *flag)
Replacement of glEdgeFlagv.

NVSG_API void | GLEnable (GLenum cap)
Replacement of glEnable.

NVSG_API void | GLEnableAlphaTest (void)
Cached version of GLEnable( GL_ALPHA_TEST ).

NVSG_API void | GLEnableAutoNormal (void)
Cached version of GLEnable( GL_AUTO_NORMAL ).

NVSG_API void | GLEnableBlend (void)
Cached version of GLEnable( GL_BLEND ).

NVSG_API void | GLEnableClientState (GLenum array)
Replacement of glEnableClientState.

NVSG_API void | GLEnableClipPlane (GLenum plane)
Cached version of GLEnable( GL_CLIP_PLANEi ).

NVSG_API void | GLEnableColorArray (void)
Cached version of GLEnableClientState( GL_COLOR_ARRAY ).

NVSG_API void | GLEnableColorLogicOp (void)
Cached version of GLEnable( GL_COLOR_LOGIC_OP ).

NVSG_API void | GLEnableColorMaterial (void)
Cached version of GLEnable( GL_COLOR_MATERIAL ).

NVSG_API void | GLEnableCullFace (void)
Cached version of GLEnable( GL_CULL_FACE ).

NVSG_API void | GLEnableCullFaceLock (void)
Helper function to enable face culling and lock it.

NVSG_API void | GLEnableCullFaceUnlock (void)
Helper function to unlock the face culling and enable it.

NVSG_API void | GLEnableDepthTest (void)
Cached version of GLEnable( GL_DEPTH_TEST ).

NVSG_API void | GLEnableFogCoordinateArray (void)
Cached version of GLEnableClientState( GL_FOG_COORDINATE_ARRAY ).

NVSG_API void | GLEnableDither (void)
Cached version of GLEnable( GL_DITHER ).

NVSG_API void | GLEnableFog (void)
Cached version of GLEnable( GL_FOG ).

NVSG_API void | GLEnableIndexed (GLenum target, GLuint index)
Replacement of glEnabledIndexed.

NVSG_API void | GLEnableLight (GLenum light)
Cached version of GLEnable( GL_LIGHTi ).

NVSG_API void | GLEnableLighting (void)
Cached version of GLEnable( GL_LIGHTING ).

NVSG_API void | GLEnableLineSmooth (void)
Cached version of GLEnable( GL_LINE_SMOOTH ).

NVSG_API void | GLEnableLineStipple (void)
Cached version of GLEnable( GL_LINE_STIPPLE ).

NVSG_API void | GLEnableLogicOp (void)
Cached version of GLEnable( GL_LOGIC_OP ).

NVSG_API void | GLEnableNormalArray (void)
Cached version of GLEnableClientState( GL_NORMAL_ARRAY ).

NVSG_API void | GLEnableNormalize (void)
Cached version of GLEnable( GL_NORMALIZE ).

NVSG_API void | GLEnablePointSmooth (void)
Cached version of GLEnable( GL_POINT_SMOOTH ).

NVSG_API void | GLEnablePolygonOffsetFill (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_FILL ).

NVSG_API void | GLEnablePolygonOffsetLine (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_LINE ).

NVSG_API void | GLEnablePolygonOffsetPoint (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_POINT ).

NVSG_API void | GLEnablePolygonSmooth (void)
Cached version of GLEnable( GL_POLYGON_SMOOTH ).

NVSG_API void | GLEnablePolygonStipple (void)
Cached version of GLEnable( GL_POLYGON_STIPPLE ).

NVSG_API void | GLEnableScissorTest (void)
Cached version of GLEnable( GL_SCISSOR_TEST ).

NVSG_API void | GLEnableStencilTest (void)
Cached version of GLEnable( GL_STENCIL_TEST ).

NVSG_API void | GLEnableSecondaryColorArray (void)
Cached version of GLEnableClientState( GL_SECONDARY_COLOR_ARRAY ).

NVSG_API void | GLEnableTexture (GLenum target)
NVSG_API void | GLEnableTextureCoordArray (void)
Cached version of GLEnableClientState( GL_TEXTURE_COORD_ARRAY ).

NVSG_API void | GLEnableTextureGen (GLenum target)
Cached version of GLEnable( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

NVSG_API void | GLEnableVertexArray (void)
Cached version of GLEnableClientState( GL_VERTEX_ARRAY ).

NVSG_API void | GLEnableVertexAttribArray (GLuint index)
Replacement of glEnableVertexAttribArray.

NVSG_API void | GLEnd (void)
Replacement of glEnd.

NVSG_API void | GLEndList (void)
Replacement of glEndList.

NVSG_API void | GLEndOcclusionQuery (void)
Replacement of glEndOcclusionQueryNV.

NVSG_API void | GLEndQuery (GLenum target)
Replacement of glEndQuery.

NVSG_API void | GLEndTransformFeedback ()
Replacement of glEndTransformFeedbackNV.

NVSG_API void | GLEvalCoord1d (GLdouble u)
Replacement of glEvalCoord1d.

NVSG_API void | GLEvalCoord1f (GLfloat u)
Replacement of glEvalCoord1f.

NVSG_API void | GLEvalCoord2d (GLdouble u, GLdouble v)
Replacement of glEvalCoord2d.

NVSG_API void | GLEvalCoord2f (GLfloat u, GLfloat v)
Replacement of glEvalCoord2f.

NVSG_API void | GLEvalMesh1 (GLenum mode, GLint i1, GLint i2)
Replacement of glEvalMesh1.

NVSG_API void | GLEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
Replacement of glEvalMesh2.

NVSG_API void | GLEvalPoint1 (GLint i)
Replacement of glEvalPoint1.

NVSG_API void | GLEvalPoint2 (GLint i, GLint j)
Replacement of glEvalPoint2.

NVSG_API void | GLExecuteProgram (GLenum target, GLuint id, const GLfloat *params)
Replacement of glExecuteProgramNV.

NVSG_API void | GLFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer)
Replacement of glFeedbackBuffer.

NVSG_API void | GLFinalCombinerInput (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
Replacement of glFinalCombinerInput.

NVSG_API void | GLFinish (void)
Replacement of glFinish.

NVSG_API void | GLFinishFence (GLuint fence)
Replacement of glFinishFenceNV.

NVSG_API void | GLFlush (void)
Replacement of glFlush.

NVSG_API void | GLFlushPixelDataRange (GLenum target)
Replacement of glFlushPixelDataRangeNV.

NVSG_API void | GLFlushVertexArrayRange ()
Replacement of glFlushVertexArrayRange.

NVSG_API void | GLFogColor (const GLfloat *color)
Cached version of GLFog[fv|iv]( GL_FOG_COLOR, params ).

NVSG_API void | GLFogCoordd (GLdouble fog)
Replacement of glFogCoordd.

NVSG_API void | GLFogCoorddv (const GLdouble *fog)
Replacement of glFogCoorddv.

NVSG_API void | GLFogCoordf (GLfloat fog)
Replacement of glFogCoordf.

NVSG_API void | GLFogCoordfv (const GLfloat *fog)
Replacement of glFogCoordfv.

NVSG_API void | GLFogCoordh (GLhalf fog)
Replacement of glFogCoordh.

NVSG_API void | GLFogCoordhv (const GLhalf *fog)
Replacement of glFogCoordhv.

NVSG_API void | GLFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glFogCoordPointer.

NVSG_API void | GLFogDensity (GLfloat density)
Cached version of GLFog[f|fv|i|iv]( GL_FOG_DENSITY, param[s] ).

NVSG_API void | GLFogEnd (GLfloat end)
Cached version of GLFog[f|fv|i|iv]( GL_FOG_END, param[s] ).

NVSG_API void | GLFogf (GLenum pname, GLfloat param)
Replacement of glFogf.

NVSG_API void | GLFogfv (GLenum pname, const GLfloat *params)
Replacement of glFogfv.

NVSG_API void | GLFogi (GLenum pname, GLint param)
Replacement of glFogi.

NVSG_API void | GLFogiv (GLenum pname, const GLint *params)
Replacement of glFogiv.

NVSG_API void | GLFogMode (GLenum param)
Cached version of GLFog[f|fv|i|iv]( GL_FOG_MODE, param[s] ).

NVSG_API void | GLFogStart (GLfloat start)
Cached version of GLFog[f|fv|i|iv]( GL_FOG_START, param[s] ).

NVSG_API void | GLFrameTerminator (void)
Replacement of glFrameTerminatorGREMEDY.

NVSG_API void | GLFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level)
Replacement of glFramebufferTextureEXT.

NVSG_API void | GLFramebufferTextureFace (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)
Replacement of glFramebufferTextureFaceEXT.

NVSG_API void | GLFrontFace (GLenum mode)
Replacement of glFrontFace.

NVSG_API void | GLFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
Replacement of glFrustum.

NVSG_API void | GLGenArraySets (GLsizei n, GLuint *buffers)
Replacement of glGenArraySetsARB.

NVSG_API void | GLGenBuffers (GLsizei n, GLuint *buffers)
Replacement of glGenBuffers.

NVSG_API void | GLGenFences (GLsizei n, GLuint *fences)
Replacement of glGenFencesNV.

NVSG_API GLuint | GLGenLists (GLsizei range)
Replacement of glGenLists.

NVSG_API void | GLGenOcclusionQueries (GLsizei n, GLuint *ids)
Replacement of glGenOcclusionQueriesNV.

NVSG_API void | GLGenPrograms (GLsizei n, GLuint *ids)
Replacement of glGenProgramsNV.

NVSG_API void | GLGenQueries (GLsizei n, GLuint *ids)
Replacement of glGenQueries.

NVSG_API void | GLGenTextures (GLsizei n, GLuint *textures)
Replacement of glGenTextures.

NVSG_API void | GLGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
Replacement of glGetActiveAttrib.

NVSG_API void | GLGetActiveUniform (GLuint program, GLuint index, GLsizei maxLength, GLsizei *length, GLsizei *size, GLenum *type, GLcharARB *name)
Replacement of glGetActiveUniform.

NVSG_API void | GLGetActiveVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
Replacement of glGetActiveVaryingNV.

NVSG_API void | GLGetAttachedObjects (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj)
Replacement of glGetAttachedObjectsARB.

NVSG_API void | GLGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
Replacement of glGetAttachedShaders.

NVSG_API GLint | GLGetAttribLocation (GLuint program, const GLchar *name)
Replacement of glGetAttribLocation.

NVSG_API void | GLGetBooleanv (GLenum pname, GLboolean *params)
Replacement of glGetBooleanv.

NVSG_API void | GLGetBooleanIndexedv (GLenum target, GLuint index, GLboolean *data)
Replacement of glGetBooleanIndexedvEXT.

NVSG_API void | GLGetBufferParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetBufferParameteriv.

NVSG_API void | GLGetBufferPointerv (GLenum target, GLenum pname, GLvoid **params)
Replacement of glGetBufferPointerv.

NVSG_API void | GLGetBufferSubData (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data)
Replacement of glGetBufferSubData.

NVSG_API void | GLGetClipPlane (GLenum plane, GLdouble *equation)
Replacement of glGetClipPlane.

NVSG_API void | GLGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table)
Replacement of glGetColorTable.

NVSG_API void | GLGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetColorTableParameterfv.

NVSG_API void | GLGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetColorTableParameteriv.

NVSG_API void | GLGetCombinerInputParameterfv (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params)
Replacement of glGetCombinerInputParameterfv.

NVSG_API void | GLGetCombinerInputParameteriv (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params)
Replacement of glGetCombinerInputParameteriv.

NVSG_API void | GLGetCombinerOutputParameterfv (GLenum stage, GLenum portion, GLenum pname, GLfloat *params)
Replacement of glGetCombinerOutputParameterfv.

NVSG_API void | GLGetCombinerOutputParameteriv (GLenum stage, GLenum portion, GLenum pname, GLint *params)
Replacement of glGetCombinerOutputParameteriv.

NVSG_API void | GLGetCombinerStageParameterfv (GLenum stage, GLenum pname, GLfloat *params)
Replacement of glGetCombinerStageParameterfv.

NVSG_API void | GLGetCompressedTexImage (GLenum target, GLint lod, GLvoid *img)
Replacement of glGetCompressedTexImage.

NVSG_API void | GLGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image)
Replacement of glGetConvolutionFilter.

NVSG_API void | GLGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetConvolutionParameterfv.

NVSG_API void | GLGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetConvolutionParameteriv.

NVSG_API void | GLGetDoublev (GLenum pname, GLdouble *params)
Replacement of glGetDoublev.

NVSG_API void | GLGetFenceiv (GLuint fence, GLenum pname, GLint *params)
Replacement of glGetFenceivNV.

NVSG_API void | GLGetFinalCombinerInputParameterfv (GLenum variable, GLenum pname, GLfloat *params)
Replacement of glGetFinalCombinerInputParamterfv.

NVSG_API void | GLGetFinalCombinerInputParameteriv (GLenum variable, GLenum pname, GLint *params)
Replacement of glGetFinalCombinerInputParamteriv.

NVSG_API void | GLGetFloatv (GLenum pname, GLfloat *params)
Replacement of glGetFloatv.

NVSG_API void | GLGetFogColor (GLfloat *fogColor)
NVSG_API GLint | GLGetFragDataLocation (GLuint program, const GLchar *name)
Replacement of glGetFragDataLocationEXT.

NVSG_API GLhandleARB | GLGetHandle (GLenum pname)
Replacement of glGetHandleARB.

NVSG_API void | GLGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
Replacement of glGetHistogram.

NVSG_API void | GLGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetHistogramParameterfv.

NVSG_API void | GLGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetHistogramParameteriv.

NVSG_API void | GLGetInfoLog (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog)
Replacement of glGetInfoLogARB.

NVSG_API void | GLGetIntegerv (GLenum pname, GLint *params)
Replacement of glGetIntegerv.

NVSG_API void | GLGetIntegerIndexedv (GLenum target, GLuint index, GLint *data)
Replacement of glGetIntegerIndexedvEXT.

NVSG_API void | GLGetLightfv (GLenum light, GLenum pname, GLfloat *params)
Replacement of glGetLightfv.

NVSG_API void | GLGetLightiv (GLenum light, GLenum pname, GLint *params)
Replacement of glGetLightiv.

NVSG_API void | GLGetMapdv (GLenum target, GLenum query, GLdouble *v)
Replacement of glGetMapdv.

NVSG_API void | GLGetMapfv (GLenum target, GLenum query, GLfloat *v)
Replacement of glGetMapfv.

NVSG_API void | GLGetMapiv (GLenum target, GLenum query, GLint *v)
Replacement of glGetMapiv.

NVSG_API void | GLGetMaterialfv (GLenum face, GLenum pname, GLfloat *params)
Replacement of glGetMaterialfv.

NVSG_API void | GLGetMaterialiv (GLenum face, GLenum pname, GLint *params)
Replacement of glGetMaterialiv.

NVSG_API GLint | GLGetMaxTexCoords (void)
Get the maximal number of texture coordinate slots.

NVSG_API GLint | GLGetMaxTexUnits (void)
Get the maximal number of texture units.

NVSG_API GLint | GLGetMaxTexImageUnits (void)
Get the maximal number of texture image units.

NVSG_API void | GLGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
Replacement of glGetMinmax.

NVSG_API void | GLGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetMinmaxParameterfv.

NVSG_API void | GLGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetMinmaxParameteriv.

NVSG_API void | GLGetObjectParameterfv (GLhandleARB obj, GLenum pname, GLfloat *params)
Replacement of glGetObjectParameterfvARB.

NVSG_API void | GLGetObjectParameteriv (GLhandleARB obj, GLenum pname, GLint *params)
Replacement of glGetObjectParameterivARB.

NVSG_API void | GLGetOcclusionQueryiv (GLuint id, GLenum pname, GLint *params)
Replacement of glGetOcclusionQueryivNV.

NVSG_API void | GLGetOcclusionQueryuiv (GLuint id, GLenum pname, GLuint *params)
Replacement of glGetOcclusionQueryuivNV.

NVSG_API void | GLGetPixelMapfv (GLenum map, GLfloat *values)
Replacement of glGetPixelMapfv.

NVSG_API void | GLGetPixelMapuiv (GLenum map, GLuint *values)
Replacement of glGetPixelMapuiv.

NVSG_API void | GLGetPixelMapusv (GLenum map, GLushort *values)
Replacement of glGetPixelMapusv.

NVSG_API void | GLGetPointerv (GLenum pname, GLvoid **params)
Replacement of glGetPointerv.

NVSG_API void | GLGetPolygonStipple (GLubyte *mask)
Replacement of glGetPolygonStipple.

NVSG_API void | GLGetProgramEnvParameterdv (GLenum target, GLuint index, GLdouble *params)
Replacement of glGetProgramEnvParameterdvARB.

NVSG_API void | GLGetProgramEnvParameterfv (GLenum target, GLuint index, GLfloat *params)
Replacement of glGetProgramEnvParameterfvARB.

NVSG_API void | GLGetProgramiv (GLuint program, GLenum pname, GLint *params)
Replacement of glGetProgramiv.

NVSG_API void | GLGetProgramLocalParameterdv (GLenum target, GLuint index, GLdouble *params)
Replacement of glGetProgramLocalParameterdvARB.

NVSG_API void | GLGetProgramLocalParameterfv (GLenum target, GLuint index, GLfloat *params)
Replacement of glGetProgramLocalParameterfvARB.

NVSG_API void | GLGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
Replacement of glGetProgramInfoLog.

NVSG_API void | GLGetProgramEnvParameterIiv (GLenum target, GLuint index, GLint *params)
Replacement of glGetProgramEnvParameterIivNV.

NVSG_API void | GLGetProgramEnvParameterIuiv (GLenum target, GLuint index, GLuint *params)
Replacement of glGetProgramEnvParameterIuivNV.

NVSG_API void | GLGetProgramLocalParameterIiv (GLenum target, GLuint index, GLint *params)
Replacement of glGetProgramLocalParameterIivNV.

NVSG_API void | GLGetProgramLocalParameterIuiv (GLenum target, GLuint index, GLuint *params)
Replacement of glGetProgramLocalParameterIuivNV.

NVSG_API void | GLGetProgramNamedParameterdv (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params)
Replacement of glGetProgramNamedParameterdvNV.

NVSG_API void | GLGetProgramNamedParameterfv (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params)
Replacement of glGetProgramNamedParameterfvNV.

NVSG_API void | GLGetProgramParameterdv (GLenum target, GLuint index, GLenum pname, GLdouble *params)
Replacement of glGetProgramParameterdvNV.

NVSG_API void | GLGetProgramParameterfv (GLenum target, GLuint index, GLenum pname, GLfloat *params)
Replacement of glGetProgramParameterfvNV.

NVSG_API void | GLGetProgramString (GLuint id, GLenum pname, GLubyte *program)
Replacement of glGetProgramStringNV.

NVSG_API void | GLGetQueryiv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetQueryiv.

NVSG_API void | GLGetQueryObjecti64v (GLuint id, GLenum pname, GLint64EXT *params)
Replacement of glGetQueryObjecti64vEXT.

NVSG_API void | GLGetQueryObjectiv (GLuint id, GLenum pname, GLint *params)
Replacement of glGetQueryObjectiv.

NVSG_API void | GLGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64EXT *params)
Replacement of glGetQueryObjectui64vEXT.

NVSG_API void | GLGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params)
Replacement of glGetQueryObjectuiv.

NVSG_API void | GLGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
Replacement of glGetSeparableFilter.

NVSG_API void | GLGetShaderiv (GLuint shader, GLenum pname, GLint *params)
Replacement of glGetShaderiv.

NVSG_API void | GLGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
Replacement of glGetShaderInfoLog.

NVSG_API void | GLGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLcharARB *source)
Replacement of glGetShaderSource.

NVSG_API const GLubyte * | GLGetString (GLenum name)
Replacement of glGetString.

NVSG_API void | GLGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetTexEnvfv.

NVSG_API void | GLGetTexEnviv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetTexEnviv.

NVSG_API void | GLGetTexGendv (GLenum coord, GLenum pname, GLdouble *params)
Replacement of glGetTexGendv.

NVSG_API void | GLGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params)
Replacement of glGetTexGenfv.

NVSG_API void | GLGetTexGeniv (GLenum coord, GLenum pname, GLint *params)
Replacement of glGetTexGeniv.

NVSG_API void | GLGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
Replacement of glGetTexImage.

NVSG_API void | GLGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params)
Replacement of glGetTexLevelParameterfv.

NVSG_API void | GLGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params)
Replacement of glGetTexLevelParameteriv.

NVSG_API void | GLGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetTexParameterfv.

NVSG_API void | GLGetTexParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetTexParameteriv.

NVSG_API void | GLGetTexParameterIiv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetTexParameterIivEXT.

NVSG_API void | GLGetTexParameterIuiv (GLenum target, GLenum pname, GLuint *params)
Replacement of glGetTexParameterIuivEXT.

NVSG_API void | GLGetTrackMatrixiv (GLenum target, GLuint address, GLenum pname, GLint *params)
Replacement of glGetTrackMatrixivNV.

NVSG_API void | GLGetTransformFeedbackVarying (GLuint program, GLuint index, GLint *location)
Replacement of glGetTransformFeedbackVaryingNV.

NVSG_API void | GLGetUniformfv (GLuint program, GLint location, GLfloat *params)
Replacement of glGetUniformfv.

NVSG_API void | GLGetUniformiv (GLuint program, GLint location, GLint *params)
Replacement of glGetUniformiv.

NVSG_API void | GLGetUniformuiv (GLuint program, GLint location, GLuint *params)
Replacement of glGetUniformuiv.

NVSG_API GLint | GLGetUniformBufferSize (GLuint program, GLint location)
Replacement of glGetUniformBufferSizeEXT.

NVSG_API GLint | GLGetUniformLocation (GLuint program, const GLcharARB *name)
Replacement of glGetUniformLocation.

NVSG_API GLintptr | GLGetUniformOffset (GLuint program, GLint location)
Replacement of glGetUniformOffsetEXT.

NVSG_API GLint | GLGetVaryingLocation (GLuint program, const GLchar *name)
Replacement of glGetVaryingLocationNV.

NVSG_API void | GLGetVertexAttribdv (GLuint index, GLenum pname, GLdouble *params)
Replacement of glGetVertexAttribdv.

NVSG_API void | GLGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params)
Replacement of glGetVertexAttribfv.

NVSG_API void | GLGetVertexAttribiv (GLuint index, GLenum pname, GLint *params)
Replacement of glGetVertexAttribiv.

NVSG_API void | GLGetVertexAttribIiv (GLuint index, GLenum pname, GLint *params)
Replacement of glGetVertexAttribIivEXT.

NVSG_API void | GLGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint *params)
Replacement of glGetVertexAttribIuivEXT.

NVSG_API void | GLGetVertexAttribPointerv (GLuint index, GLenum pname, GLvoid **pointer)
Replacement of glGetVertexAttribPointer.

NVSG_API GLint | GLGetVersion ()
Returns the version of the OpenGL available on the target system.

NVSG_API void | GLHint (GLenum target, GLenum mode)
Replacement of glHint.

NVSG_API void | GLHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
Replacement of glHistogram.

NVSG_API void | GLIndexd (GLdouble c)
Replacement of glIndexd.

NVSG_API void | GLIndexf (GLfloat c)
Replacement of glIndexf.

NVSG_API void | GLIndexi (GLint c)
Replacement of glIndexi.

NVSG_API void | GLIndexMask (GLuint mask)
Replacement of glIndexMask.

NVSG_API void | GLIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glIndexPointer.

NVSG_API void | GLIndexs (GLshort c)
Replacement of glIndexs.

NVSG_API void | GLIndexub (GLubyte c)
Replacement of glIndexub.

NVSG_API void | GLInitNames (void)
Replacement of glInitNames.

NVSG_API void | GLInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer)
Replacement of glInterleavedArrays.

NVSG_API GLboolean | GLIsArraySet (GLuint buffer)
Replacement of glIsArraySetARB.

NVSG_API GLboolean | GLIsBuffer (GLuint name)
Replacement of glIsBuffer.

NVSG_API GLboolean | GLIsEnabled (GLenum cap)
Replacement of glIsEnabled.

NVSG_API GLboolean | GLIsEnabledAlphaTest ()
Replacement of glIsEnabled( GL_ALPHA_TEST ).

NVSG_API GLboolean | GLIsEnabledAutoNormal ()
Replacement of glIsEnabled( GL_AUTO_NORMAL ).

NVSG_API GLboolean | GLIsEnabledBlend ()
Replacement of glIsEnabled( GL_BLEND ).

NVSG_API GLboolean | GLIsEnabledClipPlane (GLenum plane)
Replacement of glIsEnabled( GL_CLIP_PLANEi ).

NVSG_API GLboolean | GLIsEnabledColorLogicOp ()
Replacement of glIsEnabled( GL_COLOR_LOGIC_OP ).

NVSG_API GLboolean | GLIsEnabledColorMaterial ()
Replacement of glIsEnabled( GL_COLOR_MATERIAL ).

NVSG_API GLboolean | GLIsEnabledCullFace ()
Replacement of glIsEnabled( GL_CULL_FACE ).

NVSG_API GLboolean | GLIsEnabledDepthTest ()
Replacement of glIsEnabled( GL_DEPTH_TEST ).

NVSG_API GLboolean | GLIsEnabledDither ()
Replacement of glIsEnabled( GL_DITHER ).

NVSG_API GLboolean | GLIsEnabledFog ()
Replacement of glIsEnabled( GL_FOG ).

NVSG_API GLboolean | GLIsEnabledIndexed (GLenum target, GLuint index)
Replacement of glIsEnabledIndexed.

NVSG_API GLboolean | GLIsEnabledLight (GLenum cap)
Replacement of glIsEnabled( GL_LIGHTi ).

NVSG_API GLboolean | GLIsEnabledLighting ()
Replacement of glIsEnabled( GL_LIGHTING ).

NVSG_API GLboolean | GLIsEnabledLineSmooth ()
Replacement of glIsEnabled( GL_LINE_SMOOTH ).

NVSG_API GLboolean | GLIsEnabledLineStipple ()
Replacement of glIsEnabled( GL_LINE_STIPPLE ).

NVSG_API GLboolean | GLIsEnabledLogicOp ()
Replacement of glIsEnabled( GL_LOGIC_OP ).

NVSG_API GLboolean | GLIsEnabledNormalize ()
Replacement of glIsEnabled( GL_NORMALIZE ).

NVSG_API GLboolean | GLIsEnabledPointSmooth ()
Replacement of glIsEnabled( GL_POINT_SMOOTH ).

NVSG_API GLboolean | GLIsEnabledPolygonOffsetFill ()
Replacement of glIsEnabled( GL_POLYGON_OFFSET_FILL ).

NVSG_API GLboolean | GLIsEnabledPolygonOffsetLine ()
Replacement of glIsEnabled( GL_POLYGON_OFFSET_LINE ).

NVSG_API GLboolean | GLIsEnabledPolygonOffsetPoint ()
Replacement of glIsEnabled( GL_POLYGON_OFFSET_POINT ).

NVSG_API GLboolean | GLIsEnabledPolygonSmooth ()
Replacement of glIsEnabled( GL_POLYGON_SMOOTH ).

NVSG_API GLboolean | GLIsEnabledPolygonStipple ()
Replacement of glIsEnabled( GL_POLYGON_STIPPLE ).

NVSG_API GLboolean | GLIsEnabledScissorTest ()
Replacement of glIsEnabled( GL_SCISSOR_TEST ).

NVSG_API GLboolean | GLIsEnabledStencilTest ()
Replacement of glIsEnabled( GL_STENCIL_TEST ).

NVSG_API GLboolean | GLIsEnabledTexture (GLenum cap)
Replacement of glIsEnabled( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

NVSG_API GLboolean | GLIsEnabledTextureGen (GLenum cap)
Replacement of glIsEnabled( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

NVSG_API GLboolean | GLIsExtensionAvailable (const std::string &extension)
Test if a given extension is available on the current context.

NVSG_API GLboolean | GLIsExtensionExported (const std::string &extension)
Test if a given extension is exported on the current context.

NVSG_API GLboolean | GLIsFence (GLuint fence)
Replacement of glIsFenceNV.

NVSG_API GLboolean | GLIsList (GLuint list)
Replacement of glIsList.

NVSG_API GLboolean | GLIsOcclusionQuery (GLuint id)
Replacement of glIsOcclusionQueryNV.

NVSG_API GLboolean | GLIsProgram (GLuint program)
Replacement of glIsProgram.

NVSG_API GLboolean | GLIsQuery (GLuint id)
Replacement of glIsQuery.

NVSG_API GLboolean | GLIsShader (GLuint shader)
Replacement of glIsShader.

NVSG_API GLboolean | GLIsTexture (GLuint texture)
Replacement of glIsTexture.

NVSG_API void | GLLightAmbient (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_AMBIENT, param ).

NVSG_API void | GLLightConstantAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_CONSTANT_ATTENUATION, param ).

NVSG_API void | GLLightDiffuse (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_DIFFUSE, param ).

NVSG_API void | GLLightf (GLenum light, GLenum pname, GLfloat param)
Replacement of glLightf.

NVSG_API void | GLLightfv (GLenum light, GLenum pname, const GLfloat *params)
Replacement of glLightfv.

NVSG_API void | GLLighti (GLenum light, GLenum pname, GLint param)
Replacement of glLighti.

NVSG_API void | GLLightiv (GLenum light, GLenum pname, GLint *params)
Replacement of glLightiv.

NVSG_API void | GLLightPosition (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_POSITION, param ).

NVSG_API void | GLLightLinearAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_LINEAR_ATTENUATION, param ).

NVSG_API void | GLLightQuadraticAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_QUADRATIC_ATTENUATION, param ).

NVSG_API void | GLLightSpecular (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_SPECULAR, param ).

NVSG_API void | GLLightSpotCutoff (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_SPOT_CUTOFF, param ).

NVSG_API void | GLLightSpotDirection (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_SPOT_DIRECTION, param ).

NVSG_API void | GLLightSpotExponent (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_SPOT_EXPONENT, param ).

NVSG_API void | GLLightModelf (GLenum pname, GLfloat param)
Replacement of glLightModelf.

NVSG_API void | GLLightModelfv (GLenum pname, const GLfloat *params)
Replacement of glLightModelfv.

NVSG_API void | GLLightModeli (GLenum pname, GLint param)
Replacement of glLightModeli.

NVSG_API void | GLLightModeliv (GLenum pname, const GLint *params)
Replacement of glLightModeliv.

NVSG_API void | GLLightModelAmbient (const GLfloat *params)
Replacement of glLightModelfv( GL_LIGHT_MODEL_AMBIENT, params ).

NVSG_API void | GLLightModelLocalViewer (GLint param)
Replacement of GLLightModelLocalViewer.

NVSG_API void | GLLightModelTwoSide (GLint param)
Replacement of GLLightModelTwoSide.

NVSG_API void | GLLightModelTwoSideLock (GLint param)
Helper function to set two sided lighting and lock it.

NVSG_API void | GLLightModelTwoSideUnlock (GLint param)
Helper function to unlock the two sided lighting and set it.

NVSG_API void | GLLineStipple (GLint factor, GLushort pattern)
Replacement of glLineStipple.

NVSG_API void | GLLineWidth (GLfloat width)
Replacement of glLineWidth.

NVSG_API void | GLLinkProgram (GLuint program)
Replacement of glLinkProgram.

NVSG_API void | GLListBase (GLuint base)
Replacement of glListBase.

NVSG_API void | GLLoadIdentity (void)
Replacement of glLoadItentity.

NVSG_API void | GLLoadMatrixd (const GLdouble *m)
Replacement of glLoadMatrixd.

NVSG_API void | GLLoadMatrixf (const GLfloat *m)
Replacement of glLoadMatrixf.

NVSG_API void | GLLoadTransposedMatrixd (const GLdouble *m)
Replacement of glLoadTransposeMatrixd.

NVSG_API void | GLLoadTransposeMatrixf (const GLfloat *m)
Replacement of glLoadTransposMatrixf.

NVSG_API void | GLLoadName (GLuint name)
Replacement of glLoadName.

NVSG_API void | GLLoadProgram (GLenum target, GLuint id, GLsizei len, const GLubyte *program)
Replacement of glLoadProgramNV.

NVSG_API void | GLLockArrays (GLint first, GLsizei count)
Replacement of glLockArrays.

NVSG_API void | GLLogicOp (GLenum opcode)
Replacement of glLogicOp.

NVSG_API void | GLMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
Replacement of glMap1d.

NVSG_API void | GLMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
Replacement of glMap1f.

NVSG_API void | GLMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
Replacement of glMap2d.

NVSG_API void | GLMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
Replacement of glMap2f.

NVSG_API GLvoid * | GLMapBuffer (GLenum target, GLenum access)
Replacement of glMapBuffer.

NVSG_API void | GLMapGrid1d (GLint un, GLdouble u1, GLdouble u2)
Replacement of glMapGrid1d.

NVSG_API void | GLMapGrid1f (GLint un, GLfloat u1, GLfloat u2)
Replacement of glMapGrid1f.

NVSG_API void | GLMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
Replacement of glMapGrid2d.

NVSG_API void | GLMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
Replacement of glMapGrid2f.

NVSG_API void | GLMaterialAmbient (GLenum face, const GLfloat *params)
Cached version of GLMaterialfv( face, GL_AMBIENT, params ).

NVSG_API void | GLMaterialAmbientBack (const GLfloat *params)
Cached version of GLMaterialf( GL_BACK, GL_AMBIENT, param ).

NVSG_API void | GLMaterialAmbientFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_AMBIENT, param ).

NVSG_API void | GLMaterialAmbientFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_AMBIENT, param ).

NVSG_API void | GLMaterialDiffuse (GLenum face, const GLfloat *params)
Cached version of GLMaterialfv( face, GL_DIFFUSE, params ).

NVSG_API void | GLMaterialDiffuseBack (const GLfloat *params)
Cached version of GLMaterialf( GL_BACK, GL_DIFFUSE, param ).

NVSG_API void | GLMaterialDiffuseFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_DIFFUSE, param ).

NVSG_API void | GLMaterialDiffuseFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_DIFFUSE, param ).

NVSG_API void | GLMaterialEmission (GLenum face, const GLfloat *params)
Cached version of GLMaterialfv( face, GL_EMISSION, params ).

NVSG_API void | GLMaterialEmissionBack (const GLfloat *params)
Cached version of GLMaterialf( GL_BACK, GL_EMISSION, param ).

NVSG_API void | GLMaterialEmissionFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_EMISSION, param ).

NVSG_API void | GLMaterialEmissionFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_EMISSION, param ).

NVSG_API void | GLMaterialf (GLenum face, GLenum pname, GLfloat param)
Replacement of glMaterialf.

NVSG_API void | GLMaterialfv (GLenum face, GLenum pname, const GLfloat *params)
Replacement of glMaterialfv.

NVSG_API void | GLMateriali (GLenum face, GLenum pname, GLint param)
Replacement of glMateriali.

NVSG_API void | GLMaterialiv (GLenum face, GLenum pname, const GLint *params)
Replacement of glMaterialiv.

NVSG_API void | GLMaterialShininess (GLenum face, GLfloat param)
Cached version of GLMaterialf( face, GL_SHININESS, param ).

NVSG_API void | GLMaterialShininessBack (GLfloat param)
Cached version of GLMaterialf( GL_BACK, GL_SHININESS, param ).

NVSG_API void | GLMaterialShininessFront (GLfloat param)
Cached version of GLMaterialf( GL_FRONT, GL_SHININESS, param ).

NVSG_API void | GLMaterialShininessFrontAndBack (GLfloat param)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, param ).

NVSG_API void | GLMaterialSpecular (GLenum face, const GLfloat *params)
Cached version of GLMaterialfv( face, GL_SPECULAR, params ).

NVSG_API void | GLMaterialSpecularBack (const GLfloat *params)
Cached version of GLMaterialf( GL_BACK, GL_SPECULAR, param ).

NVSG_API void | GLMaterialSpecularFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_SPECULAR, param ).

NVSG_API void | GLMaterialSpecularFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SPECULAR, param ).

NVSG_API void | GLMatrixMode (GLenum mode)
Replacement of glMatrixMode.

NVSG_API void | GLMinmax (GLenum target, GLenum internalformat, GLboolean sink)
Replacement of glMinmax.

NVSG_API void | GLMultiDrawArrays (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
Replacement of glMultiDrawArrays.

NVSG_API void | GLMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount)
Replacement of glMultiDrawElements.

NVSG_API void | GLMultiTexCoord1d (GLenum target, GLdouble s)
Replacement of glMultiTexCoord1d.

NVSG_API void | GLMultiTexCoord1dv (GLenum target, const GLdouble *v)
Replacement of glMultiTexCoord1dv.

NVSG_API void | GLMultiTexCoord1f (GLenum target, GLfloat s)
Replacement of glMultiTexCoord1f.

NVSG_API void | GLMultiTexCoord1fv (GLenum target, const GLfloat *v)
Replacement of glMultiTexCoord1fv.

NVSG_API void | GLMultiTexCoord1h (GLenum target, GLhalf s)
Replacement of glMultiTexCoord1hNV.

NVSG_API void | GLMultiTexCoord1hv (GLenum target, const GLhalf *v)
Replacement of glMultiTexCoord1hv.

NVSG_API void | GLMultiTexCoord1i (GLenum target, GLint s)
Replacement of glMultiTexCoord1i.

NVSG_API void | GLMultiTexCoord1iv (GLenum target, const GLint *v)
Replacement of glMultiTexCoord1iv.

NVSG_API void | GLMultiTexCoord1s (GLenum target, GLshort s)
Replacement of glMultiTexCoord1s.

NVSG_API void | GLMultiTexCoord1sv (GLenum target, const GLshort *v)
Replacement of glMultiTexCoord1sv.

NVSG_API void | GLMultiTexCoord2d (GLenum target, GLdouble s, GLdouble t)
Replacement of glMultiTexCoord2d.

NVSG_API void | GLMultiTexCoord2dv (GLenum target, const GLdouble *v)
Replacement of glMultiTexCoord2dv.

NVSG_API void | GLMultiTexCoord2f (GLenum target, GLfloat s, GLfloat t)
Replacement of glMultiTexCoord2f.

NVSG_API void | GLMultiTexCoord2fv (GLenum target, const GLfloat *v)
Replacement of glMultiTexCoord2fv.

NVSG_API void | GLMultiTexCoord2h (GLenum target, GLhalf s, GLhalf t)
Replacement of glMultiTexCoord2hNV.

NVSG_API void | GLMultiTexCoord2hv (GLenum target, const GLhalf *v)
Replacement of glMultiTexCoord2hv.

NVSG_API void | GLMultiTexCoord2i (GLenum target, GLint s, GLint t)
Replacement of glMultiTexCoord2i.

NVSG_API void | GLMultiTexCoord2iv (GLenum target, const GLint *v)
Replacement of glMultiTexCoord2iv.

NVSG_API void | GLMultiTexCoord2s (GLenum target, GLshort s, GLshort t)
Replacement of glMultiTexCoord2s.

NVSG_API void | GLMultiTexCoord2sv (GLenum target, const GLshort *v)
Replacement of glMultiTexCoord2sv.

NVSG_API void | GLMultiTexCoord3d (GLenum target, GLdouble s, GLdouble t, GLdouble r)
Replacement of glMultiTexCoord3d.

NVSG_API void | GLMultiTexCoord3dv (GLenum target, const GLdouble *v)
Replacement of glMultiTexCoord3dv.

NVSG_API void | GLMultiTexCoord3f (GLenum target, GLfloat s, GLfloat t, GLfloat r)
Replacement of glMultiTexCoord3f.

NVSG_API void | GLMultiTexCoord3fv (GLenum target, const GLfloat *v)
Replacement of glMultiTexCoord3fv.

NVSG_API void | GLMultiTexCoord3h (GLenum target, GLhalf s, GLhalf t, GLhalf r)
Replacement of glMultiTexCoord3hNV.

NVSG_API void | GLMultiTexCoord3hv (GLenum target, const GLhalf *v)
Replacement of glMultiTexCoord3hv.

NVSG_API void | GLMultiTexCoord3i (GLenum target, GLint s, GLint t, GLint r)
Replacement of glMultiTexCoord3i.

NVSG_API void | GLMultiTexCoord3iv (GLenum target, const GLint *v)
Replacement of glMultiTexCoord3iv.

NVSG_API void | GLMultiTexCoord3s (GLenum target, GLshort s, GLshort t, GLshort r)
Replacement of glMultiTexCoord3s.

NVSG_API void | GLMultiTexCoord3sv (GLenum target, const GLshort *v)
Replacement of glMultiTexCoord3sv.

NVSG_API void | GLMultiTexCoord4d (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
Replacement of glMultiTexCoord4d.

NVSG_API void | GLMultiTexCoord4dv (GLenum target, const GLdouble *v)
Replacement of glMultiTexCoord4dv.

NVSG_API void | GLMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
Replacement of glMultiTexCoord4f.

NVSG_API void | GLMultiTexCoord4fv (GLenum target, const GLfloat *v)
Replacement of glMultiTexCoord4fv.

NVSG_API void | GLMultiTexCoord4h (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q)
Replacement of glMultiTexCoord4hNV.

NVSG_API void | GLMultiTexCoord4hv (GLenum target, const GLhalf *v)
Replacement of glMultiTexCoord4hv.

NVSG_API void | GLMultiTexCoord4i (GLenum target, GLint s, GLint t, GLint r, GLint q)
Replacement of glMultiTexCoord4i.

NVSG_API void | GLMultiTexCoord4iv (GLenum target, const GLint *v)
Replacement of glMultiTexCoord4iv.

NVSG_API void | GLMultiTexCoord4s (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
Replacement of glMultiTexCoord4s.

NVSG_API void | GLMultiTexCoord4sv (GLenum target, const GLshort *v)
Replacement of glMultiTexCoord4sv.

NVSG_API void | GLMultiTexCoordPointer (GLenum target, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glMultiTexCoordPointer.

NVSG_API void | GLMultMatrixd (const GLdouble *m)
Replacement of glMultMatrixd.

NVSG_API void | GLMultMatrixf (const GLfloat *m)
Replacement of glMultMatrixf.

NVSG_API void | GLMultTransposeMatrixd (const GLdouble *m)
Replacement of glMultTransposeMatrixd.

NVSG_API void | GLMultTransposeMatrixf (const GLfloat *m)
Replacement of glMultTransposeMatrixf.

NVSG_API void | GLNewList (GLuint list, GLenum mode)
Replacement of glNewList.

NVSG_API void | GLNormal3b (GLbyte nx, GLbyte ny, GLbyte nz)
Replacement of glNormal3b.

NVSG_API void | GLNormal3bv (const GLbyte *v)
Replacement of glNormal3bv.

NVSG_API void | GLNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)
Replacement of glNormal3d.

NVSG_API void | GLNormal3dv (const GLdouble *v)
Replacement of glNormal3dv.

NVSG_API void | GLNormal3f (GLfloat nx, GLfloat ny, GLfloat nz)
Replacement of glNormal3f.

NVSG_API void | GLNormal3fv (const GLfloat *v)
Replacement of glNormal3fv.

NVSG_API void | GLNormal3h (GLhalf nx, GLhalf ny, GLhalf nz)
Replacement of glNormal3hNV.

NVSG_API void | GLNormal3hv (const GLhalf *v)
Replacement of glNormal3hv.

NVSG_API void | GLNormal3i (GLint nx, GLint ny, GLint nz)
! Replacement of glNormal3i

NVSG_API void | GLNormal3iv (const GLint *v)
Replacement of glNormal3iv.

NVSG_API void | GLNormal3s (GLshort nx, GLshort ny, GLshort nz)
Replacement of glNormal3s.

NVSG_API void | GLNormal3sv (const GLshort *v)
Replacement of glNormal3sv.

NVSG_API void | GLNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glNormalPointer.

NVSG_API void | GLOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
Replacement of glOrtho.

NVSG_API void | GLPassThrough (GLfloat token)
Replacement of glPassThrough.

NVSG_API void | GLPixelDataRange (GLenum target, GLsizei size, const GLvoid *pointer)
Replacement of glPixelDataRangeNV.

NVSG_API void | GLPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values)
Replacement of glPixelMapfv.

NVSG_API void | GLPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values)
Replacement of glPixelMapuiv.

NVSG_API void | GLPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values)
Replacement of glPixelMapusv.

NVSG_API void | GLPixelStoref (GLenum pname, GLfloat param)
Replacement of glPixelStoref.

NVSG_API void | GLPixelStorei (GLenum pname, GLint param)
Replacement of glPixelStorei.

NVSG_API void | GLPixelTransferf (GLenum pname, GLfloat param)
Replacement of glPixelTransferf.

NVSG_API void | GLPixelTransferi (GLenum pname, GLint param)
Replacement of glPixelTransferi.

NVSG_API void | GLPixelZoom (GLfloat xfactor, GLfloat yfactor)
Replacement of glPixelZoom.

NVSG_API void | GLPointParameterf (GLenum pname, GLfloat param)
Replacement of glPointParameterf.

NVSG_API void | GLPointParameterfv (GLenum pname, const GLfloat *params)
Replacement of glPointParameterfv.

NVSG_API void | GLPointParameteri (GLenum pname, GLint param)
Replacement of glPointParameteri.

NVSG_API void | GLPointParameteriv (GLenum pname, const GLint *params)
Replacement of glPointParameteriv.

NVSG_API void | GLPointSize (GLfloat size)
Replacement of glPointSize.

NVSG_API void | GLPolygonMode (GLenum face, GLenum mode)
Cached version of GLPolygonMode( face, mode ).

NVSG_API void | GLPolygonModeBack (GLenum mode)
Cached version of GLPolygonMode( GL_BACK, mode ).

NVSG_API void | GLPolygonModeFront (GLenum mode)
Cached version of GLPolygonMode( GL_FRONT, mode ).

NVSG_API void | GLPolygonModeFrontAndBack (GLenum mode)
Cached version of GLPolygonMode( GL_FRONT_AND_BACK, mode ).

NVSG_API void | GLPolygonModeLock (GLenum face, GLenum mode)
Helper function to set the polygon mode and lock it.

NVSG_API void | GLPolygonModeUnlock (GLenum face, GLenum mode)
Helper function to unlock the polygon mode and set it.

NVSG_API void | GLPolygonOffset (GLfloat factor, GLfloat units)
Replacement of glPolygonOffset.

NVSG_API void | GLPolygonStipple (const GLubyte *mask)
Replacement of glPolygonStipple.

NVSG_API void | GLPopAttrib (void)
Replacement of glPopAttrib.

NVSG_API void | GLPopClientAttrib (void)
Replacement of glPopClientAttrib.

NVSG_API void | GLPopMatrix (void)
Replacement of glPopMatrix.

NVSG_API void | GLPopName (void)
Replacement of glPopName.

NVSG_API void | GLPrimitiveRestart ()
Replacement of glPrimitiveRestart.

NVSG_API void | GLPrimitiveRestartIndex (GLuint index)
Replacement of glPrimitiveRestartIndex.

NVSG_API void | GLPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities)
Replacement of glPrioritizeTextures.

NVSG_API void | GLProgramBufferParametersfv (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params)
Replacement of glProgramBufferParametersfvNV.

NVSG_API void | GLProgramBufferParametersIiv (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params)
Replacement of glProgramBufferParametersIivNV.

NVSG_API void | GLProgramBufferParametersIuiv (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params)
Replacement of glProgramBufferParametersIuivNV.

NVSG_API void | GLProgramEnvParameter4d (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glProgramEnvParameter4dARB.

NVSG_API void | GLProgramEnvParameter4dv (GLenum target, GLuint index, const GLdouble *params)
Replacement of glProgramEnvParameter4dvARB.

NVSG_API void | GLProgramEnvParameter4f (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramEnvParameter4fARB.

NVSG_API void | GLProgramEnvParameter4fv (GLenum target, GLuint index, const GLfloat *params)
Replacement of glProgramEnvParameter4fvARB.

NVSG_API void | GLProgramEnvParametersI4iv (GLenum target, GLuint index, GLsizei count, const GLint *params)
Replacement of glProgramEnvParametersI4ivNV.

NVSG_API void | GLProgramEnvParameterI4i (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
Replacement of glProgramEnvParameterI4iNV.

NVSG_API void | GLProgramEnvParameterI4iv (GLenum target, GLuint index, const GLint *params)
Replacement of glProgramEnvParameterI4ivNV.

NVSG_API void | GLProgramEnvParametersI4uiv (GLenum target, GLuint index, GLsizei count, const GLuint *params)
Replacement of glProgramEnvParametersI4uivNV.

NVSG_API void | GLProgramEnvParameterI4ui (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
Replacement of glProgramEnvParameterI4uiNV.

NVSG_API void | GLProgramEnvParameterI4uiv (GLenum target, GLuint index, const GLuint *params)
Replacement of glProgramEnvParameterI4uivNV.

NVSG_API void | GLProgramEnvParameters4fv (GLenum target, GLuint index, GLsizei count, const GLfloat *params)
Replacement of glProgramEnvParameters4fvEXT.

NVSG_API void | GLProgramLocalParameter4d (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glProgramLocalParameter4dARB.

NVSG_API void | GLProgramLocalParameter4dv (GLenum target, GLuint index, const GLdouble *params)
Replacement of glProgramLocalParameter4dvARB.

NVSG_API void | GLProgramLocalParameter4f (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramLocalParameter4fARB.

NVSG_API void | GLProgramLocalParameter4fv (GLenum target, GLuint index, const GLfloat *params)
Replacement of glProgramLocalParameter4fvARB.

NVSG_API void | GLProgramLocalParametersI4iv (GLenum target, GLuint index, GLsizei count, const GLint *params)
Replacement of glProgramLocalParametersI4ivNV.

NVSG_API void | GLProgramLocalParametersI4uiv (GLenum target, GLuint index, GLsizei count, const GLuint *params)
Replacement of glProgramLocalParametersI4uivNV.

NVSG_API void | GLProgramLocalParameterI4i (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
Replacement of glProgramLocalParameterI4iNV.

NVSG_API void | GLProgramLocalParameterI4iv (GLenum target, GLuint index, const GLint *params)
Replacement of glProgramLocalParameterI4ivNV.

NVSG_API void | GLProgramLocalParameterI4ui (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
Replacement of glProgramLocalParameterI4uiNV.

NVSG_API void | GLProgramLocalParameterI4uiv (GLenum target, GLuint index, const GLuint *params)
Replacement of glProgramLocalParameterI4uivNV.

NVSG_API void | GLProgramLocalParameters4fv (GLenum target, GLuint index, GLsizei count, const GLfloat *params)
Replacement of glProgramLocalParameters4fvEXT.

NVSG_API void | GLProgramNamedParameter4d (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glProgramNamedParameter4dNV.

NVSG_API void | GLProgramNamedParameter4dv (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v)
Replacement of glProgramNamedParameter4dvNV.

NVSG_API void | GLProgramNamedParameter4f (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramNamedParameter4fNV.

NVSG_API void | GLProgramNamedParameter4fv (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v)
Replacement of glProgramNamedParameter4fvNV.

NVSG_API void | GLProgramParameter4d (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glProgramParameter4dNV.

NVSG_API void | GLProgramParameter4dv (GLenum target, GLuint index, const GLdouble *v)
Replacement of glProgramParameter4dvNV.

NVSG_API void | GLProgramParameter4f (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramParameter4fNV.

NVSG_API void | GLProgramParameter4fv (GLenum target, GLuint index, const GLfloat *v)
Replacement of glProgramParameter4fvNV.

NVSG_API void | GLProgramParameteri (GLuint program, GLenum pname, GLint value)
Replacement of glProgramParameteriEXT.

NVSG_API void | GLProgramParameters4dv (GLenum target, GLuint index, GLsizei count, const GLdouble *v)
Replacement of glProgramParameters4dvNV.

NVSG_API void | GLProgramParameters4fv (GLenum target, GLuint index, GLsizei count, const GLfloat *v)
Replacement of glProgramParameters4fvNV.

NVSG_API void | GLProgramString (GLenum target, GLenum format, GLsizei len, const GLvoid *string)
Replacement of glProgramStringARB.

NVSG_API void | GLProgramVertexLimit (GLenum target, GLint limit)
Replacement of glProgramVertexLimitNV.

NVSG_API void | GLPushAttrib (GLbitfield mask)
Replacement of glPushAttrib.

NVSG_API void | GLPushClientAttrib (GLbitfield mask)
Replacement of glPushClientAttrib.

NVSG_API void | GLPushMatrix (void)
Replacement of glPushMatrix.

NVSG_API void | GLPushName (GLuint name)
Replacement of glPushName.

NVSG_API void | GLRasterPos2d (GLdouble x, GLdouble y)
Replacement of glRasterPos2d.

NVSG_API void | GLRasterPos2f (GLfloat x, GLfloat y)
Replacement of glRasterPos2f.

NVSG_API void | GLRasterPos2i (GLint x, GLint y)
Replacement of glRasterPos2i.

NVSG_API void | GLRasterPos2s (GLshort x, GLshort y)
Replacement of glRasterPos2s.

NVSG_API void | GLRasterPos3d (GLdouble x, GLdouble y, GLdouble z)
Replacement of glRasterPos3d.

NVSG_API void | GLRasterPos3f (GLfloat x, GLfloat y, GLfloat z)
Replacement of glRasterPos3f.

NVSG_API void | GLRasterPos3i (GLint x, GLint y, GLint z)
Replacement of glRasterPos3i.

NVSG_API void | GLRasterPos3s (GLshort x, GLshort y, GLshort z)
Replacement of glRasterPos3s.

NVSG_API void | GLRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glRasterPos4d.

NVSG_API void | GLRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glRasterPos4f.

NVSG_API void | GLRasterPos4i (GLint x, GLint y, GLint z, GLint w)
Replacement of glRasterPos4i.

NVSG_API void | GLRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w)
Replacement of glRasterPos4s.

NVSG_API void | GLReadBuffer (GLenum mode)
Replacement of glReadBuffer.

NVSG_API void | GLReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
Replacement of glReadPixels.

NVSG_API void | GLRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
Replacement of glRectd.

NVSG_API void | GLRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
Replacement of glRectf.

NVSG_API void | GLRecti (GLint x1, GLint y1, GLint x2, GLint y2)
Replacement of glRecti.

NVSG_API void | GLRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2)
Replacement of glRects.

NVSG_API void | GLRenderMode (GLenum mode)
Replacement of glRenderMode.

NVSG_API void | GLRequestResidentPrograms (GLsizei n, const GLuint *programs)
Replacement of glRequestResidentProgramsNV.

NVSG_API void | GLResetHistogram (GLenum target)
Replacement of glResetHistogram.

NVSG_API void | GLResetMinmax (GLenum target)
Replacement of glResetMinmax.

NVSG_API void | GLRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
Replacement of glRotated.

NVSG_API void | GLRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
Replacement of glRotatef.

NVSG_API void | GLScaled (GLdouble x, GLdouble y, GLdouble z)
Replacement of glScaled.

NVSG_API void | GLScalef (GLfloat x, GLfloat y, GLfloat z)
Replacement of glScalef.

NVSG_API void | GLSampleCoverage (GLclampf value, GLboolean invert)
Replacement of glSampleCoverage.

NVSG_API void | GLScissor (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glScissor.

NVSG_API void | GLSecondaryColor3b (GLbyte red, GLbyte green, GLbyte blue)
Replacement of glSecondaryColor3b.

NVSG_API void | GLSecondaryColor3bv (const GLbyte *v)
Replacement of glSecondaryColor3bv.

NVSG_API void | GLSecondaryColor3d (GLdouble red, GLdouble green, GLdouble blue)
Replacement of glSecondaryColor3d.

NVSG_API void | GLSecondaryColor3dv (const GLdouble *v)
Replacement of glSecondaryColor3dv.

NVSG_API void | GLSecondaryColor3f (GLfloat red, GLfloat green, GLfloat blue)
Replacement of glSecondaryColor3f.

NVSG_API void | GLSecondaryColor3fv (const GLfloat *v)
Replacement of glSecondaryColor3fv.

NVSG_API void | GLSecondaryColor3h (GLhalf red, GLhalf green, GLhalf blue)
Replacement of glSecondaryColor3h.

NVSG_API void | GLSecondaryColor3hv (const GLhalf *v)
Replacement of glSecondaryColor3hv.

NVSG_API void | GLSecondaryColor3i (GLint red, GLint green, GLint blue)
Replacement of glSecondaryColor3i.

NVSG_API void | GLSecondaryColor3iv (const GLint *v)
Replacement of glSecondaryColor3iv.

NVSG_API void | GLSecondaryColor3s (GLshort red, GLshort green, GLshort blue)
Replacement of glSecondaryColor3s.

NVSG_API void | GLSecondaryColor3sv (const GLshort *v)
Replacement of glSecondaryColor3sv.

NVSG_API void | GLSecondaryColor3ub (GLubyte red, GLubyte green, GLubyte blue)
Replacement of glSecondaryColor3ub.

NVSG_API void | GLSecondaryColor3ubv (const GLubyte *v)
Replacement of glSecondaryColor3ubv.

NVSG_API void | GLSecondaryColor3ui (GLuint red, GLuint green, GLuint blue)
Replacement of glSecondaryColor3ui.

NVSG_API void | GLSecondaryColor3uiv (const GLuint *v)
Replacement of glSecondaryColor3uiv.

NVSG_API void | GLSecondaryColor3us (GLushort red, GLushort green, GLushort blue)
Replacement of glSecondaryColor3us.

NVSG_API void | GLSecondaryColor3usv (const GLushort *v)
Replacement of glSecondaryColor3usv.

NVSG_API void | GLSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glSecondaryColorPointer.

NVSG_API void | GLSelectBuffer (GLsizei size, GLuint *buffer)
Replacement of glSelectBuffer.

NVSG_API void | GLSelectTexture (GLenum target)
Replacement of glSelectTexture.

NVSG_API void | GLSelectTextureCoordSet (GLenum target)
Replacement of GLSelectTextureCoordSet.

NVSG_API void | GLSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
Replacement of glSeparableFilter2D.

NVSG_API void | GLSetFence (GLuint fence, GLenum condition)
Replacement of glSetFenceNV.

NVSG_API void | GLSetWindowStereoMode (GLboolean displayMode)
Replacement of glSetWindowStereoModeNV.

NVSG_API void | GLShadeModel (GLenum mode)
Replacement of glShadeModel.

NVSG_API void | GLShaderSource (GLuint shader, GLsizei count, const GLcharARB **string, const GLint *length)
Replacement of glShaderSource.

NVSG_API void | GLStencilClearTag (GLsizei tagBits, GLuint clearTag)
Replacement of glStencilClearTag.

NVSG_API void | GLStencilFunc (GLenum func, GLint ref, GLuint mask)
Replacement of glStencilFunc.

NVSG_API void | GLStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
Replacement of glStencilFuncSeparate.

NVSG_API void | GLStencilOpSeparate (GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
Replacement of glStencilOpSeparate.

NVSG_API void | GLStencilMaskSeparate (GLenum face, GLuint mask)
Replacement of glStencilMaskSeparate.

NVSG_API void | GLStencilMask (GLuint mask)
Replacement of glStencilMask.

NVSG_API void | GLStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
Replacement of glStencilOp.

NVSG_API void | GLStringMarker (GLsizei len, const GLvoid *string)
Replacement of glStringMarkerGREMEDY.

NVSG_API GLboolean | GLTestFence (GLuint fence)
Replacement of glTestFenceNV.

NVSG_API void | GLTexBuffer (GLenum target, GLenum internalformat, GLuint buffer)
Replacement of glTexBufferEXT.

NVSG_API void | GLTexCoord1d (GLdouble s)
Replacement of glTexCoord1d.

NVSG_API void | GLTexCoord1dv (const GLdouble *v)
Replacement of glTexCoord1dv.

NVSG_API void | GLTexCoord1f (GLfloat s)
Replacement of glTexCoord1f.

NVSG_API void | GLTexCoord1fv (const GLfloat *v)
Replacement of glTexCoord1fv.

NVSG_API void | GLTexCoord1h (GLhalf s)
Replacement of glTexCoord1hNV.

NVSG_API void | GLTexCoord1hv (const GLhalf *v)
Replacement of glTexCoord1hv.

NVSG_API void | GLTexCoord1i (GLint s)
Replacement of glTexCoord1i.

NVSG_API void | GLTexCoord1iv (const GLint *v)
Replacement of glTexCoord1iv.

NVSG_API void | GLTexCoord1s (GLshort s)
Replacement of glTexCoord1s.

NVSG_API void | GLTexCoord1sv (const GLshort *v)
Replacement of glTexCoord1sv.

NVSG_API void | GLTexCoord2d (GLdouble s, GLdouble t)
Replacement of glTexCoord2d.

NVSG_API void | GLTexCoord2dv (const GLdouble *v)
Replacement of glTexCoord2dv.

NVSG_API void | GLTexCoord2f (GLfloat s, GLfloat t)
Replacement of glTexCoord2f.

NVSG_API void | GLTexCoord2fv (const GLfloat *v)
Replacement of glTexCoord2fv.

NVSG_API void | GLTexCoord2h (GLhalf s, GLhalf t)
Replacement of glTexCoord2hNV.

NVSG_API void | GLTexCoord2hv (const GLhalf *v)
Replacement of glTexCoord2hv.

NVSG_API void | GLTexCoord2i (GLint s, GLint t)
Replacement of glTexCoord2i.

NVSG_API void | GLTexCoord2iv (const GLint *v)
Replacement of glTexCoord2iv.

NVSG_API void | GLTexCoord2s (GLshort s, GLshort t)
Replacement of glTexCoord2s.

NVSG_API void | GLTexCoord2sv (const GLshort *v)
Replacement of glTexCoord2sv.

NVSG_API void | GLTexCoord3d (GLdouble s, GLdouble t, GLdouble r)
Replacement of glTexCoord3d.

NVSG_API void | GLTexCoord3dv (const GLdouble *v)
Replacement of glTexCoord3dv.

NVSG_API void | GLTexCoord3f (GLfloat s, GLfloat t, GLfloat r)
Replacement of glTexCoord3f.

NVSG_API void | GLTexCoord3fv (const GLfloat *v)
Replacement of glTexCoord3fv.

NVSG_API void | GLTexCoord3h (GLhalf s, GLhalf t, GLhalf r)
Replacement of glTexCoord3hNV.

NVSG_API void | GLTexCoord3hv (const GLhalf *v)
Replacement of glTexCoord3hv.

NVSG_API void | GLTexCoord3i (GLint s, GLint t, GLint r)
Replacement of glTexCoord3i.

NVSG_API void | GLTexCoord3iv (const GLint *v)
Replacement of glTexCoord3iv.

NVSG_API void | GLTexCoord3s (GLshort s, GLshort t, GLshort r)
Replacement of glTexCoord3s.

NVSG_API void | GLTexCoord3sv (const GLshort *v)
Replacement of glTexCoord3sv.

NVSG_API void | GLTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)
Replacement of glTexCoord4d.

NVSG_API void | GLTexCoord4dv (const GLdouble *v)
Replacement of glTexCoord4dv.

NVSG_API void | GLTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)
Replacement of glTexCoord4f.

NVSG_API void | GLTexCoord4fv (const GLfloat *v)
Replacement of glTexCoord4fv.

NVSG_API void | GLTexCoord4h (GLhalf s, GLhalf t, GLhalf r, GLhalf q)
Replacement of glTexCoord4hNV.

NVSG_API void | GLTexCoord4hv (const GLhalf *v)
Replacement of glTexCoord4hv.

NVSG_API void | GLTexCoord4i (GLint s, GLint t, GLint r, GLint q)
Replacement of glTexCoord4i.

NVSG_API void | GLTexCoord4iv (const GLint *v)
Replacement of glTexCoord4iv.

NVSG_API void | GLTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)
Replacement of glTexCoord4s.

NVSG_API void | GLTexCoord4sv (const GLshort *v)
Replacement of glTexCoord4sv.

NVSG_API void | GLTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glTexCoordPointer.

NVSG_API void | GLTexEnvf (GLenum target, GLenum pname, GLfloat param)
Cached version of glTexEnvf( target, pname, param ).

NVSG_API void | GLTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)
Cached version of glTexEnvf( target, pname, param ).

NVSG_API void | GLTexEnvi (GLenum target, GLenum pname, GLint param)
Cached version of glTexEnvi( target, pname, param ).

NVSG_API void | GLTexEnviv (GLenum target, GLenum pname, const GLint *params)
Cached version of glTexEnviv( target, pname, param ).

NVSG_API void | GLTexGend (GLenum coord, GLenum pname, GLdouble param)
Replacement of glTexGend.

NVSG_API void | GLTexGenf (GLenum coord, GLenum pname, GLfloat param)
Replacement of glTexGenf.

NVSG_API void | GLTexGenfv (GLenum coord, GLenum pname, const GLfloat *param)
Replacement of glTexGenfv.

NVSG_API void | GLTexGeni (GLenum coord, GLenum pname, GLint param)
Replacement of glTexGeni.

NVSG_API void | GLTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexImage1D.

NVSG_API void | GLTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexImage2D.

NVSG_API void | GLTexImage3D (GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type, const void *pixels)
Replacement of glTexImage3D.

NVSG_API void | GLTexParameterf (GLenum target, GLenum pname, GLfloat param)
Cached version of glTexParameterf( target, pname, param ).

NVSG_API void | GLTexParameteri (GLenum target, GLenum pname, GLint param)
Cached version of glTexParameteri( target, pname, param ).

NVSG_API void | GLTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)
Cached version of glTexParameterfv( target, pname, params ).

NVSG_API void | GLTexParameteriv (GLenum target, GLenum pname, const GLint *params)
Cached version of glTexParameteriv( target, pname, params ).

NVSG_API void | GLTexParameterIiv (GLenum target, GLenum pname, const GLint *params)
Replacement of glTexParameterIivEXT.

NVSG_API void | GLTexParameterIuiv (GLenum target, GLenum pname, const GLuint *params)
Replacement of glTexParameterIuivEXT.

NVSG_API void | GLTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexSubImage1D.

NVSG_API void | GLTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexSubImage2D.

NVSG_API void | GLTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexSubImage3D.

NVSG_API void | GLTextureBorderColor (GLenum target, const GLfloat *params)
Cached version of GLTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, params ).

NVSG_API void | GLTextureEnvColor (const GLfloat *params)
Cached version of GLTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params ).

NVSG_API void | GLTextureEnvMode (GLint param)
Cached version of GLTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, param ).

NVSG_API void | GLTextureMagFilter (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_MAG_FILTER, param ).

NVSG_API void | GLTextureMinFilter (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_MIN_FILTER, param ).

NVSG_API void | GLTextureWrapR (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_R, param ).

NVSG_API void | GLTextureWrapS (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_S, param ).

NVSG_API void | GLTextureWrapT (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_T, param ).

NVSG_API void | GLTrackMatrix (GLenum target, GLuint address, GLenum matrix, GLenum transform)
Cached version of glTrackMatrixNV.

NVSG_API void | GLTransformFeedbackAttribs (GLuint count, const GLint *attribs, GLenum bufferMode)
Cached version of glTransformFeedbackAttribsNV.

NVSG_API void | GLTransformFeedbackVaryings (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode)
Cached version of glTransformFeedbackVaryingsNV.

NVSG_API void | GLTranslated (GLdouble x, GLdouble y, GLdouble z)
Replacement of glTranslated.

NVSG_API void | GLTranslatef (GLfloat x, GLfloat y, GLfloat z)
Replacement of glTranslatef.

NVSG_API void | GLUnlockArrays ()
Replacement of glUnlockArrays.

NVSG_API void | GLUniform1f (GLint location, GLfloat v0)
Replacement of glUniform1f.

NVSG_API void | GLUniform1fv (GLint location, GLsizei count, const GLfloat *value)
Replacement of glUniform1fv.

NVSG_API void | GLUniform1i (GLint location, GLint v0)
Replacement of glUniform1i.

NVSG_API void | GLUniform1iv (GLint location, GLsizei count, const GLint *value)
Replacement of glUniform1iv.

NVSG_API void | GLUniform1ui (GLint location, GLuint v0)
Replacement of glUniform1uiEXT.

NVSG_API void | GLUniform1uiv (GLint location, GLsizei count, const GLuint *value)
Replacement of glUniform1uivEXT.

NVSG_API void | GLUniform2f (GLint location, GLfloat v0, GLfloat v1)
Replacement of glUniform2f.

NVSG_API void | GLUniform2fv (GLint location, GLsizei count, const GLfloat *value)
Replacement of glUniform2fv.

NVSG_API void | GLUniform2i (GLint location, GLint v0, GLint v1)
Replacement of glUniform2i.

NVSG_API void | GLUniform2iv (GLint location, GLsizei count, const GLint *value)
Replacement of glUniform2iv.

NVSG_API void | GLUniform2ui (GLint location, GLuint v0, GLuint v1)
Replacement of glUniform2ui.

NVSG_API void | GLUniform2uiv (GLint location, GLsizei count, const GLuint *value)
Replacement of glUniform2uiv.

NVSG_API void | GLUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
Replacement of glUniform3f.

NVSG_API void | GLUniform3fv (GLint location, GLsizei count, const GLfloat *value)
Replacement of glUniform3fv.

NVSG_API void | GLUniform3i (GLint location, GLint v0, GLint v1, GLint v2)
Replacement of glUniform3i.

NVSG_API void | GLUniform3iv (GLint location, GLsizei count, const GLint *value)
Replacement of glUniform3iv.

NVSG_API void | GLUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2)
Replacement of glUniform3ui.

NVSG_API void | GLUniform3uiv (GLint location, GLsizei count, const GLuint *value)
Replacement of glUniform3uiv.

NVSG_API void | GLUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
Replacement of glUniform4f.

NVSG_API void | GLUniform4fv (GLint location, GLsizei count, const GLfloat *value)
Replacement of glUniform4fv.

NVSG_API void | GLUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
Replacement of glUniform4i.

NVSG_API void | GLUniform4iv (GLint location, GLsizei count, const GLint *value)
Replacement of glUniform4iv.

NVSG_API void | GLUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
Replacement of glUniform4ui.

NVSG_API void | GLUniform4uiv (GLint location, GLsizei count, const GLuint *value)
Replacement of glUniform4uiv.

NVSG_API void | GLUniformBuffer (GLuint program, GLint location, GLuint buffer)
Replacement of glUniformBufferEXT.

NVSG_API void | GLUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix2fv.

NVSG_API void | GLUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix2x3fv.

NVSG_API void | GLUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix2x4fv.

NVSG_API void | GLUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix3fv.

NVSG_API void | GLUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix3x2fv.

NVSG_API void | GLUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix3x4fv.

NVSG_API void | GLUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix4fv.

NVSG_API void | GLUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix4x2fv.

NVSG_API void | GLUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix4x3fv.

NVSG_API GLboolean | GLUnmapBuffer (GLenum target)
Replacement of glUnmapBuffer.

NVSG_API void | GLUseProgram (GLuint program)
Replacement of glUseProgram.

NVSG_API void | GLUseProgramObject (GLhandleARB programObj)
Replacement of glUseProgramObjectARB.

NVSG_API GLboolean | GLValidBackBufferHint (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glValidBackBufferHintAutodesk.

NVSG_API void | GLValidateProgram (GLuint program)
Replacement of glValidateProgram.

NVSG_API void | GLVertex2d (GLdouble x, GLdouble y)
Replacement of glVertex2d.

NVSG_API void | GLVertex2dv (const GLdouble *v)
Replacement of glVertex2dv.

NVSG_API void | GLVertex2f (GLfloat x, GLfloat y)
Replacement of glVertex2f.

NVSG_API void | GLVertex2fv (const GLfloat *v)
Replacement of glVertex2fv.

NVSG_API void | GLVertex2h (GLhalf x, GLhalf y)
Replacement of glVertex2hNV.

NVSG_API void | GLVertex2hv (const GLhalf *v)
Replacement of glVertex2hv.

NVSG_API void | GLVertex2i (GLint x, GLint y)
Replacement of glVertex2i.

NVSG_API void | GLVertex2iv (const GLint *v)
Replacement of glVertex2iv.

NVSG_API void | GLVertex2s (GLshort x, GLshort y)
Replacement of glVertex2s.

NVSG_API void | GLVertex2sv (const GLshort *v)
Replacement of glVertex2sv.

NVSG_API void | GLVertex3d (GLdouble x, GLdouble y, GLdouble z)
Replacement of glVertex3d.

NVSG_API void | GLVertex3dv (const GLdouble *v)
Replacement of glVertex3dv.

NVSG_API void | GLVertex3f (GLfloat x, GLfloat y, GLfloat z)
Replacement of glVertex3f.

NVSG_API void | GLVertex3fv (const GLfloat *v)
Replacement of glVertex3fv.

NVSG_API void | GLVertex3h (GLhalf x, GLhalf y, GLhalf z)
Replacement of glVertex3hNV.

NVSG_API void | GLVertex3hv (const GLhalf *v)
Replacement of glVertex3hv.

NVSG_API void | GLVertex3i (GLint x, GLint y, GLint z)
Replacement of glVertex3i.

NVSG_API void | GLVertex3iv (const GLint *v)
Replacement of glVertex3iv.

NVSG_API void | GLVertex3s (GLshort x, GLshort y, GLshort z)
Replacement of glVertex3s.

NVSG_API void | GLVertex3sv (const GLshort *v)
Replacement of glVertex3sv.

NVSG_API void | GLVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glVertex4d.

NVSG_API void | GLVertex4dv (const GLdouble *v)
Replacement of glVertex4dv.

NVSG_API void | GLVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glVertex4f.

NVSG_API void | GLVertex4fv (const GLfloat *v)
Replacement of glVertex4fv.

NVSG_API void | GLVertex4h (GLhalf x, GLhalf y, GLhalf z, GLhalf w)
Replacement of glVertex4hNV.

NVSG_API void | GLVertex4hv (const GLhalf *v)
Replacement of glVertex4hv.

NVSG_API void | GLVertex4i (GLint x, GLint y, GLint z, GLint w)
Replacement of glVertex4i.

NVSG_API void | GLVertex4iv (const GLint *v)
Replacement of glVertex4iv.

NVSG_API void | GLVertex4s (GLshort x, GLshort y, GLshort z, GLshort w)
Replacement of glVertex4s.

NVSG_API void | GLVertex4sv (const GLshort *v)
Replacement of glVertex4sv.

NVSG_API void | GLVertexArrayRange (GLsizei size, const GLvoid *pointer)
Replacement of glVertexArrayRange.

NVSG_API void | GLVertexAttrib1d (GLuint index, GLdouble x)
Replacement of glVertexAttrib1d.

NVSG_API void | GLVertexAttrib1dv (GLuint index, const GLdouble *v)
Replacement of glVertexAttrib1dv.

NVSG_API void | GLVertexAttrib1f (GLuint index, GLfloat x)
Replacement of glVertexAttrib1f.

NVSG_API void | GLVertexAttrib1fv (GLuint index, const GLfloat *v)
Replacement of glVertexAttrib1fv.

NVSG_API void | GLVertexAttrib1h (GLuint index, GLhalf x)
Replacement of glVertexAttrib1h.

NVSG_API void | GLVertexAttrib1hv (GLuint index, const GLhalf *v)
Replacement of glVertexAttrib1nv.

NVSG_API void | GLVertexAttrib1s (GLuint index, GLshort x)
Replacement of glVertexAttrib1s.

NVSG_API void | GLVertexAttrib1sv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib1sv.

NVSG_API void | GLVertexAttrib2d (GLuint index, GLdouble x, GLdouble y)
Replacement of glVertexAttrib2d.

NVSG_API void | GLVertexAttrib2dv (GLuint index, const GLdouble *v)
Replacement of glVertexAttrib2dv.

NVSG_API void | GLVertexAttrib2f (GLuint index, GLfloat x, GLfloat y)
Replacement of glVertexAttrib2f.

NVSG_API void | GLVertexAttrib2fv (GLuint index, const GLfloat *v)
Replacement of glVertexAttrib2fv.

NVSG_API void | GLVertexAttrib2h (GLuint index, GLhalf x, GLhalf y)
Replacement of glVertexAttrib2h.

NVSG_API void | GLVertexAttrib2hv (GLuint index, const GLhalf *v)
Replacement of glVertexAttrib2hv.

NVSG_API void | GLVertexAttrib2s (GLuint index, GLshort x, GLshort y)
Replacement of glVertexAttrib2s.

NVSG_API void | GLVertexAttrib2sv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib2sv.

NVSG_API void | GLVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)
Replacement of glVertexAttrib3d.

NVSG_API void | GLVertexAttrib3dv (GLuint index, const GLdouble *v)
Replacement of glVertexAttrib3dv.

NVSG_API void | GLVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z)
Replacement of glVertexAttrib3f.

NVSG_API void | GLVertexAttrib3fv (GLuint index, const GLfloat *v)
Replacement of glVertexAttrib3fv.

NVSG_API void | GLVertexAttrib3h (GLuint index, GLhalf x, GLhalf y, GLhalf z)
Replacement of glVertexAttrib3h.

NVSG_API void | GLVertexAttrib3hv (GLuint index, const GLhalf *v)
Replacement of glVertexAttrib3hv.

NVSG_API void | GLVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z)
Replacement of glVertexAttrib3s.

NVSG_API void | GLVertexAttrib3sv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib3sv.

NVSG_API void | GLVertexAttrib4bv (GLuint index, const GLbyte *v)
Replacement of glVertexAttrib3bv.

NVSG_API void | GLVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glVertexAttrib4d.

NVSG_API void | GLVertexAttrib4dv (GLuint index, const GLdouble *v)
Replacement of glVertexAttrib4dv.

NVSG_API void | GLVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glVertexAttrib4f.

NVSG_API void | GLVertexAttrib4fv (GLuint index, const GLfloat *v)
Replacement of glVertexAttrib4fv.

NVSG_API void | GLVertexAttrib4h (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w)
Replacement of glVertexAttrib4h.

NVSG_API void | GLVertexAttrib4hv (GLuint index, const GLhalf *v)
Replacement of glVertexAttrib4hv.

NVSG_API void | GLVertexAttrib4iv (GLuint index, const GLint *v)
Replacement of glVertexAttrib4iv.

NVSG_API void | GLVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
Replacement of glVertexAttrib4s.

NVSG_API void | GLVertexAttrib4sv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib4sv.

NVSG_API void | GLVertexAttrib4ub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
Replacement of glVertexAttrib4ub.

NVSG_API void | GLVertexAttrib4ubv (GLuint index, const GLubyte *v)
Replacement of glVertexAttrib4ubv.

NVSG_API void | GLVertexAttrib4uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttrib4uiv.

NVSG_API void | GLVertexAttrib4usv (GLuint index, const GLushort *v)
Replacement of glVertexAttrib4usv.

NVSG_API void | GLVertexAttrib4Nbv (GLuint index, const GLbyte *v)
Replacement of glVertexAttrib4Nbv.

NVSG_API void | GLVertexAttrib4Niv (GLuint index, const GLint *v)
Replacement of glVertexAttrib4Niv.

NVSG_API void | GLVertexAttrib4Nsv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib4Nsv.

NVSG_API void | GLVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
Replacement of glVertexAttrib4Nub.

NVSG_API void | GLVertexAttrib4Nubv (GLuint index, const GLubyte *v)
Replacement of glVertexAttrib4Nubv.

NVSG_API void | GLVertexAttrib4Nuiv (GLuint index, const GLuint *v)
Replacement of glVertexAttrib4Nuiv.

NVSG_API void | GLVertexAttrib4Nusv (GLuint index, const GLushort *v)
Replacement of glVertexAttrib4Nusv.

NVSG_API void | GLVertexAttribI1i (GLuint index, GLint x)
Replacement of glVertexAttribI1iEXT.

NVSG_API void | GLVertexAttribI1iv (GLuint index, const GLint *v)
Replacement of glVertexAttribI1ivEXT.

NVSG_API void | GLVertexAttribI1ui (GLuint index, GLuint x)
Replacement of glVertexAttribI1uiExt.

NVSG_API void | GLVertexAttribI1uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttribI1iuvEXT.

NVSG_API void | GLVertexAttribI2i (GLuint index, GLint x, GLint y)
Replacement of glVertexAttribI2iEXT.

NVSG_API void | GLVertexAttribI2iv (GLuint index, const GLint *v)
Replacement of glVertexAttribI2ivEXT.

NVSG_API void | GLVertexAttribI2ui (GLuint index, GLuint x, GLuint y)
Replacement of glVertexAttribI2uiExt.

NVSG_API void | GLVertexAttribI2uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttribI2uivEXT.

NVSG_API void | GLVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z)
Replacement of glVertexAttribI3iEXT.

NVSG_API void | GLVertexAttribI3iv (GLuint index, const GLint *v)
Replacement of glVertexAttribI3ivEXT.

NVSG_API void | GLVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z)
Replacement of glVertexAttribI3uiExt.

NVSG_API void | GLVertexAttribI3uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttribI3uivEXT.

NVSG_API void | GLVertexAttribI4bv (GLuint index, const GLbyte *v)
Replacement of glVertexAttribI4bvEXT.

NVSG_API void | GLVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w)
Replacement of glVertexAttribI4iEXT.

NVSG_API void | GLVertexAttribI4iv (GLuint index, const GLint *v)
Replacement of glVertexAttribI4ivEXT.

NVSG_API void | GLVertexAttribI4sv (GLuint index, const GLshort *v)
Replacement of glVertexAttribI4svEXT.

NVSG_API void | GLVertexAttribI4ubv (GLuint index, const GLubyte *v)
Replacement of glVertexAttribI4ubvEXT.

NVSG_API void | GLVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
Replacement of glVertexAttribI4uiExt.

NVSG_API void | GLVertexAttribI4uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttribI4uivEXT.

NVSG_API void | GLVertexAttribI4usv (GLuint index, const GLushort *v)
Replacement of glVertexAttribI4usvEXT.

NVSG_API void | GLVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glVertexAttribIPointerEXT.

NVSG_API void | GLVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalize, GLsizei stride, const GLvoid *pointer)
Replacement of glVertexAttribPointer.

NVSG_API void | GLVertexAttribPointerNV (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glVertexAttribPointerNV.

NVSG_API void | GLVertexAttribs1dvNV (GLuint index, GLsizei count, const GLdouble *v)
Replacement of glVertexAttribs1dvNV.

NVSG_API void | GLVertexAttribs1fvNV (GLuint index, GLsizei count, const GLfloat *v)
Replacement of glVertexAttribs1fvNV.

NVSG_API void | GLVertexAttribs1hv (GLuint index, GLsizei count, const GLhalf *v)
Replacement of glVertexAttribs1hv.

NVSG_API void | GLVertexAttribs1svNV (GLuint index, GLsizei count, const GLshort *v)
Replacement of glVertexAttribs1svNV.

NVSG_API void | GLVertexAttribs2dvNV (GLuint index, GLsizei count, const GLdouble *v)
Replacement of glVertexAttribs2dvNV.

NVSG_API void | GLVertexAttribs2fvNV (GLuint index, GLsizei count, const GLfloat *v)
Replacement of glVertexAttribs2fvNV.

NVSG_API void | GLVertexAttribs2hv (GLuint index, GLsizei count, const GLhalf *v)
Replacement of glVertexAttribs2hv.

NVSG_API void | GLVertexAttribs2svNV (GLuint index, GLsizei count, const GLshort *v)
Replacement of glVertexAttribs2svNV.

NVSG_API void | GLVertexAttribs3dvNV (GLuint index, GLsizei count, const GLdouble *v)
Replacement of glVertexAttribs3dvNV.

NVSG_API void | GLVertexAttribs3fvNV (GLuint index, GLsizei count, const GLfloat *v)
Replacement of glVertexAttribs3fvNV.

NVSG_API void | GLVertexAttribs3hv (GLuint index, GLsizei count, const GLhalf *v)
Replacement of glVertexAttribs3hv.

NVSG_API void | GLVertexAttribs3svNV (GLuint index, GLsizei count, const GLshort *v)
Replacement of glVertexAttribs3svNV.

NVSG_API void | GLVertexAttribs4dvNV (GLuint index, GLsizei count, const GLdouble *v)
Replacement of glVertexAttribs4dvNV.

NVSG_API void | GLVertexAttribs4fvNV (GLuint index, GLsizei count, const GLfloat *v)
Replacement of glVertexAttribs4fvNV.

NVSG_API void | GLVertexAttribs4hv (GLuint index, GLsizei count, const GLhalf *v)
Replacement of glVertexAttribs4hv.

NVSG_API void | GLVertexAttribs4svNV (GLuint index, GLsizei count, const GLshort *v)
Replacement of glVertexAttribs4svNV.

NVSG_API void | GLVertexAttribs4ubvNV (GLuint index, GLsizei count, const GLubyte *v)
Replacement of glVertexAttribs4svNV.

NVSG_API void | GLVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glVertexPointer.

NVSG_API void | GLViewport (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glViewport.

NVSG_API void | GLWindowBackBufferHint ()
Replacement of glWindowBackBufferHintAutodesk.

NVSG_API void | GLWindowPos2d (GLdouble x, GLdouble y)
Replacement of glWindowPos2d.

NVSG_API void | GLWindowPos2dv (const GLdouble *p)
Replacement of glWindowPos2dv.

NVSG_API void | GLWindowPos2f (GLfloat x, GLfloat y)
Replacement of glWindowPos2f.

NVSG_API void | GLWindowPos2fv (const GLfloat *p)
Replacement of glWindowPos2fv.

NVSG_API void | GLWindowPos2i (GLint x, GLint y)
Replacement of glWindowPos2i.

NVSG_API void | GLWindowPos2iv (const GLint *p)
Replacement of glWindowPos2iv.

NVSG_API void | GLWindowPos2s (GLshort x, GLshort y)
Replacement of glWindowPos2s.

NVSG_API void | GLWindowPos2sv (const GLshort *p)
Replacement of glWindowPos2sv.

NVSG_API void | GLWindowPos3d (GLdouble x, GLdouble y, GLdouble z)
Replacement of glWindowPos3d.

NVSG_API void | GLWindowPos3dv (const GLdouble *p)
Replacement of glWindowPos3dv.

NVSG_API void | GLWindowPos3f (GLfloat x, GLfloat y, GLfloat z)
Replacement of glWindowPos3f.

NVSG_API void | GLWindowPos3fv (const GLfloat *p)
Replacement of glWindowPos3fv.

NVSG_API void | GLWindowPos3i (GLint x, GLint y, GLint z)
Replacement of glWindowPos3i.

NVSG_API void | GLWindowPos3iv (const GLint *p)
Replacement of glWindowPos3iv.

NVSG_API void | GLWindowPos3s (GLshort x, GLshort y, GLshort z)
Replacement of glWindowPos3s.

NVSG_API void | GLWindowPos3sv (const GLshort *p)
Replacement of glWindowPos3sv.

NVSG_API GLboolean | GLIsRenderbuffer (GLuint renderbuffer)
Replacement of glIsRenderbufferEXT.

NVSG_API void | GLBindRenderbuffer (GLenum target, GLuint renderbuffer)
Replacement of glBindRenderbufferEXT.

NVSG_API void | GLDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers)
Replacement of glDeleteRenderbuffersEXT.

NVSG_API void | GLGenRenderbuffers (GLsizei n, GLuint *renderbuffers)
Replacement of glGenRenderbuffersEXT.

NVSG_API void | GLRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
Replacement of glRenderbufferStorageEXT.

NVSG_API void | GLRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
Replacement of glRenderbufferStorageMultisampleEXT.

NVSG_API void | GLRenderbufferStorageMultisampleCoverage (GLenum target, GLsizei coverage, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
Replacement of glRenderbufferStorageMultisampleCoverageNV.

NVSG_API void | GLGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetRenderbufferParameterivEXT.

NVSG_API GLboolean | GLIsFramebuffer (GLuint framebuffer)
Replacement of glIsFramebufferEXT.

NVSG_API void | GLBindFramebuffer (GLenum target, GLuint framebuffer)
Replacement of glBindFramebufferEXT.

NVSG_API void | GLDeleteFramebuffers (GLsizei n, const GLuint *framebuffers)
Replacement of glDeleteFramebuffersEXT.

NVSG_API void | GLGenFramebuffers (GLsizei n, GLuint *framebuffers)
Replacement of glGenFramebuffersEXT.

NVSG_API GLenum | GLCheckFramebufferStatus (GLenum target)
Replacement of glCheckFramebufferStatusEXT.

NVSG_API void | GLFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
Replacement of glFramebufferTexture1DEXT.

NVSG_API void | GLFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
Replacement of glFramebufferTexture2DEXT.

NVSG_API void | GLFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
Replacement of glFramebufferTexture3DEXT.

NVSG_API void | GLFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
Replacement of glFramebufferTextureLayerEXT.

NVSG_API void | GLFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
Replacement of glFramebufferRenderbufferEXT.

NVSG_API void | GLGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params)
Replacement of glGetFramebufferAttachmentParameterivEXT.

NVSG_API void | GLGenerateMipmap (GLenum target)
Replacement of glGenerateMipmapEXT.

NVSG_API BOOL | WGLBindTexImage (HPBUFFERARB hPbuffer, int iBuffer)
Replacement of wglBindTexImageARB.

NVSG_API BOOL | WGLChoosePixelFormat (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats)
Replacement of wglChoosePixelFormatARB.

NVSG_API HGLRC | WGLCreateContext (HDC hdc)
Replacement of wglCreateContext.

NVSG_API HPBUFFERARB | WGLCreatePbuffer (HDC hdc, int pixelFormat, int width, int height, const int *attribList)
Replacement of wglCreatePbufferARB.

NVSG_API BOOL | WGLDeleteContext (HGLRC hglrc)
Replacement of wglDeleteContext.

NVSG_API BOOL | WGLDestroyPbuffer (HPBUFFERARB hPbuffer)
Replacement of wglDestroyPbufferARB.

NVSG_API HGLRC | WGLGetCurrentContext (void)
Replacement for wglGetCurrenContext.

NVSG_API HDC | WGLGetCurrentDC (void)
Replacement for wglGetCurrentDC.

NVSG_API BOOL | WGLMakeCurrent (HDC hdc, HGLRC hglrc)
NVSG_API HDC | WGLGetPbufferDC (HPBUFFERARB hPbuffer)
Replacement of wglGetPbufferDCARB.

NVSG_API BOOL | WGLQueryPbuffer (HPBUFFERARB hPbuffer, int attribute, int *value)
Replacement of wglQueryPbufferARB.

NVSG_API int | WGLReleasePbufferDC (HPBUFFERARB hPbuffer, HDC hdc)
Replacement of wglReleasePbufferDCARB.

NVSG_API BOOL | WGLReleaseTexImage (HPBUFFERARB hPbuffer, int iBuffer)
Replacement of wglReleaseTexImageARB.

NVSG_API BOOL | WGLShareLists (HGLRC hglrc1, HGLRC hglrc2)
NVSG_API BOOL | WGLJoinSwapGroupNV (HDC hDC, GLuint group)
Replacement of wglJointSwapGroupNV.

NVSG_API BOOL | WGLBindSwapBarrierNV (GLuint group, GLuint barrier)
Replacement of wglBindSwapBarrierNV.

NVSG_API BOOL | WGLQuerySwapGroupNV (HDC hDC, GLuint *group, GLuint *barrier)
Replacement of wglQuerySwapGroupNV.

NVSG_API BOOL | WGLQueryMaxSwapGroupsNV (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers)
Replacement of wglQueryMaxSwapGroupsNV.

NVSG_API BOOL | WGLQueryFrameCountNV (HDC hDC, GLuint *count)
Replacement of wglQueryFrameCountNV.

NVSG_API BOOL | WGLResetFrameCountNV (HDC hDC)
Replacement of wglResetFrameCountNV.

NVSG_API BOOL | WGLEnumGpus (UINT iIndex, HGPUNV *hGpu)
Replacement of wglEnumGpusNV.

NVSG_API BOOL | WGLEnumGpuDevices (HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice)
Replacement of wglEnumGpuDevicesNV.

NVSG_API HDC | WGLCreateAffinityDC (const HGPUNV *pGpuList)
Replacement for wglCreateAffinityDVNV.

NVSG_API BOOL | WGLEnumGpusFromAffinityDC (HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu)
Replacement for wglEnumGpusFromAffinityDCNV.

NVSG_API BOOL | WGLDeleteDC (HDC hAffinityDC)
Replacement for wglDeleteDCNV.

NVSG_API void | WGLAttachContext (HDC, HGLRC)
NVSG_API void | WGLDetachContext (HGLRC)
NVSG_API GLXContext | GLXCreateContext (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct)
Replacement of glXCreateContext.

NVSG_API void | GLXDestroyContext (Display *dpy, GLXContext ctx)
Replacement of glXDestroyContext.

NVSG_API GLXContext | GLXGetCurrentContext ()
Replacement of glXGetCurrentContext.

NVSG_API GLXDrawable | GLXGetCurrentDrawable ()
Replacement of glXGetCurrentDrawable.

NVSG_API Bool | GLXMakeCurrent (Display *dpy, GLXDrawable drawable, GLXContext ctx)
NVSG_API void | GLXAttachContext (Display *, GLXContext)
NVSG_API void | GLXDetachContext (GLXContext)
NVSG_API int | GLXSwapInterval (int)
NVSG_API int | GLXGetVideoSync (unsigned int *)
NVSG_API int | GLXWaitVideoSync (int, int, unsigned int *)
NVSG_API Bool | GLXJoinSwapGroup (Display *dpy, GLXDrawable drawable, GLuint group)
NVSG_API Bool | GLXBindSwapBarrier (Display *dpy, GLuint group, GLuint barrier)
NVSG_API Bool | GLXQuerySwapGroup (Display *dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier)
NVSG_API Bool | GLXQueryMaxSwapGroups (Display *dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers)
NVSG_API Bool | GLXQueryFrameCount (Display *dpy, int screen, GLuint *count)
NVSG_API Bool | GLXResetFrameCount (Display *dpy, int screen)
NVSG_API int | GLXGetVideoDevice (Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice)
NVSG_API int | GLXReleaseVideoDevice (Display *dpy, int screen, GLXVideoDeviceNV VideoDevice)
NVSG_API int | GLXBindVideoImage (Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer)
NVSG_API int | GLXReleaseVideoImage (Display *dpy, GLXPbuffer pbuf)
NVSG_API int | GLXSendPbufferToVideo (Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock)
NVSG_API int | GLXGetVideoInfo (Display *dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputVideo, unsigned long *pulCounterOutputPbuffer)
NVSG_API void | GLXBindTexImage (Display *, GLXDrawable, int, const int *)
NVSG_API void | GLXReleaseTexImage (Display *, GLXDrawable, int)
NVSG_API void | GLResetAlphaFunc ()
Helper function to reset alpha function and alpha reference value.

NVSG_API void | GLResetAlphaTest ()
Helper function to reset the enable state of the alpha test.

NVSG_API void | GLResetAutoNormal ()
Helper function to reset the enable state of the auto normal calculation.

NVSG_API void | GLResetBlend ()
Helper function to reset the enable state of the blending.

NVSG_API void | GLResetBlendFunc ()
Helper function to reset the blend function.

NVSG_API void | GLResetBlendFuncSeparate ()
Helper function to reset the blend function, using the GL_EXT_blend_func_separate extention.

NVSG_API void | GLResetClearColor ()
Helper function to reset the clear color.

NVSG_API void | GLResetClearDepth ()
Helper function to reset the clear depth.

NVSG_API void | GLResetClearStencil ()
Helper function to reset the stencil clear value.

NVSG_API void | GLResetClipPlane (GLenum plane)
Helper function to reset the enable state of the clip plane plane.

NVSG_API void | GLResetClipPlaneEquation (GLenum plane)
Helper function to reset a clip plane equation.

NVSG_API void | GLResetColorLogicOp ()
Helper function to reset the enable state of the color logic operation.

NVSG_API void | GLResetColorMask ()
Helper function to reset the color mask.

NVSG_API void | GLResetColorMaterial ()
Helper function to reset the enable state of the color material.

NVSG_API void | GLResetColorMaterialMode ()
Helper function to reset the color material mode.

NVSG_API void | GLResetCullFace ()
Helper function to reset the enable state of face culling.

NVSG_API void | GLResetCullFaceMode ()
Helper function to reset the cull face mode.

NVSG_API void | GLResetDepthFunc ()
Helper function to reset the depth func.

NVSG_API void | GLResetDepthMask ()
Helper function to reset the depth mask.

NVSG_API void | GLResetDepthRange ()
Helper function to reset the depth range.

NVSG_API void | GLResetDepthTest ()
Helper function to reset the enable state of depth testing.

NVSG_API void | GLResetDither ()
Helper function to reset the enable state of dithering.

NVSG_API void | GLResetFog ()
Helper function to reset the the enable state of fogging.

NVSG_API void | GLResetFogColor ()
Helper function to reset the fog color.

NVSG_API void | GLResetFogDensity ()
Helper function to reset the fog density.

NVSG_API void | GLResetFogEnd ()
Helper function to reset the fog end value.

NVSG_API void | GLResetFogMode ()
Helper function to reset the fog mode.

NVSG_API void | GLResetFogStart ()
Helper function to reset the fog start value.

NVSG_API void | GLResetFrontFace ()
Helper function to reset the front face state.

NVSG_API void | GLResetLight (GLenum light)
Helper function to reset the enable state of the light light.

NVSG_API void | GLResetLighting ()
Helper function to reset the enable state of lighting.

NVSG_API void | GLResetLightAmbient (GLenum light)
Helper function to reset the ambient light color.

NVSG_API void | GLResetLightConstantAttenuation (GLenum light)
Helper function to reset the constant attenuation of the light light.

NVSG_API void | GLResetLightDiffuse (GLenum light)
Helper function to reset the diffuse color of the light light.

NVSG_API void | GLResetLightLinearAttenuation (GLenum light)
Helper function to reset the linear attenuation of the light light.

NVSG_API void | GLResetLightModelAmbient ()
Helper function to reset the ambient light color.

NVSG_API void | GLResetLightModelLocalViewer ()
Helper function to reset the local viewer setting.

NVSG_API void | GLResetLightModelTwoSide ()
Helper function to reset the two sided lighting state.

NVSG_API void | GLResetLightPosition (GLenum light)
Helper function to reset the position of the light light.

NVSG_API void | GLResetLightQuadraticAttenuation (GLenum light)
Helper function to reset the quadratic attenuation of the light light.

NVSG_API void | GLResetLightSpecular (GLenum light)
Helper function to reset the specular color of the light light.

NVSG_API void | GLResetLightSpotCutoff (GLenum light)
Helper function to reset the spot cutoff of the light light.

NVSG_API void | GLResetLightSpotDirection (GLenum light)
Helper function to reset the spot cutoff of the light light.

NVSG_API void | GLResetLightSpotExponent (GLenum light)
Helper function to reset the spot exponent of the light light.

NVSG_API void | GLResetLineSmooth ()
Helper function to reset the enable state of line smoothing.

NVSG_API void | GLResetLineStipple ()
Helper function to reset the enable state of line stippling.

NVSG_API void | GLResetLineStippleDefinition ()
Helper function to reset line stipple repeat and pattern.

NVSG_API void | GLResetLineWidth ()
Helper function to reset the line width.

NVSG_API void | GLResetLogicOp ()
Helper function to reset the enable state of logic operation.

NVSG_API void | GLResetMaterialAmbientBack ()
Helper function to reset the material back face ambient color.

NVSG_API void | GLResetMaterialAmbientFront ()
Helper function to reset the material front face ambient color.

NVSG_API void | GLResetMaterialAmbientFrontAndBack ()
Helper function to reset the material back and front face ambient color.

NVSG_API void | GLResetMaterialDiffuseBack ()
Helper function to reset the material back face diffuse color.

NVSG_API void | GLResetMaterialDiffuseFront ()
Helper function to reset the material front face diffuse color.

NVSG_API void | GLResetMaterialDiffuseFrontAndBack ()
Helper function to reset the material back and front face diffuse color.

NVSG_API void | GLResetMaterialEmissionBack ()
Helper function to reset the material back face emission color.

NVSG_API void | GLResetMaterialEmissionFront ()
Helper function to reset the material front face emission color.

NVSG_API void | GLResetMaterialEmissionFrontAndBack ()
Helper function to reset the material back and front face emission color.

NVSG_API void | GLResetMaterialShininessBack ()
Helper function to reset the material back face shininess.

NVSG_API void | GLResetMaterialShininessFront ()
Helper function to reset the material front face shininess.

NVSG_API void | GLResetMaterialShininessFrontAndBack ()
Helper function to reset the material back and front face shininess.

NVSG_API void | GLResetMaterialSpecularBack ()
Helper function to reset the material back face specular color.

NVSG_API void | GLResetMaterialSpecularFront ()
Helper function to reset the material front face specular color.

NVSG_API void | GLResetMaterialSpecularFrontAndBack ()
Helper function to reset the material back and front face specular color.

NVSG_API void | GLResetNormalize ()
Helper function to reset the enable state of normalizing.

NVSG_API void | GLResetPointSize ()
Helper function to reset the point size.

NVSG_API void | GLResetPointSmooth ()
Helper function to reset the enable state of point smoothing.

NVSG_API void | GLResetPolygonModeBack ()
Helper function to reset back face polygon mode.

NVSG_API void | GLResetPolygonModeFront ()
Helper function to reset front face polygon mode.

NVSG_API void | GLResetPolygonModeFrontAndBack ()
Helper function to reset back and front face polygon mode.

NVSG_API void | GLResetPolygonOffset ()
Helper function to reset the polygon offset.

NVSG_API void | GLResetPolygonOffsetFill ()
Helper function to reset the enable state of filled polygon offset.

NVSG_API void | GLResetPolygonOffsetLine ()
Helper function to reset the enable state of lined polygon offset.

NVSG_API void | GLResetPolygonOffsetPoint ()
Helper function to reset the enable state of pointed polygon offset.

NVSG_API void | GLResetPolygonSmooth ()
Helper function to reset the enable state of polygon smoothing.

NVSG_API void | GLResetPolygonStipple ()
Helper function to reset the enable state of polygon stippling.

NVSG_API void | GLResetScissor ()
Helper function to reset the scissor rectangle.

NVSG_API void | GLResetScissorTest ()
Helper function to reset the enable state of scissor testing.

NVSG_API void | GLResetShadeModel ()
Helper function to reset the shade model.

NVSG_API void | GLResetStencilFunc ()
Helper function to reset the stencil function values.

NVSG_API void | GLResetStencilMask ()
Helper function to reset the stencil mask.

NVSG_API void | GLResetStencilOp ()
Helper function to reset the stencil operation values.

NVSG_API void | GLResetStencilTest ()
Helper function to reset the enable state of stencil testing.

NVSG_API void | GLResetTexture (GLenum target)
Helper function to reset the enable state of texture target target.

NVSG_API void | GLCgGLBindEffect (nvsg::CgFxEffect *effect)
NVSG_API nvsg::CgFxEffect * | GLCgGLGetEffect ()
NVSG_API void | GLCgGLBindPass (nvsg::CgFxPass pass)
NVSG_API nvsg::CgFxPass | GLCgGLGetPass ()
NVSG_API void | GLCgGLBindProgram (nvsg::CgFxProgram program)
NVSG_API nvsg::CgFxProgram | GLCgGLGetProgram ()
NVSG_API void | GLCgGLApplyProgramSamplers ()
NVSG_API void | GLGenDisplayListCache (nvsg::DALHost *host, GLDisplayListCache *&cache)
NVSG_API void | GLDeleteDisplayListCaches ()
NVSG_API void | GLGenArrayBufferCache (nvsg::DALHost *host, GLArrayBufferCache *&cache)
NVSG_API void | GLGenElementArrayBufferCache (nvsg::DALHost *host, GLElementArrayBufferCache *&cache)
NVSG_API void | GLGenPixelBufferCache (nvsg::DALHost *host, GLPixelBufferCache *&cache)
NVSG_API void | GLDeleteBufferCaches ()
NVSG_API void | GLGenTextureCache (nvsg::DALHost *host, GLTextureCache *&cache)
NVSG_API void | GLGenTextureCache (nvsg::DALHost *host, GLTextureCache *&cache, GLuint texture, GLenum target)
NVSG_API void | GLDeleteTextureCaches ()
NVSG_API bool | GLIsValidDisplayListCache (const GLDisplayListCache *cache)
NVSG_API bool | GLIsValidArrayBufferCache (const GLArrayBufferCache *cache)
NVSG_API bool | GLIsValidElementArrayBufferCache (const GLElementArrayBufferCache *cache)
NVSG_API bool | GLIsValidPixelBufferCache (const GLPixelBufferCache *cache)
NVSG_API bool | GLIsValidTextureCache (const GLTextureCache *cache)
NVSG_API bool | GLGetTexImageFmt (GLTexImageFmt &tfmt, nvsg::Image::PixelFormat fmt, nvsg::Image::PixelDataType type, nvsg::TextureImage::TextureGPUFormat gpuFmt=nvsg::TextureImage::TGF_DEFAULT)
Returns a GLTexImageFmt according to the passed in PixelFormat and PixelDataType descriptors.

NVSG_API void | GLUploadTexImage1D (GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage *, GLTextureCache *)
NVSG_API void | GLUploadTexImage2D (GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage *, GLTextureCache *)
NVSG_API void | GLUploadTexImage3D (GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage *, GLTextureCache *)
NVSG_API void | GLUploadTexImageCube (GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage *, GLTextureCache *)
NVSG_API void | GLUploadTexImage1DArray (GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage *, GLTextureCache *)
NVSG_API void | GLUploadTexImage2DArray (GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage *, GLTextureCache *)
NVSG_API void | GLUploadTexImageRectangle (GLint intFmt, GLint usrFmt, GLint type, nvsg::TextureImage *, GLTextureCache *)
NVSG_API GLenum | GLGetTexWrapMode (nvsg::TextureWrapMode twm)
Translate an nvsg::TextureWrapMode into a GL-specific texture wrap mode as a GLenum.

Detailed Description

Wrapper for OpenGL functions to provide caching, extension handling, and, in debug mode, error handling per context.

A GLContext is defined per pair of <HDC,HGLRC> for Windows or <Display*,GLXContext> for Linux. It holds informations to cache the most important OpenGL states.
You will never have to use this class explicitly. For creation, deletion, and consistent interaction, instead of using the functions with the lowercase prefix wgl on Windows, use the corresponding functions with the uppercase prefix WGL. That is, instead of using wglCreateContext(), use WGLCreateContext(). On Linux, instead of using the prefix glX, use the prefix GLX.
To use it consistently, all OpenGL calls should be replaced by the corresponding functions with uppercase GL, defined in GLContext.h. I.e. instead of using glAccum(), you should use GLAccum(). For some of the OpenGL state handling functions, there are slightly faster specialized functions with uppercase GL. For example, instead of using glDisable(GL_BLEND), you could either use GLDisable(GL_BLEND) or the specialized function GLDisableBlend(). Note, that there might be states that are not covered with specialized functions.
In the debug build, all the functions with uppercase prefix also test for the OpenGL error code being GL_NO_ERROR and assert on failure.

Member Function Documentation

Display* getDisplay ( ) [inline]

Get the Display of this GLContext (Linux only).

Returns:
The pointer to the Display of this GLContext.

Friends And Related Function Documentation

NVSG_API void GLAccum | ( | GLenum | op,
 |  | GLfloat | value
 | ) | [friend]

Replacement of glAccum.

This function asserts on the result before returning.

NVSG_API void GLActiveStencilFace ( GLenum face ) [friend]

Replacement of glActiveStencilFaceEXT.

This function asserts on the result before returning.

NVSG_API void GLActiveTexture ( GLenum texture ) [friend]

Replacement of glActiveTexture.

This function stores the texture to activate for subsequent texture operations.

NVSG_API void GLActiveVarying | ( | GLuint | program,
 |  | const GLchar * | name
 | ) | [friend]

Replacement of glActiveVaryingNV.

This function asserts on the result before returning.

NVSG_API void GLAddSwapHintRect | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glSwapHintRectWin.

This function asserts on the result before returning.

NVSG_API void GLAlphaFunc | ( | GLenum | func,
 |  | GLclampf | ref
 | ) | [friend]

Replacement of glAlphaFunc.

This function caches the alpha func and ref and asserts on the result before returning.

NVSG_API GLboolean GLAreProgramsResident | ( | GLsizei | n,
 |  | const GLuint * | programs,
 |  | GLboolean * | residences
 | ) | [friend]

Replacement of glAreProgramsResidentNV.

This function asserts on the result before returning.

NVSG_API GLboolean GLAreTexturesResident | ( | GLsizei | n,
 |  | const GLuint * | textures,
 |  | GLboolean * | residences
 | ) | [friend]

Replacement of glAreTexturesResident.

This function asserts on the result before returning.

NVSG_API void GLArrayElement ( GLint i ) [friend]

Replacement of glArrayElement.

This function asserts on the result before returning.

NVSG_API void GLAttachObject | ( | GLhandleARB | containerObj,
 |  | GLhandleARB | attachedObj
 | ) | [friend]

Replacement of glAttachObjectARB.

This function asserts on the result before returning.

NVSG_API void GLAttachShader | ( | GLuint | program,
 |  | GLuint | shader
 | ) | [friend]

Replacement of glAttachShader.

This function asserts on the result before returning.

NVSG_API void GLBegin ( GLenum mode ) [friend]

Replacement of glBegin.

This function asserts on the result before returning.

NVSG_API void GLBeginOcclusionQuery ( GLuint id ) [friend]

Replacement of glBeginOcclusionQueryNV.

This function asserts on the result before returning.

NVSG_API void GLBeginQuery | ( | GLenum | target,
 |  | GLuint | id
 | ) | [friend]

Replacement of glBeginQuery.

This function asserts on the result before returning.

NVSG_API void GLBeginTransformFeedback ( GLenum primitiveMode ) [friend]

Replacement of glBeginTransformFeedbackNV.

NVSG_API void GLBlendColor | ( | GLclampf | red,
 |  | GLclampf | green,
 |  | GLclampf | blue,
 |  | GLclampf | alpha
 | ) | [friend]

Replacement of glBlendColor.

NVSG_API void GLBindArraySet ( GLuint buffer ) [friend]

Replacement of glBindArraySetARB.

NVSG_API void GLBindAttribLocation | ( | GLuint | program,
 |  | GLuint | index,
 |  | const GLchar * | name
 | ) | [friend]

Replacement of glBindAttribLocation.

NVSG_API void GLBindBuffer | ( | GLenum | target,
 |  | GLuint | id
 | ) | [friend]

Replacement of glBindBuffer.

This function caches and asserts on the result before returning.

NVSG_API void GLBindBufferBase | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | buffer
 | ) | [friend]

Replacement of glBindBufferBaseNV.

This function asserts on the result before returning.

NVSG_API void GLBindBufferOffset | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | buffer,
 |  | GLintptr | offset
 | ) | [friend]

Replacement of glBindBufferOffsetNV.

This function asserts on the result before returning.

NVSG_API void GLBindBufferRange | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | buffer,
 |  | GLintptr | offset,
 |  | GLsizeiptr | size
 | ) | [friend]

Replacement of glBindBufferRangeNV.

This function asserts on the result before returning.

NVSG_API void GLBindFragDataLocation | ( | GLuint | program,
 |  | GLuint | color,
 |  | const GLchar * | name
 | ) | [friend]

Replacement of glBindFragDataLocationEXT.

This function asserts on the result before returning.

NVSG_API void GLBindProgram | ( | GLenum | target,
 |  | GLuint | id
 | ) | [friend]

Replacement of glBindProgramNV.

This function hides the extension character of glBindProgramNV and asserts on the result before returning.

NVSG_API void GLBindTexture | ( | GLenum | target,
 |  | GLuint | texture
 | ) | [friend]

Replacement of glBindTexture.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLBitmap | ( | GLsizei | width,
 |  | GLsizei | height,
 |  | GLfloat | xorig,
 |  | GLfloat | yorig,
 |  | GLfloat | xmove,
 |  | GLfloat | ymove,
 |  | const GLubyte * | bitmap
 | ) | [friend]

Replacement of glBitmap.

This function asserts on the result before returning.

NVSG_API void GLBlendEquation ( GLenum mode ) [friend]

Replacement of glBlendEquation.

This function asserts on the result before returning.

NVSG_API void GLBlendEquationSeparate | ( | GLenum | modeRGB,
 |  | GLenum | modeAlpha
 | ) | [friend]

Replacement of glBlendEquationSeparate.

This function asserts on the result before returning.

NVSG_API void GLBlendFunc | ( | GLenum | sfactor,
 |  | GLenum | dfactor
 | ) | [friend]

Replacement of glBlendFunc.

This function caches the blend func settings and asserts on the result before returning.

NVSG_API void GLBlendFuncSeparate | ( | GLenum | sfactorRGB,
 |  | GLenum | dfactorRGB,
 |  | GLenum | sfactorAlpha,
 |  | GLenum | dfactorAlpha
 | ) | [friend]

Replacement of glBlendFunc.

This function caches the blend func settings and asserts on the result before returning.

NVSG_API void GLBlitFramebuffer | ( | GLint | srcX0,
 |  | GLint | srcY0,
 |  | GLint | srcX1,
 |  | GLint | srcY1,
 |  | GLint | dstX0,
 |  | GLint | dstY0,
 |  | GLint | dstX1,
 |  | GLint | dstY1,
 |  | GLbitfield | mask,
 |  | GLenum | filter
 | ) | [friend]

Replacement of glBlitFramebufferEXT.

Parameters:
srcX0 | source lower left X pos
srcY0 | source lower left Y pos
srcX1 | source upper right X pos
srcY1 | source upper right Y pos
dstX0 | destination lower left X pos
dstY0 | destination lower left Y pos
dstX1 | destination upper right X pos
dstY1 | destination uppoer right Y pos
mask | mask containing bits for COLOR, DEPTH, or STENCIL to blit.
filter | filter to use if src and dst are not the same size. Must be GL_NEAREST or GL_LINEAR. Must be GL_NEAREST if mask contains anything but the color buffer.
Note:
It is assumed that the extension GL_EXT_framebuffer_blit is supported.

This function asserts on no GL error.

NVSG_API void GLBufferData | ( | GLenum | target,
 |  | GLsizeiptrARB | size,
 |  | const GLvoid * | data,
 |  | GLenum | usage
 | ) | [friend]

Replacement of glBufferData.

This function asserts on the result before returning.

NVSG_API void GLBufferSubData | ( | GLenum | target,
 |  | GLintptrARB | offset,
 |  | GLsizeiptrARB | size,
 |  | const GLvoid * | data
 | ) | [friend]

Replacement of glBufferSubData.

This function and asserts on the result before returning.

NVSG_API void GLCallList ( GLuint list ) [friend]

Replacement of glCallList.

This function asserts on the result before returning.

NVSG_API void GLCallLists | ( | GLsizei | n,
 |  | GLenum | type,
 |  | const GLvoid * | lists
 | ) | [friend]

Replacement of glCallLists.

This function asserts on the result before returning.

NVSG_API void GLClampColor | ( | GLenum | target,
 |  | GLenum | clamp
 | ) | [friend]

Replacement of glClampColorARB.

This function asserts on the result before returning.

NVSG_API void GLClear ( GLbitfield mask ) [friend]

Replacement of glClear.

This function asserts on the result before returning.

NVSG_API void GLClearAccum | ( | GLfloat | red,
 |  | GLfloat | green,
 |  | GLfloat | blue,
 |  | GLfloat | alpha
 | ) | [friend]

Replacement of glClearAccum.

This function asserts on the result before returning.

NVSG_API void GLClearColor | ( | GLclampf | red,
 |  | GLclampf | green,
 |  | GLclampf | blue,
 |  | GLclampf | alpha
 | ) | [friend]

Replacement of glClearColor.

This function caches the clear color settings and asserts on the result before returning.

NVSG_API void GLClearColorIi | ( | GLint | red,
 |  | GLint | green,
 |  | GLint | blue,
 |  | GLint | alpha
 | ) | [friend]

Replacement of glClearColorIiEXT.

This function asserts on the result before returning.

NVSG_API void GLClearColorIui | ( | GLuint | red,
 |  | GLuint | green,
 |  | GLuint | blue,
 |  | GLuint | alpha
 | ) | [friend]

Replacement of glClearColorIuiEXT.

This function asserts on the result before returning.

NVSG_API void GLClearDepth ( GLclampd depth ) [friend]

Replacement of glClearDepth.

This function caches the depth clear setting and asserts on the result before returning.

NVSG_API void GLClearDepthd ( GLdouble depth ) [friend]

Replacement of glClearDepthd.

This functions asserts on the result before returning.

NVSG_API void GLClearIndex ( GLfloat c ) [friend]

Replacement of glClearIndex.

This function asserts on the result before returning.

NVSG_API void GLClearStencil ( GLint s ) [friend]

Replacement of glClearStencil.

This function caches the stencil clear setting and asserts on the result before returning.

NVSG_API void GLClientActiveTexture ( GLenum texture ) [friend]

Replacement of glClientActiveTexture.

This functions caches the next active texture unit and asserts on the result before returning.

NVSG_API void GLClipPlane | ( | GLenum | plane,
 |  | const GLdouble * | equation
 | ) | [friend]

Replacement of glClipPlane.

This function asserts on the result before returning.

NVSG_API void GLColor3b | ( | GLbyte | red,
 |  | GLbyte | green,
 |  | GLbyte | blue
 | ) | [friend]

Replacement of glColor3b.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3bv ( const GLbyte * v ) [friend]

Replacement of glColor3bv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3d | ( | GLdouble | red,
 |  | GLdouble | green,
 |  | GLdouble | blue
 | ) | [friend]

Replacement of glColor3d.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3dv ( const GLdouble * v ) [friend]

Replacement of glColor3dv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3f | ( | GLfloat | red,
 |  | GLfloat | green,
 |  | GLfloat | blue
 | ) | [friend]

Replacement of glColor3f.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3fv ( const GLfloat * v ) [friend]

Replacement of glColor3fv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3h | ( | GLhalf | red,
 |  | GLhalf | green,
 |  | GLhalf | blue
 | ) | [friend]

Replacement of glColor3hNV.

This function asserts on the result before returning.

NVSG_API void GLColor3hv ( const GLhalf * v ) [friend]

Replacement of glColor3hv.

This function asserts on the result before returning.

NVSG_API void GLColor3i | ( | GLint | red,
 |  | GLint | green,
 |  | GLint | blue
 | ) | [friend]

Replacement of glColor3i.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3iv ( const GLint * v ) [friend]

Replacement of glColor3iv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3s | ( | GLshort | red,
 |  | GLshort | green,
 |  | GLshort | blue
 | ) | [friend]

Replacement of glColor3s.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3sv ( const GLshort * v ) [friend]

Replacement of glColor3sv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3ub | ( | GLubyte | red,
 |  | GLubyte | green,
 |  | GLubyte | blue
 | ) | [friend]

Replacement of glColor3ub.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3ubv ( const GLubyte * v ) [friend]

Replacement of glColor3ubv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3ui | ( | GLuint | red,
 |  | GLuint | green,
 |  | GLuint | blue
 | ) | [friend]

Replacement of glColor3ui.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3uiv ( const GLuint * v ) [friend]

Replacement of glColor3uiv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3us | ( | GLushort | red,
 |  | GLushort | green,
 |  | GLushort | blue
 | ) | [friend]

Replacement of glColor3us.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor3usv ( const GLushort * v ) [friend]

Replacement of glColor3usv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4b | ( | GLbyte | red,
 |  | GLbyte | green,
 |  | GLbyte | blue,
 |  | GLbyte | alpha
 | ) | [friend]

Replacement of glColor4b.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4bv ( const GLbyte * v ) [friend]

Replacement of glColor4bv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4d | ( | GLdouble | red,
 |  | GLdouble | green,
 |  | GLdouble | blue,
 |  | GLdouble | alpha
 | ) | [friend]

Replacement of glColor4d.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4dv ( const GLdouble * v ) [friend]

Replacement of glColor4dv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4f | ( | GLfloat | red,
 |  | GLfloat | green,
 |  | GLfloat | blue,
 |  | GLfloat | alpha
 | ) | [friend]

Replacement of glColor4f.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4fv ( const GLfloat * v ) [friend]

Replacement of glColor4fv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4h | ( | GLhalf | red,
 |  | GLhalf | green,
 |  | GLhalf | blue,
 |  | GLhalf | alpha
 | ) | [friend]

Replacement of glColor4hNV.

This function asserts on the result before returning.

NVSG_API void GLColor4hv ( const GLhalf * v ) [friend]

Replacement of glColor4hv.

This function asserts on the result before returning.

NVSG_API void GLColor4i | ( | GLint | red,
 |  | GLint | green,
 |  | GLint | blue,
 |  | GLint | alpha
 | ) | [friend]

Replacement of glColor4i.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4iv ( const GLint * v ) [friend]

Replacement of glColor4iv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4s | ( | GLshort | red,
 |  | GLshort | green,
 |  | GLshort | blue,
 |  | GLshort | alpha
 | ) | [friend]

Replacement of glColor4s.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4sv ( const GLshort * v ) [friend]

Replacement of glColor4sv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4ub | ( | GLubyte | red,
 |  | GLubyte | green,
 |  | GLubyte | blue,
 |  | GLubyte | alpha
 | ) | [friend]

Replacement of glColor4ub.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4ubv ( const GLubyte * v ) [friend]

Replacement of glColor4ubv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4ui | ( | GLuint | red,
 |  | GLuint | green,
 |  | GLuint | blue,
 |  | GLuint | alpha
 | ) | [friend]

Replacement of glColor4ui.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4uiv ( const GLuint * v ) [friend]

Replacement of glColor4uiv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4us | ( | GLushort | red,
 |  | GLushort | green,
 |  | GLushort | blue,
 |  | GLushort | alpha
 | ) | [friend]

Replacement of glColor4us.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColor4usv ( const GLushort * v ) [friend]

Replacement of glColor4usv.

This function caches the color values and asserts on the result before returning.

NVSG_API void GLColorMask | ( | GLboolean | red,
 |  | GLboolean | green,
 |  | GLboolean | blue,
 |  | GLboolean | alpha
 | ) | [friend]

Replacement of glColorMask.

This function asserts on the result before returning.

NVSG_API void GLColorMaskIndexed | ( | GLuint | index,
 |  | GLboolean | r,
 |  | GLboolean | g,
 |  | GLboolean | b,
 |  | GLboolean | a
 | ) | [friend]

Replacement of glColorMaskIndexedEXT.

This functions asserts on the result before returning.

NVSG_API void GLColorMaterial | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [friend]

Replacement of glColorMaterial.

This function asserts on the result before returning.

NVSG_API void GLColorPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glColorPointer.

This function caches the color pointer settings and asserts on the result before returning.

NVSG_API void GLColorSubTable | ( | GLenum | target,
 |  | GLsizei | start,
 |  | GLsizei | count,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | data
 | ) | [friend]

Replacement of glColorSubTable.

This function asserts on the result before returning.

NVSG_API void GLColorTable | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | table
 | ) | [friend]

Replacement of glColorTable.

This function asserts on the result before returning.

NVSG_API void GLColorTableParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glColorTableParameterfv.

This function asserts on the result before returning.

NVSG_API void GLColorTableParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glColorTableParameteriv.

This function asserts on the result before returning.

NVSG_API void GLCombinerInput | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | variable,
 |  | GLenum | input,
 |  | GLenum | mapping,
 |  | GLenum | componentUsage
 | ) | [friend]

Replacement of glCombinerInput.

This function asserts on the result before returning.

NVSG_API void GLCombinerOutput | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | abOutput,
 |  | GLenum | cdOutput,
 |  | GLenum | sumOutput,
 |  | GLenum | scale,
 |  | GLenum | bias,
 |  | GLboolean | abDotProduct,
 |  | GLboolean | cdDotProduct,
 |  | GLboolean | muxSum
 | ) | [friend]

Replacement of glCombinerOutput.

This function asserts on the result before returning.

NVSG_API void GLCombinerParameterf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glCombinerParameterf.

This function asserts on the result before returning.

NVSG_API void GLCombinerParameterfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glCombinerParameterfv.

This function asserts on the result before returning.

NVSG_API void GLCombinerParameteri | ( | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glCombinerParameteri.

This function asserts on the result before returning.

NVSG_API void GLCombinerParameteriv | ( | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glCombinerParameteriv.

This function asserts on the result before returning.

NVSG_API void GLCombinerStageParameterfv | ( | GLenum | stage,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glCombinerStageParameterfv.

This function asserts on the result before returning.

NVSG_API void GLCompileShader ( GLuint shader ) [friend]

Replacement of glCompileShader.

This function asserts on the result before returning.

NVSG_API void GLCompressedTexImage1D | ( | GLenum | target,
 |  | int | level,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | int | border,
 |  | GLsizei | imageSize,
 |  | const void * | data
 | ) | [friend]

Replacement of glCompressedTexImage1D.

This function hides the extension character of glCompressedTexImage1D, updates the active texture, and asserts on the result before returning.

NVSG_API void GLCompressedTexImage2D | ( | GLenum | target,
 |  | int | level,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | int | border,
 |  | GLsizei | imageSize,
 |  | const void * | data
 | ) | [friend]

Replacement of glCompressedTexImage2D.

This function hides the extension character of glCompressedTexImage2D, updates the active texture, and asserts on the result before returning.

NVSG_API void GLCompressedTexImage3D | ( | GLenum | target,
 |  | int | level,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLsizei | depth,
 |  | int | border,
 |  | GLsizei | imageSize,
 |  | const void * | data
 | ) | [friend]

Replacement of glCompressedTexImage3D.

This function hides the extension character of glCompressedTexImage3D, updates the active texture, and asserts on the result before returning.

NVSG_API void GLCompressedTexSubImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLsizei | imageSize,
 |  | const GLvoid * | data
 | ) | [friend]

Replacement of glCompressedTexSubImage1D.

This updates the active texture and asserts on the result before returning.

NVSG_API void GLCompressedTexSubImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLsizei | imageSize,
 |  | const GLvoid * | data
 | ) | [friend]

Replacement of glCompressedTexSubImage2D.

This updates the active texture and asserts on the result before returning.

NVSG_API void GLCompressedTexSubImage3D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLint | zoffset,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLsizei | depth,
 |  | GLenum | format,
 |  | GLsizei | imageSize,
 |  | const GLvoid * | data
 | ) | [friend]

Replacement of glCompressedTexSubImage3D.

This updates the active texture and asserts on the result before returning.

NVSG_API void GLConvolutionFilter1D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | image
 | ) | [friend]

Replacement of glConvolutionFilter1D.

This function asserts on the result before returning.

NVSG_API void GLConvolutionFilter2D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | image
 | ) | [friend]

Replacement of glConvolutionFilter2D.

This function asserts on the result before returning.

NVSG_API void GLConvolutionParameterf | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat | params
 | ) | [friend]

Replacement of glConvolutionParameterf.

This function asserts on the result before returning.

NVSG_API void GLConvolutionParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glConvolutionParameterfv.

This function asserts on the result before returning.

NVSG_API void GLConvolutionParameteri | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint | params
 | ) | [friend]

Replacement of glConvolutionParameteri.

This function asserts on the result before returning.

NVSG_API void GLConvolutionParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glConvolutionParameteriv.

This function asserts on the result before returning.

NVSG_API void GLCopyColorSubTable | ( | GLenum | target,
 |  | GLsizei | start,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width
 | ) | [friend]

Replacement of glCopyColorSubTable.

This function asserts on the result before returning.

NVSG_API void GLCopyColorTable | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width
 | ) | [friend]

Replacement of glCopyColorTable.

This function asserts on the result before returning.

NVSG_API void GLCopyConvolutionFilter1D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width
 | ) | [friend]

Replacement of glCopyConvolutionFilter1D.

This function asserts on the result before returning.

NVSG_API void GLCopyConvolutionFilter2D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glCopyConvolutionFilter2D.

This function asserts on the result before returning.

NVSG_API void GLCopyPixels | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | type
 | ) | [friend]

Replacement of glCopyPixels.

This function asserts on the result before returning.

NVSG_API void GLCopyTexImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | internalFormat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLint | border
 | ) | [friend]

Replacement of glCopyTexImage1D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLCopyTexImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | internalFormat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLint | border
 | ) | [friend]

Replacement of glCopyTexImage2D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLCopyTexSubImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width
 | ) | [friend]

Replacement of glCopyTexSubImage1D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLCopyTexSubImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glCopyTexSubImage2D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLCopyTexSubImage3D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLint | zoffset,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glCopyTexSubImage2D.

This function updates the active texture and asserts on the result before returning.

NVSG_API GLuint GLCreateProgram ( ) [friend]

Replacement of glCreateProgram.

This function asserts on the result before returning.

NVSG_API GLhandleARB GLCreateProgramObject ( ) [friend]

Replacement of glCreateProgramObjectARB.

This function asserts on the result before returning.

NVSG_API GLuint GLCreateShader ( GLenum type ) [friend]

Replacement of glCreateShader.

This function asserts on the result before returning.

NVSG_API GLhandleARB GLCreateShaderObject ( GLenum shaderType ) [friend]

Replacement of glCreateShaderObjectARB.

This function asserts on the result before returning.

NVSG_API void GLCullFace ( GLenum mode ) [friend]

Replacement of glCullFace.

This function caches the cull face setting and asserts on the result before returning.

NVSG_API void GLCullFaceLock ( GLenum mode ) [friend]

Helper function to set the cull face mode and lock it.

Parameters:
mode The cull face mode to set and lock.
Remarks:
This function sets the cull face mode and locks this state. Any subsequent calls to GLCullFace will not change that value, until the next call to GLCullFaceUnlock.
See also:
GLCullFace, GLCullFaceUnlock

NVSG_API void GLCullFaceUnlock ( GLenum mode ) [friend]

Helper function to unlock the cull face and set it.

Parameters:
mode The cull face mode to set, after unlocking.
Remarks:
This function unlocks the cull face mode and sets it to mode. After a call to GLCullFaceLock, this function is needed to unlock the cull face mode again.
See also:
GLCullFace, GLCullFaceLock

NVSG_API void GLDeleteArraySets | ( | GLsizei | n,
 |  | const GLuint * | buffers
 | ) | [friend]

Replacement of glDeleteArraySetsARB.

This function asserts on the result before returning.

NVSG_API void GLDeleteBuffers | ( | GLsizei | n,
 |  | const GLuint * | buffers
 | ) | [friend]

Replacement of glDeleteBuffers.

This function updates some caches, and asserts on the result before returning.

NVSG_API void GLDeleteFences | ( | GLsizei | n,
 |  | const GLuint * | fences
 | ) | [friend]

Replacement of glDeleteFencesNV.

NVSG_API void GLDeleteLists | ( | GLuint | list,
 |  | GLsizei | range
 | ) | [friend]

Replacement of glDeleteLists.

This function updates some caches and asserts on the result before returning.

NVSG_API void GLDeleteObject ( GLhandleARB obj ) [friend]

Replacement of glDeleteObjectARB.

This function asserts on the result before returning.

NVSG_API void GLDeleteOcclusionQueries | ( | GLsizei | n,
 |  | const GLuint * | ids
 | ) | [friend]

Replacement of glDeleteOcclusionQueriesNV.

This function updates some caches and asserts on the result before returning.

NVSG_API void GLDeleteProgram ( GLuint program ) [friend]

Replacement of glDeleteProgram.

This function updates some caches and asserts on the result before returning.

NVSG_API void GLDeletePrograms | ( | GLsizei | n,
 |  | const GLuint * | ids
 | ) | [friend]

Replacement of glDeleteProgramsNV.

This function hides the extension character of glDeleteProgramsNV, updates some caches, and asserts on the result before returning.

NVSG_API void GLDeleteQueries | ( | GLsizei | n,
 |  | const GLuint * | ids
 | ) | [friend]

Replacement of glDeleteQueries.

This function updates some caches, and asserts on the result before returning.

NVSG_API void GLDeleteShader ( GLuint shader ) [friend]

Replacement of glDeleteShader.

This function asserts on the result before returning.

NVSG_API void GLDeleteTextures | ( | GLsizei | n,
 |  | const GLuint * | textures
 | ) | [friend]

Replacement of glDeleteTextures.

This function updates some caches and asserts on the result before returning.

NVSG_API void GLDepthBounds | ( | GLclampd | zmin,
 |  | GLclampd | zmax
 | ) | [friend]

Replacement of glDepthBounds.

This function asserts on the result before returning.

NVSG_API void GLDepthBoundsd | ( | GLdouble | zmin,
 |  | GLdouble | zmax
 | ) | [friend]

Replacement of glDepthBoundsd.

This function asserts on the result before returning.

NVSG_API void GLDepthFunc ( GLenum func ) [friend]

Replacement of glDepthFunc.

This function asserts on the result before returning.

NVSG_API void GLDepthMask ( GLboolean flag ) [friend]

Replacement of glDepthMask.

This function asserts on the result before returning.

NVSG_API void GLDepthRange | ( | GLclampd | znear,
 |  | GLclampd | zfar
 | ) | [friend]

Replacement of glDepthRange.

This function asserts on the result before returning.

NVSG_API void GLDepthRanged | ( | GLdouble | zNear,
 |  | GLdouble | zFar
 | ) | [friend]

Replacement of glDepthRandedNV.

This function asserts on the result before returning.

NVSG_API void GLDetachObject | ( | GLhandleARB | containerObj,
 |  | GLhandleARB | attachedObj
 | ) | [friend]

Replacement of glDetachObjectARB.

NVSG_API void GLDetachShader | ( | GLuint | program,
 |  | GLuint | shader
 | ) | [friend]

Replacement of glDetachShader.

NVSG_API void GLDisable ( GLenum cap ) [friend]

Replacement of glDisable.

This function caches on some cap values and asserts on the result before returning.

NVSG_API void GLDisableAlphaTest ( void ) [friend]

Cached version of GLDisable( GL_ALPHA_TEST ).

This function caches the GL_ALPHA_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_ALPHA_TEST) directly.

NVSG_API void GLDisableAutoNormal ( void ) [friend]

Cached version of GLDisable( GL_AUTO_NORMAL ).

This function caches the GL_AUTO_NORMAL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_AUTO_NORMAL) directly.

NVSG_API void GLDisableBlend ( void ) [friend]

Cached version of GLDisable( GL_BLEND ).

This function caches the GL_BLEND state. It is faster to call this method instead of calling GL[Disable|Enable](GL_BLEND) directly.

NVSG_API void GLDisableClientState ( GLenum array ) [friend]

Replacement of glDisableClientState.

This function caches on some cap values and asserts on the result before returning.

NVSG_API void GLDisableClipPlane ( GLenum plane ) [friend]

Cached version of GLDisable( GL_CLIP_PLANEi ).

This function caches the GL_CLIP_PLANEi state. It is faster to call this method instead of calling GL[Disable|Enable](GL_CLIP_PLANEi) directly.

NVSG_API void GLDisableColorArray ( void ) [friend]

Cached version of GLDisableClientState( GL_COLOR_ARRAY ).

This function caches the GL_COLOR_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_COLOR_ARRAY ) directly.

NVSG_API void GLDisableColorLogicOp ( void ) [friend]

Cached version of GLDisable( GL_COLOR_LOGIC_OP ).

This function caches the GL_COLOR_LOGIC_OP state. It is faster to call this method instead of calling GL[Disable|Enable](GL_COLOR_LOGIC_OP) directly.

NVSG_API void GLDisableColorMaterial ( void ) [friend]

Cached version of GLDisable( GL_COLOR_MATERIAL ).

This function caches the GL_COLOR_MATERIAL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_COLOR_MATERIAL) directly.

NVSG_API void GLDisableCullFace ( void ) [friend]

Cached version of GLDisable( GL_CULL_FACE ).

This function is caches the GL_CULL_FACE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_CULL_FACE) directly.

NVSG_API void GLDisableCullFaceLock ( void ) [friend]

Helper function to disable the cull face and lock it.

Remarks:
This function disables face culling and locks it. Any subsequent calls to GLEnableCullFace, GLDisableCullFace, GLEnable(GL_CULL_FACE), or GLDisable(GL_CULL_FACE) will not change that setting, until the next call to GLDisableCullFaceUnlock or GLEnableCullFaceUnlock.
See also:
GLDisableCullFace, GLDisableCullFaceUnlock, GLEnableCullFaceLock

NVSG_API void GLDisableCullFaceUnlock ( void ) [friend]

Helper function to unlock the cull face and set it.

Remarks:
This function unlocks face culling and disables it.
See also:
GLDisableCullFace, GLDisableCullFaceLock, GLEnableCullFaceUnlock

NVSG_API void GLDisableDepthTest ( void ) [friend]

Cached version of GLDisable( GL_DEPTH_TEST ).

This function caches the GL_DEPTH_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_DEPTH_TEST) directly.

NVSG_API void GLDisableFogCoordinateArray ( void ) [friend]

Cached version of GLDisableClientState( GL_FOG_COORDINATE_ARRAY ).

This function caches the GL_FOG_COORDINATE_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_FOG_COORDINATE_ARRAY ) directly.

NVSG_API void GLDisableNormalArray ( void ) [friend]

Cached version of GLDisableClientState( GL_NORMAL_ARRAY ).

This function caches the GL_NORMAL_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_NORMAL_ARRAY ) directly.

NVSG_API void GLDisableDither ( void ) [friend]

Cached version of GLDisable( GL_DITHER ).

This function caches the GL_DITHER state. It is faster to call this method instead of calling GL[Disable|Enable](GL_DITHER) directly.

NVSG_API void GLDisableFog ( void ) [friend]

Cached version of GLDisable( GL_FOG ).

This function caches the GL_DITHER state. It is faster to call this method instead of calling GL[Disable|Enable](GL_FOG) directly.

NVSG_API void GLDisableIndexed | ( | GLenum | target,
 |  | GLuint | index
 | ) | [friend]

Replacement of glDiableIndexed.

This functions asserts on the result before returning.

NVSG_API void GLDisableLight ( GLenum light ) [friend]

Cached version of GLDisable( GL_LIGHTi ).

This function caches the GL_LIGHTi state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LIGHTi) directly.

NVSG_API void GLDisableLighting ( void ) [friend]

Cached version of GLDisable( GL_LIGHTING ).

This function is caches the GL_LIGHTING state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LIGHTING) directly.

NVSG_API void GLDisableLightingLock ( void ) [friend]

Helper function to disable lighting and lock it.

Remarks:
This function disables lighting and locks it. Any subsequent calls to GLEnableLighting, GLDisableLighting, GLEnable(GL_LIGHTING), or GLDisable(GL_LIGHTING) will not change that setting, until the next call to GLDisableLightingUnlock or GLEnableLightingUnlock.
See also:
GLDisableLighting, GLDisableLightingUnlock, GLEnableLightingLock

NVSG_API void GLDisableLightingUnlock ( void ) [friend]

Helper function to unlock the lighting and disable it.

Remarks:
This function unlocks lighting and disables it.
See also:
GLDisableLighting, GLDisableLightingLock, GLEnableLightingUnlock

NVSG_API void GLDisableLineSmooth ( void ) [friend]

Cached version of GLDisable( GL_LINE_SMOOTH ).

This function is caches the GL_LINE_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LINE_SMOOTH) directly.

NVSG_API void GLDisableLineStipple ( void ) [friend]

Cached version of GLDisable( GL_LINE_STIPPLE ).

This function is caches the GL_LINE_STIPPLE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LINE_STIPPLE) directly.

NVSG_API void GLDisableLogicOp ( void ) [friend]

Cached version of GLDisable( GL_LOGIC_OP ).

This function caches the GL_LOGIC_OP state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LOGIC_OP) directly.

NVSG_API void GLDisableNormalize ( void ) [friend]

Cached version of GLDisable( GL_NORMALIZE ).

This function is caches the GL_NORMALIZE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_NORMALIZE) directly.

NVSG_API void GLDisablePointSmooth ( void ) [friend]

Cached version of GLDisable( GL_POINT_SMOOTH ).

This function is caches the GL_POINT_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POINT_SMOOTH) directly.

NVSG_API void GLDisablePolygonOffsetFill ( void ) [friend]

Cached version of GLDisable( GL_POLYGON_OFFSET_FILL ).

This function is caches the GL_POLYGON_OFFSET_FILL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_FILL) directly.

NVSG_API void GLDisablePolygonOffsetLine ( void ) [friend]

Cached version of GLDisable( GL_POLYGON_OFFSET_LINE ).

This function is caches the GL_POLYGON_OFFSET_LINE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_LINE) directly.

NVSG_API void GLDisablePolygonOffsetPoint ( void ) [friend]

Cached version of GLDisable( GL_POLYGON_OFFSET_POINT ).

This function is caches the GL_POLYGON_OFFSET_POINT state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_POINT) directly.

NVSG_API void GLDisablePolygonSmooth ( void ) [friend]

Cached version of GLDisable( GL_POLYGON_SMOOTH ).

This function caches the GL_POLYGON_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_SMOOTH) directly.

NVSG_API void GLDisablePolygonStipple ( void ) [friend]

Cached version of GLDisable( GL_POLYGON_STIPPLE ).

This function is caches the GL_POLYGON_STIPPLE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_STIPPLE) directly.

NVSG_API void GLDisableScissorTest ( void ) [friend]

Cached version of GLDisable( GL_SCISSOR_TEST ).

This function caches the GL_SCISSOR_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_SCISSOR_TEST) directly.

NVSG_API void GLDisableSecondaryColorArray ( void ) [friend]

Cached version of GLDisableClientState( GL_SECONDARY_COLOR_ARRAY ).

This function caches the GL_SECONDARY_COLOR_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_SECONDARY_COLOR_ARRAY ) directly.

NVSG_API void GLDisableStencilTest ( void ) [friend]

Cached version of GLDisable( GL_STENCIL_TEST ).

This function caches the GL_STENCIL_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_STENCIL_TEST) directly.

NVSG_API void GLDisableTexture ( GLenum target ) [friend]

This function caches the texture target type per texture unit. It is faster to call this method instead of calling GL[Disable|Enable]( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ) directly.

NVSG_API void GLDisableTextureCoordArray ( void ) [friend]

Cached version of GLDisableClientState( GL_TEXTURE_COORD_ARRAY ).

This function caches the GL_TEXTURE_COORD_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_TEXTURE_COORD_ARRAY ) directly.

NVSG_API void GLDisableTextureGen ( GLenum target ) [friend]

Cached version of GLDisable( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

This function caches the texture generation type per texture unit. It is faster to call this method instead of calling GL[Disable|Enable]( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ) directly.

NVSG_API void GLDisableVertexArray ( void ) [friend]

Cached version of GLDisableClientState( GL_VERTEX_ARRAY ).

This function caches the GL_VERTEX_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_VERTEX_ARRAY ) directly.

NVSG_API void GLDisableVertexAttribArray ( GLuint index ) [friend]

Replacement of glDisableVertexAttribArray.

NVSG_API void GLDrawArrays | ( | GLenum | mode,
 |  | GLint | first,
 |  | GLsizei | count
 | ) | [friend]

Replacement of glDrawArrays.

This function asserts on the result before returning.

NVSG_API void GLDrawArraysInstanced | ( | GLenum | mode,
 |  | GLint | start,
 |  | GLsizei | count,
 |  | GLsizei | primcount
 | ) | [friend]

Replacement of glDrawArraysInstancedEXT.

This function asserts on the result before returning.

NVSG_API void GLDrawBuffer ( GLenum mode ) [friend]

Replacement of glDrawBuffer.

This function asserts on the result before returning.

NVSG_API void GLDrawBuffers | ( | GLsizei | n,
 |  | const GLenum * | bufs
 | ) | [friend]

Replacement of glDrawBuffersARB.

This function asserts on the result before returning.

NVSG_API void GLDrawElements | ( | GLenum | mode,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices
 | ) | [friend]

Replacement of glDrawElements.

This function asserts on the result before returning.

NVSG_API void GLDrawElementsInstanced | ( | GLenum | mode,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices,
 |  | GLsizei | primcount
 | ) | [friend]

Replacement of glDrawElementsInstancedEXT.

This function asserts on the result before returning.

NVSG_API void GLDrawPixels | ( | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [friend]

Replacement of glDrawPixels.

This function asserts on the result before returning.

NVSG_API void GLDrawRangeElements | ( | GLenum | mode,
 |  | GLuint | start,
 |  | GLuint | end,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices
 | ) | [friend]

Replacement of glDrawRangeElements.

This function asserts on the result before returning.

NVSG_API void GLEdgeFlagPointer | ( | GLsizei | stride,
 |  | const GLboolean * | pointer
 | ) | [friend]

Replacement of glEdgeFlagPointer.

This function asserts on the result before returning.

NVSG_API void GLEdgeFlag ( GLboolean flag ) [friend]

Replacement of glEdgeFlag.

This function asserts on the result before returning.

NVSG_API void GLEdgeFlagv ( const GLboolean * flag ) [friend]

Replacement of glEdgeFlagv.

This function asserts on the result before returning.

NVSG_API void GLEnable ( GLenum cap ) [friend]

Replacement of glEnable.

This function caches on some cap values and asserts on the result before returning.

NVSG_API void GLEnableAlphaTest ( void ) [friend]

Cached version of GLEnable( GL_ALPHA_TEST ).

This function caches the GL_ALPHA_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_ALPHA_TEST) directly.

NVSG_API void GLEnableAutoNormal ( void ) [friend]

Cached version of GLEnable( GL_AUTO_NORMAL ).

This function caches the GL_AUTO_NORMAL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_AUTO_NORMAL) directly.

NVSG_API void GLEnableBlend ( void ) [friend]

Cached version of GLEnable( GL_BLEND ).

This function caches the GL_BLEND state. It is faster to call this method instead of calling GL[Disable|Enable](GL_BLEND) directly.

NVSG_API void GLEnableClientState ( GLenum array ) [friend]

Replacement of glEnableClientState.

This function caches on some cap values and asserts on the result before returning.

NVSG_API void GLEnableClipPlane ( GLenum plane ) [friend]

Cached version of GLEnable( GL_CLIP_PLANEi ).

This function caches the GL_CLIP_PLANEi state. It is faster to call this method instead of calling GL[Disable|Enable](GL_CLIP_PLANEi) directly.

NVSG_API void GLEnableColorArray ( void ) [friend]

Cached version of GLEnableClientState( GL_COLOR_ARRAY ).

This function caches the GL_COLOR_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_COLOR_ARRAY ) directly.

NVSG_API void GLEnableColorLogicOp ( void ) [friend]

Cached version of GLEnable( GL_COLOR_LOGIC_OP ).

This function caches the GL_COLOR_LOGIC_OP state. It is faster to call this method instead of calling GL[Disable|Enable](GL_COLOR_LOGIC_OP) directly.

NVSG_API void GLEnableColorMaterial ( void ) [friend]

Cached version of GLEnable( GL_COLOR_MATERIAL ).

This function caches the GL_COLOR_MATERIAL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_COLOR_MATERIAL) directly.

NVSG_API void GLEnableCullFace ( void ) [friend]

Cached version of GLEnable( GL_CULL_FACE ).

This function caches the GL_CULL_FACE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_CULL_FACE) directly.

NVSG_API void GLEnableCullFaceLock ( void ) [friend]

Helper function to enable face culling and lock it.

Remarks:
This function enables face culling and locks it. Any subsequent calls to GLEnableCullFace, GLDisableCullFace, GLEnable(GL_CULL_FACE), or GLDisable(GL_CULL_FACE) will not change that setting, until the next call to GLEnableCullFaceUnlock or GLDisableCullFaceUnlock.
See also:
GLEnableCullFace, GLDisableCullFaceUnlock, GLEnableCullFaceUnlock

NVSG_API void GLEnableCullFaceUnlock ( void ) [friend]

Helper function to unlock the face culling and enable it.

Remarks:
This function unlocks face culling and enables it.
See also:
GLEnableCullFace, GLEnableCullFaceLock, GLDisableCullFaceUnlock

NVSG_API void GLEnableDepthTest ( void ) [friend]

Cached version of GLEnable( GL_DEPTH_TEST ).

This function caches the GL_DEPTH_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_DEPTH_TEST) directly.

NVSG_API void GLEnableFogCoordinateArray ( void ) [friend]

Cached version of GLEnableClientState( GL_FOG_COORDINATE_ARRAY ).

This function caches the GL_FOG_COORDINATE_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_FOG_COORDINATE_ARRAY ) directly.

NVSG_API void GLEnableDither ( void ) [friend]

Cached version of GLEnable( GL_DITHER ).

This function caches the GL_DITHER state. It is faster to call this method instead of calling GL[Disable|Enable](GL_DITHER) directly.

NVSG_API void GLEnableFog ( void ) [friend]

Cached version of GLEnable( GL_FOG ).

This function caches the GL_DITHER state. It is faster to call this method instead of calling GL[Disable|Enable](GL_FOG) directly.

NVSG_API void GLEnableIndexed | ( | GLenum | target,
 |  | GLuint | index
 | ) | [friend]

Replacement of glEnabledIndexed.

This functions asserts on the result before returning.

NVSG_API void GLEnableLight ( GLenum light ) [friend]

Cached version of GLEnable( GL_LIGHTi ).

This function caches the GL_LIGHTi state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LIGHTi) directly.

NVSG_API void GLEnableLighting ( void ) [friend]

Cached version of GLEnable( GL_LIGHTING ).

This function caches the GL_LIGHTING state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LIGHTING) directly.

NVSG_API void GLEnableLineSmooth ( void ) [friend]

Cached version of GLEnable( GL_LINE_SMOOTH ).

This function caches the GL_LINE_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LINE_SMOOTH) directly.

NVSG_API void GLEnableLineStipple ( void ) [friend]

Cached version of GLEnable( GL_LINE_STIPPLE ).

This function caches the GL_LINE_STIPPLE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LINE_STIPPLE) directly.

NVSG_API void GLEnableLogicOp ( void ) [friend]

Cached version of GLEnable( GL_LOGIC_OP ).

This function caches the GL_LOGIC_OP state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LOGIC_OP) directly.

NVSG_API void GLEnableNormalArray ( void ) [friend]

Cached version of GLEnableClientState( GL_NORMAL_ARRAY ).

This function caches the GL_NORMAL_ARRAY client state. PIt is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_NORMAL_ARRAY ) directly.

NVSG_API void GLEnableNormalize ( void ) [friend]

Cached version of GLEnable( GL_NORMALIZE ).

This function caches the GL_NORMALIZE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_NORMALIZE) directly.

NVSG_API void GLEnablePointSmooth ( void ) [friend]

Cached version of GLEnable( GL_POINT_SMOOTH ).

This function caches the GL_POINT_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POINT_SMOOTH) directly.

NVSG_API void GLEnablePolygonOffsetFill ( void ) [friend]

Cached version of GLEnable( GL_POLYGON_OFFSET_FILL ).

This function caches the GL_POLYGON_OFFSET_FILL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_FILL) directly.

NVSG_API void GLEnablePolygonOffsetLine ( void ) [friend]

Cached version of GLEnable( GL_POLYGON_OFFSET_LINE ).

This function caches the GL_POLYGON_OFFSET_LINE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_LINE) directly.

NVSG_API void GLEnablePolygonOffsetPoint ( void ) [friend]

Cached version of GLEnable( GL_POLYGON_OFFSET_POINT ).

This function caches the GL_POLYGON_OFFSET_POINT state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_POINT) directly.

NVSG_API void GLEnablePolygonSmooth ( void ) [friend]

Cached version of GLEnable( GL_POLYGON_SMOOTH ).

This function caches the GL_POLYGON_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_SMOOTH) directly.

NVSG_API void GLEnablePolygonStipple ( void ) [friend]

Cached version of GLEnable( GL_POLYGON_STIPPLE ).

This function caches the GL_POLYGON_STIPPLE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_STIPPLE) directly.

NVSG_API void GLEnableScissorTest ( void ) [friend]

Cached version of GLEnable( GL_SCISSOR_TEST ).

This function caches the GL_SCISSOR_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_SCISSOR_TEST) directly.

NVSG_API void GLEnableStencilTest ( void ) [friend]

Cached version of GLEnable( GL_STENCIL_TEST ).

This function caches the GL_STENCIL_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_STENCIL_TEST) directly.

NVSG_API void GLEnableSecondaryColorArray ( void ) [friend]

Cached version of GLEnableClientState( GL_SECONDARY_COLOR_ARRAY ).

This function caches the GL_SECONDARY_COLOR_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_SECONDARY_COLOR_ARRAY ) directly.

NVSG_API void GLEnableTexture ( GLenum target ) [friend]

This function caches the texture target type per texture unit. It is faster to call this method instead of calling GL[Disable|Enable]( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ) directly.

NVSG_API void GLEnableTextureCoordArray ( void ) [friend]

Cached version of GLEnableClientState( GL_TEXTURE_COORD_ARRAY ).

This function caches the GL_TEXTURE_COORD_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_TEXTURE_COORD_ARRAY ) directly.

NVSG_API void GLEnableTextureGen ( GLenum target ) [friend]

Cached version of GLEnable( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

This function caches the texture generation type per texture unit. It is faster to call this method instead of calling GL[Disable|Enable]( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ) directly.

NVSG_API void GLEnableVertexArray ( void ) [friend]

Cached version of GLEnableClientState( GL_VERTEX_ARRAY ).

This function caches the GL_VERTEX_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_VERTEX_ARRAY ) directly.

NVSG_API void GLEnableVertexAttribArray ( GLuint index ) [friend]

Replacement of glEnableVertexAttribArray.

NVSG_API void GLEnd ( void ) [friend]

Replacement of glEnd.

This function asserts on the result before returning.

NVSG_API void GLEndList ( void ) [friend]

Replacement of glEndList.

This function asserts on the result before returning.

NVSG_API void GLEndOcclusionQuery ( void ) [friend]

Replacement of glEndOcclusionQueryNV.

This function asserts on the result before returning.

NVSG_API void GLEndQuery ( GLenum target ) [friend]

Replacement of glEndQuery.

This function asserts on the result before returning.

NVSG_API void GLEndTransformFeedback ( ) [friend]

Replacement of glEndTransformFeedbackNV.

This function asserts on the result before returning.

NVSG_API void GLEvalCoord1d ( GLdouble u ) [friend]

Replacement of glEvalCoord1d.

This function asserts on the result before returning.

NVSG_API void GLEvalCoord1f ( GLfloat u ) [friend]

Replacement of glEvalCoord1f.

This function asserts on the result before returning.

NVSG_API void GLEvalCoord2d | ( | GLdouble | u,
 |  | GLdouble | v
 | ) | [friend]

Replacement of glEvalCoord2d.

This function asserts on the result before returning.

NVSG_API void GLEvalCoord2f | ( | GLfloat | u,
 |  | GLfloat | v
 | ) | [friend]

Replacement of glEvalCoord2f.

This function asserts on the result before returning.

NVSG_API void GLEvalMesh1 | ( | GLenum | mode,
 |  | GLint | i1,
 |  | GLint | i2
 | ) | [friend]

Replacement of glEvalMesh1.

This function asserts on the result before returning.

NVSG_API void GLEvalMesh2 | ( | GLenum | mode,
 |  | GLint | i1,
 |  | GLint | i2,
 |  | GLint | j1,
 |  | GLint | j2
 | ) | [friend]

Replacement of glEvalMesh2.

This function asserts on the result before returning.

NVSG_API void GLEvalPoint1 ( GLint i ) [friend]

Replacement of glEvalPoint1.

This function asserts on the result before returning.

NVSG_API void GLEvalPoint2 | ( | GLint | i,
 |  | GLint | j
 | ) | [friend]

Replacement of glEvalPoint2.

This function asserts on the result before returning.

NVSG_API void GLExecuteProgram | ( | GLenum | target,
 |  | GLuint | id,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glExecuteProgramNV.

This function asserts on the result before returning.

NVSG_API void GLFeedbackBuffer | ( | GLsizei | size,
 |  | GLenum | type,
 |  | GLfloat * | buffer
 | ) | [friend]

Replacement of glFeedbackBuffer.

This function asserts on the result before returning.

NVSG_API void GLFinalCombinerInput | ( | GLenum | variable,
 |  | GLenum | input,
 |  | GLenum | mapping,
 |  | GLenum | componentUsage
 | ) | [friend]

Replacement of glFinalCombinerInput.

This function asserts on the result before returning.

NVSG_API void GLFinish ( void ) [friend]

Replacement of glFinish.

This function asserts on the result before returning.

NVSG_API void GLFinishFence ( GLuint fence ) [friend]

Replacement of glFinishFenceNV.

NVSG_API void GLFlush ( void ) [friend]

Replacement of glFlush.

This function asserts on the result before returning.

NVSG_API void GLFlushPixelDataRange ( GLenum target ) [friend]

Replacement of glFlushPixelDataRangeNV.

This functions asserts on the result before returning.

NVSG_API void GLFlushVertexArrayRange ( ) [friend]

Replacement of glFlushVertexArrayRange.

This functions asserts on the result before returning.

NVSG_API void GLFogColor ( const GLfloat * color ) [friend]

Cached version of GLFog[fv|iv]( GL_FOG_COLOR, params ).

This function caches the GL_FOG_COLOR value. It is faster to call this method instead of GLFog[fv|iv]( GL_FOG_COLOR, params ) directly.

NVSG_API void GLFogCoordd ( GLdouble fog ) [friend]

Replacement of glFogCoordd.

This function asserts on the result before returning.

NVSG_API void GLFogCoorddv ( const GLdouble * fog ) [friend]

Replacement of glFogCoorddv.

This function asserts on the result before returning.

NVSG_API void GLFogCoordf ( GLfloat fog ) [friend]

Replacement of glFogCoordf.

This function asserts on the result before returning.

NVSG_API void GLFogCoordfv ( const GLfloat * fog ) [friend]

Replacement of glFogCoordfv.

This function asserts on the result before returning.

NVSG_API void GLFogCoordh ( GLhalf fog ) [friend]

Replacement of glFogCoordh.

This function asserts on the result before returning.

NVSG_API void GLFogCoordhv ( const GLhalf * fog ) [friend]

Replacement of glFogCoordhv.

This function asserts on the result before returning.

NVSG_API void GLFogCoordPointer | ( | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glFogCoordPointer.

This function caches the fog coordinate pointer setting and asserts on the result before returning.

NVSG_API void GLFogDensity ( GLfloat density ) [friend]

Cached version of GLFog[f|fv|i|iv]( GL_FOG_DENSITY, param[s] ).

This function caches the GL_FOG_DENSITY value. It is faster to call this method instead of GLFog[f|fv|i|iv]( GL_FOG_MODE, param[s] ) directly.

NVSG_API void GLFogEnd ( GLfloat end ) [friend]

Cached version of GLFog[f|fv|i|iv]( GL_FOG_END, param[s] ).

This function caches the GL_FOG_END value. It is faster to call this method instead of GLFog[f|fv|i|iv]( GL_FOG_END, param[s] ) directly.

NVSG_API void GLFogf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glFogf.

This function asserts on the result before returning.

NVSG_API void GLFogfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glFogfv.

This function asserts on the result before returning.

NVSG_API void GLFogi | ( | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glFogi.

This function asserts on the result before returning.

NVSG_API void GLFogiv | ( | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glFogiv.

This function asserts on the result before returning.

NVSG_API void GLFogMode ( GLenum param ) [friend]

Cached version of GLFog[f|fv|i|iv]( GL_FOG_MODE, param[s] ).

This function caches the GL_FOG_MODE value. It is faster to call this method instead of GLFog[f|fv|i|iv]( GL_FOG_MODE, param[s] ) directly.

NVSG_API void GLFogStart ( GLfloat start ) [friend]

Cached version of GLFog[f|fv|i|iv]( GL_FOG_START, param[s] ).

This function caches the GL_FOG_START value. It is faster to call this method instead of GLFog[f|fv|i|iv]( GL_FOG_START, param[s] ) directly.

NVSG_API void GLFrameTerminator ( void ) [friend]

Replacement of glFrameTerminatorGREMEDY.

This function simply does nothing if the extension is not available

NVSG_API void GLFramebufferTexture | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level
 | ) | [friend]

Replacement of glFramebufferTextureEXT.

This function asserts on the result before returning.

NVSG_API void GLFramebufferTextureFace | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLenum | face
 | ) | [friend]

Replacement of glFramebufferTextureFaceEXT.

This function asserts on the result before returning.

NVSG_API void GLFrontFace ( GLenum mode ) [friend]

Replacement of glFrontFace.

This function caches the front face setting and asserts on the result before returning.

NVSG_API void GLFrustum | ( | GLdouble | left,
 |  | GLdouble | right,
 |  | GLdouble | bottom,
 |  | GLdouble | top,
 |  | GLdouble | zNear,
 |  | GLdouble | zFar
 | ) | [friend]

Replacement of glFrustum.

This function asserts on the result before returning.

NVSG_API void GLGenArraySets | ( | GLsizei | n,
 |  | GLuint * | buffers
 | ) | [friend]

Replacement of glGenArraySetsARB.

NVSG_API void GLGenBuffers | ( | GLsizei | n,
 |  | GLuint * | buffers
 | ) | [friend]

Replacement of glGenBuffers.

This function asserts on the result, and updates some caches.

NVSG_API void GLGenFences | ( | GLsizei | n,
 |  | GLuint * | fences
 | ) | [friend]

Replacement of glGenFencesNV.

NVSG_API GLuint GLGenLists ( GLsizei range ) [friend]

Replacement of glGenLists.

This function asserts on the result and updates some caches.

NVSG_API void GLGenOcclusionQueries | ( | GLsizei | n,
 |  | GLuint * | ids
 | ) | [friend]

Replacement of glGenOcclusionQueriesNV.

This function asserts on the result, and updates some caches.

NVSG_API void GLGenPrograms | ( | GLsizei | n,
 |  | GLuint * | ids
 | ) | [friend]

Replacement of glGenProgramsNV.

This function hides the extension character of glGenProgramsNV and asserts on the result, and updates some caches.

NVSG_API void GLGenQueries | ( | GLsizei | n,
 |  | GLuint * | ids
 | ) | [friend]

Replacement of glGenQueries.

This function asserts on the result, and updates some caches.

NVSG_API void GLGenTextures | ( | GLsizei | n,
 |  | GLuint * | textures
 | ) | [friend]

Replacement of glGenTextures.

This function asserts on the result and updates some caches.

NVSG_API void GLGetActiveAttrib | ( | GLuint | program,
 |  | GLuint | index,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLsizei * | size,
 |  | GLenum * | type,
 |  | GLchar * | name
 | ) | [friend]

Replacement of glGetActiveAttrib.

This function asserts on the result before returning.

NVSG_API void GLGetActiveUniform | ( | GLuint | program,
 |  | GLuint | index,
 |  | GLsizei | maxLength,
 |  | GLsizei * | length,
 |  | GLsizei * | size,
 |  | GLenum * | type,
 |  | GLcharARB * | name
 | ) | [friend]

Replacement of glGetActiveUniform.

This function asserts on the result before returning.

NVSG_API void GLGetActiveVarying | ( | GLuint | program,
 |  | GLuint | index,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLsizei * | size,
 |  | GLenum * | type,
 |  | GLchar * | name
 | ) | [friend]

Replacement of glGetActiveVaryingNV.

This function asserts on the result before returning.

NVSG_API void GLGetAttachedObjects | ( | GLhandleARB | containerObj,
 |  | GLsizei | maxCount,
 |  | GLsizei * | count,
 |  | GLhandleARB * | obj
 | ) | [friend]

Replacement of glGetAttachedObjectsARB.

This function asserts on the result before returning.

NVSG_API void GLGetAttachedShaders | ( | GLuint | program,
 |  | GLsizei | maxCount,
 |  | GLsizei * | count,
 |  | GLuint * | shaders
 | ) | [friend]

Replacement of glGetAttachedShaders.

This function asserts on the result before returning.

NVSG_API GLint GLGetAttribLocation | ( | GLuint | program,
 |  | const GLchar * | name
 | ) | [friend]

Replacement of glGetAttribLocation.

This function asserts on the result before returning.

NVSG_API void GLGetBooleanv | ( | GLenum | pname,
 |  | GLboolean * | params
 | ) | [friend]

Replacement of glGetBooleanv.

This function asserts on the result before returning.

NVSG_API void GLGetBooleanIndexedv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLboolean * | data
 | ) | [friend]

Replacement of glGetBooleanIndexedvEXT.

This function asserts on the result before returning.

NVSG_API void GLGetBufferParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetBufferParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetBufferPointerv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLvoid ** | params
 | ) | [friend]

Replacement of glGetBufferPointerv.

This function asserts on the result before returning.

NVSG_API void GLGetBufferSubData | ( | GLenum | target,
 |  | GLintptrARB | offset,
 |  | GLsizeiptrARB | size,
 |  | GLvoid * | data
 | ) | [friend]

Replacement of glGetBufferSubData.

This function asserts on the result before returning.

NVSG_API void GLGetClipPlane | ( | GLenum | plane,
 |  | GLdouble * | equation
 | ) | [friend]

Replacement of glGetClipPlane.

This function asserts on the result before returning.

NVSG_API void GLGetColorTable | ( | GLenum | target,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | table
 | ) | [friend]

Replacement of glGetColorTable.

This function asserts on the result before returning.

NVSG_API void GLGetColorTableParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetColorTableParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetColorTableParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetColorTableParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetCombinerInputParameterfv | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | variable,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetCombinerInputParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetCombinerInputParameteriv | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | variable,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetCombinerInputParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetCombinerOutputParameterfv | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetCombinerOutputParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetCombinerOutputParameteriv | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetCombinerOutputParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetCombinerStageParameterfv | ( | GLenum | stage,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetCombinerStageParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetCompressedTexImage | ( | GLenum | target,
 |  | GLint | lod,
 |  | GLvoid * | img
 | ) | [friend]

Replacement of glGetCompressedTexImage.

This function asserts on the result before returning.

NVSG_API void GLGetConvolutionFilter | ( | GLenum | target,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | image
 | ) | [friend]

Replacement of glGetConvolutionFilter.

This function asserts on the result before returning.

NVSG_API void GLGetConvolutionParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetConvolutionParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetConvolutionParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetConvolutionParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetDoublev | ( | GLenum | pname,
 |  | GLdouble * | params
 | ) | [friend]

Replacement of glGetDoublev.

This function asserts on the result before returning.

NVSG_API void GLGetFenceiv | ( | GLuint | fence,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetFenceivNV.

This function asserts on the result before returning.

NVSG_API void GLGetFinalCombinerInputParameterfv | ( | GLenum | variable,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetFinalCombinerInputParamterfv.

This function asserts on the result before returning.

NVSG_API void GLGetFinalCombinerInputParameteriv | ( | GLenum | variable,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetFinalCombinerInputParamteriv.

This function asserts on the result before returning.

NVSG_API void GLGetFloatv | ( | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetFloatv.

This function asserts on the result before returning.

NVSG_API GLint GLGetFragDataLocation | ( | GLuint | program,
 |  | const GLchar * | name
 | ) | [friend]

Replacement of glGetFragDataLocationEXT.

This function asserts on the result before returning.

NVSG_API GLhandleARB GLGetHandle ( GLenum pname ) [friend]

Replacement of glGetHandleARB.

This function asserts on the result before returning.

NVSG_API void GLGetHistogram | ( | GLenum | target,
 |  | GLboolean | reset,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | values
 | ) | [friend]

Replacement of glGetHistogram.

This function asserts on the result before returning.

NVSG_API void GLGetHistogramParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetHistogramParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetHistogramParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetHistogramParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetInfoLog | ( | GLhandleARB | obj,
 |  | GLsizei | maxLength,
 |  | GLsizei * | length,
 |  | GLcharARB * | infoLog
 | ) | [friend]

Replacement of glGetInfoLogARB.

This function asserts on the result before returning.

NVSG_API void GLGetIntegerv | ( | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetIntegerv.

This function asserts on the result before returning.

NVSG_API void GLGetIntegerIndexedv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint * | data
 | ) | [friend]

Replacement of glGetIntegerIndexedvEXT.

This function asserts on the result before returning.

NVSG_API void GLGetLightfv | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetLightfv.

This function asserts on the result before returning.

NVSG_API void GLGetLightiv | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetLightiv.

This function asserts on the result before returning.

NVSG_API void GLGetMapdv | ( | GLenum | target,
 |  | GLenum | query,
 |  | GLdouble * | v
 | ) | [friend]

Replacement of glGetMapdv.

This function asserts on the result before returning.

NVSG_API void GLGetMapfv | ( | GLenum | target,
 |  | GLenum | query,
 |  | GLfloat * | v
 | ) | [friend]

Replacement of glGetMapfv.

This function asserts on the result before returning.

NVSG_API void GLGetMapiv | ( | GLenum | target,
 |  | GLenum | query,
 |  | GLint * | v
 | ) | [friend]

Replacement of glGetMapiv.

This function asserts on the result before returning.

NVSG_API void GLGetMaterialfv | ( | GLenum | face,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetMaterialfv.

This function asserts on the result before returning.

NVSG_API void GLGetMaterialiv | ( | GLenum | face,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetMaterialiv.

This function asserts on the result before returning.

NVSG_API GLint GLGetMaxTexCoords ( void ) [friend]

Get the maximal number of texture coordinate slots.

NVSG_API GLint GLGetMaxTexUnits ( void ) [friend]

Get the maximal number of texture units.

NVSG_API GLint GLGetMaxTexImageUnits ( void ) [friend]

Get the maximal number of texture image units.

NVSG_API void GLGetMinmax | ( | GLenum | target,
 |  | GLboolean | reset,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | values
 | ) | [friend]

Replacement of glGetMinmax.

This function asserts on the result before returning.

NVSG_API void GLGetMinmaxParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetMinmaxParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetMinmaxParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetMinmaxParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetObjectParameterfv | ( | GLhandleARB | obj,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetObjectParameterfvARB.

This function asserts on the result before returning.

NVSG_API void GLGetObjectParameteriv | ( | GLhandleARB | obj,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetObjectParameterivARB.

This function asserts on the result before returning.

NVSG_API void GLGetOcclusionQueryiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetOcclusionQueryivNV.

This function asserts on the result before returning.

NVSG_API void GLGetOcclusionQueryuiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetOcclusionQueryuivNV.

This function asserts on the result before returning.

NVSG_API void GLGetPixelMapfv | ( | GLenum | map,
 |  | GLfloat * | values
 | ) | [friend]

Replacement of glGetPixelMapfv.

This function asserts on the result before returning.

NVSG_API void GLGetPixelMapuiv | ( | GLenum | map,
 |  | GLuint * | values
 | ) | [friend]

Replacement of glGetPixelMapuiv.

This function asserts on the result before returning.

NVSG_API void GLGetPixelMapusv | ( | GLenum | map,
 |  | GLushort * | values
 | ) | [friend]

Replacement of glGetPixelMapusv.

This function asserts on the result before returning.

NVSG_API void GLGetPointerv | ( | GLenum | pname,
 |  | GLvoid ** | params
 | ) | [friend]

Replacement of glGetPointerv.

This function asserts on the result before returning.

NVSG_API void GLGetPolygonStipple ( GLubyte * mask ) [friend]

Replacement of glGetPolygonStipple.

This function asserts on the result before returning.

NVSG_API void GLGetProgramEnvParameterdv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble * | params
 | ) | [friend]

Replacement of glGetProgramEnvParameterdvARB.

This function asserts on the result before returning.

NVSG_API void GLGetProgramEnvParameterfv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetProgramEnvParameterfvARB.

This function asserts on the result before returning.

NVSG_API void GLGetProgramiv | ( | GLuint | program,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetProgramiv.

This function asserts on the result before returning.

NVSG_API void GLGetProgramLocalParameterdv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble * | params
 | ) | [friend]

Replacement of glGetProgramLocalParameterdvARB.

This function asserts on the result before returning.

NVSG_API void GLGetProgramLocalParameterfv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetProgramLocalParameterfvARB.

This function asserts on the result before returning.

NVSG_API void GLGetProgramInfoLog | ( | GLuint | program,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLchar * | infoLog
 | ) | [friend]

Replacement of glGetProgramInfoLog.

This function asserts on the result before returning.

NVSG_API void GLGetProgramEnvParameterIiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetProgramEnvParameterIivNV.

This function asserts on the result before returning.

NVSG_API void GLGetProgramEnvParameterIuiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetProgramEnvParameterIuivNV.

This function asserts on the result before returning.

NVSG_API void GLGetProgramLocalParameterIiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetProgramLocalParameterIivNV.

This function asserts on the result before returning.

NVSG_API void GLGetProgramLocalParameterIuiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetProgramLocalParameterIuivNV.

This function asserts on the result before returning.

NVSG_API void GLGetProgramNamedParameterdv | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLdouble * | params
 | ) | [friend]

Replacement of glGetProgramNamedParameterdvNV.

This function asserts on the result before returning.

NVSG_API void GLGetProgramNamedParameterfv | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetProgramNamedParameterfvNV.

This function asserts on the result before returning.

NVSG_API void GLGetProgramParameterdv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLenum | pname,
 |  | GLdouble * | params
 | ) | [friend]

Replacement of glGetProgramParameterdvNV.

This function asserts on the result before returning.

NVSG_API void GLGetProgramParameterfv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetProgramParameterfvNV.

This function asserts on the result before returning.

NVSG_API void GLGetProgramString | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLubyte * | program
 | ) | [friend]

Replacement of glGetProgramStringNV.

This function asserts on the result before returning.

NVSG_API void GLGetQueryiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetQueryiv.

This function asserts on the result before returning.

NVSG_API void GLGetQueryObjecti64v | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLint64EXT * | params
 | ) | [friend]

Replacement of glGetQueryObjecti64vEXT.

This function asserts on the result before returning.

NVSG_API void GLGetQueryObjectiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetQueryObjectiv.

This function asserts on the result before returning.

NVSG_API void GLGetQueryObjectui64v | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint64EXT * | params
 | ) | [friend]

Replacement of glGetQueryObjectui64vEXT.

This function asserts on the result before returning.

NVSG_API void GLGetQueryObjectuiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetQueryObjectuiv.

This function asserts on the result before returning.

NVSG_API void GLGetSeparableFilter | ( | GLenum | target,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | row,
 |  | GLvoid * | column,
 |  | GLvoid * | span
 | ) | [friend]

Replacement of glGetSeparableFilter.

This asserts on the result before returning.

NVSG_API void GLGetShaderiv | ( | GLuint | shader,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetShaderiv.

This asserts on the result before returning.

NVSG_API void GLGetShaderInfoLog | ( | GLuint | shader,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLchar * | infoLog
 | ) | [friend]

Replacement of glGetShaderInfoLog.

This asserts on the result before returning.

NVSG_API void GLGetShaderSource | ( | GLuint | shader,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLcharARB * | source
 | ) | [friend]

Replacement of glGetShaderSource.

This asserts on the result before returning.

NVSG_API const GLubyte* GLGetString ( GLenum name ) [friend]

Replacement of glGetString.

This function asserts on the result before returning.

NVSG_API void GLGetTexEnvfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetTexEnvfv.

This function asserts on the result before returning.

NVSG_API void GLGetTexEnviv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetTexEnviv.

This function asserts on the result before returning.

NVSG_API void GLGetTexGendv | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLdouble * | params
 | ) | [friend]

Replacement of glGetTexGendv.

This function asserts on the result before returning.

NVSG_API void GLGetTexGenfv | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetTexGenfv.

This function asserts on the result before returning.

NVSG_API void GLGetTexGeniv | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetTexGeniv.

This function asserts on the result before returning.

NVSG_API void GLGetTexImage | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | pixels
 | ) | [friend]

Replacement of glGetTexImage.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLGetTexLevelParameterfv | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetTexLevelParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetTexLevelParameteriv | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetTexLevelParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetTexParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetTexParameterfv.

This function asserts on the result before returning.

NVSG_API void GLGetTexParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetTexParameteriv.

This function asserts on the result before returning.

NVSG_API void GLGetTexParameterIiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetTexParameterIivEXT.

This function asserts on the result before returning.

NVSG_API void GLGetTexParameterIuiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetTexParameterIuivEXT.

This function asserts on the result before returning.

NVSG_API void GLGetTrackMatrixiv | ( | GLenum | target,
 |  | GLuint | address,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetTrackMatrixivNV.

This function asserts on the result before returning.

NVSG_API void GLGetTransformFeedbackVarying | ( | GLuint | program,
 |  | GLuint | index,
 |  | GLint * | location
 | ) | [friend]

Replacement of glGetTransformFeedbackVaryingNV.

This function asserts on the result before returning.

NVSG_API void GLGetUniformfv | ( | GLuint | program,
 |  | GLint | location,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetUniformfv.

This function asserts on the result before returning.

NVSG_API void GLGetUniformiv | ( | GLuint | program,
 |  | GLint | location,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetUniformiv.

This function asserts on the result before returning.

NVSG_API void GLGetUniformuiv | ( | GLuint | program,
 |  | GLint | location,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetUniformuiv.

This function asserts on the result before returning.

NVSG_API GLint GLGetUniformBufferSize | ( | GLuint | program,
 |  | GLint | location
 | ) | [friend]

Replacement of glGetUniformBufferSizeEXT.

This function asserts on the result before returning.

NVSG_API GLint GLGetUniformLocation | ( | GLuint | program,
 |  | const GLcharARB * | name
 | ) | [friend]

Replacement of glGetUniformLocation.

This function asserts on the result before returning.

NVSG_API GLintptr GLGetUniformOffset | ( | GLuint | program,
 |  | GLint | location
 | ) | [friend]

Replacement of glGetUniformOffsetEXT.

This function asserts on the result before returning.

NVSG_API GLint GLGetVaryingLocation | ( | GLuint | program,
 |  | const GLchar * | name
 | ) | [friend]

Replacement of glGetVaryingLocationNV.

This function asserts on the result before returning.

NVSG_API void GLGetVertexAttribdv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLdouble * | params
 | ) | [friend]

Replacement of glGetVertexAttribdv.

This function asserts on the result before returning.

NVSG_API void GLGetVertexAttribfv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetVertexAttribfv.

This function asserts on the result before returning.

NVSG_API void GLGetVertexAttribiv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetVertexAttribiv.

This function asserts on the result before returning.

NVSG_API void GLGetVertexAttribIiv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetVertexAttribIivEXT.

This function asserts on the result before returning.

NVSG_API void GLGetVertexAttribIuiv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetVertexAttribIuivEXT.

This function asserts on the result before returning.

NVSG_API void GLGetVertexAttribPointerv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLvoid ** | pointer
 | ) | [friend]

Replacement of glGetVertexAttribPointer.

This function asserts on the result before returning.

NVSG_API GLint GLGetVersion ( ) [friend]

Returns the version of the OpenGL available on the target system.

Returns:
The floating point version of the OpenGL with the representation major.minor is returned as an integer calculated as 10*major+minor.

The OpenGL version 1.4, for example, will be reported as 14.

NVSG_API void GLHint | ( | GLenum | target,
 |  | GLenum | mode
 | ) | [friend]

Replacement of glHint.

This function asserts on the result before returning.

NVSG_API void GLHistogram | ( | GLenum | target,
 |  | GLsizei | width,
 |  | GLenum | internalformat,
 |  | GLboolean | sink
 | ) | [friend]

Replacement of glHistogram.

This function asserts on the result before returning.

NVSG_API void GLIndexd ( GLdouble c ) [friend]

Replacement of glIndexd.

This function asserts on the result before returning.

NVSG_API void GLIndexf ( GLfloat c ) [friend]

Replacement of glIndexf.

This function asserts on the result before returning.

NVSG_API void GLIndexi ( GLint c ) [friend]

Replacement of glIndexi.

This function asserts on the result before returning.

NVSG_API void GLIndexMask ( GLuint mask ) [friend]

Replacement of glIndexMask.

This function asserts on the result before returning.

NVSG_API void GLIndexPointer | ( | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glIndexPointer.

This function asserts on the result before returning.

NVSG_API void GLIndexs ( GLshort c ) [friend]

Replacement of glIndexs.

This function asserts on the result before returning.

NVSG_API void GLIndexub ( GLubyte c ) [friend]

Replacement of glIndexub.

This function asserts on the result before returning.

NVSG_API void GLInitNames ( void ) [friend]

Replacement of glInitNames.

This function asserts on the result before returning.

NVSG_API void GLInterleavedArrays | ( | GLenum | format,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glInterleavedArrays.

This function asserts on the result before returning.

NVSG_API GLboolean GLIsArraySet ( GLuint buffer ) [friend]

Replacement of glIsArraySetARB.

This function asserts on the result before returning.

NVSG_API GLboolean GLIsBuffer ( GLuint name ) [friend]

Replacement of glIsBuffer.

This function tests if for the current render context, name denotes a valid vertex buffer object.

NVSG_API GLboolean GLIsEnabled ( GLenum cap ) [friend]

Replacement of glIsEnabled.

This function returns the state of the queried capability.

NVSG_API GLboolean GLIsEnabledAlphaTest ( ) [friend]

Replacement of glIsEnabled( GL_ALPHA_TEST ).

This function returns the state of the GL_ALPHA_TEST capability.

NVSG_API GLboolean GLIsEnabledAutoNormal ( ) [friend]

Replacement of glIsEnabled( GL_AUTO_NORMAL ).

This function returns the state of the GL_AUTO_NORMAL capability.

NVSG_API GLboolean GLIsEnabledBlend ( ) [friend]

Replacement of glIsEnabled( GL_BLEND ).

This function returns the state of the GL_BLEND capability.

NVSG_API GLboolean GLIsEnabledClipPlane ( GLenum plane ) [friend]

Replacement of glIsEnabled( GL_CLIP_PLANEi ).

This function returns the state of the GL_CLIP_PLANEi capability.

NVSG_API GLboolean GLIsEnabledColorLogicOp ( ) [friend]

Replacement of glIsEnabled( GL_COLOR_LOGIC_OP ).

This function returns the state of the GL_COLOR_LOGIC_OP capability.

NVSG_API GLboolean GLIsEnabledColorMaterial ( ) [friend]

Replacement of glIsEnabled( GL_COLOR_MATERIAL ).

This function returns the state of the GL_COLOR_MATERIAL capability.

NVSG_API GLboolean GLIsEnabledCullFace ( ) [friend]

Replacement of glIsEnabled( GL_CULL_FACE ).

This function returns the state of the GL_CULL_FACE capability.

NVSG_API GLboolean GLIsEnabledDepthTest ( ) [friend]

Replacement of glIsEnabled( GL_DEPTH_TEST ).

This function returns the state of the GL_DEPTH_TEST capability.

NVSG_API GLboolean GLIsEnabledDither ( ) [friend]

Replacement of glIsEnabled( GL_DITHER ).

This function returns the state of the GL_DITHER capability.

NVSG_API GLboolean GLIsEnabledFog ( ) [friend]

Replacement of glIsEnabled( GL_FOG ).

This function returns the state of the GL_FOG capability.

NVSG_API GLboolean GLIsEnabledIndexed | ( | GLenum | target,
 |  | GLuint | index
 | ) | [friend]

Replacement of glIsEnabledIndexed.

This functions asserts on the result before returning.

NVSG_API GLboolean GLIsEnabledLight ( GLenum cap ) [friend]

Replacement of glIsEnabled( GL_LIGHTi ).

This function returns the state of the GL_LIGHTi capability.

NVSG_API GLboolean GLIsEnabledLighting ( ) [friend]

Replacement of glIsEnabled( GL_LIGHTING ).

This function returns the state of the GL_LIGHTING capability.

NVSG_API GLboolean GLIsEnabledLineSmooth ( ) [friend]

Replacement of glIsEnabled( GL_LINE_SMOOTH ).

This function returns the state of the GL_LINE_SMOOTH capability.

NVSG_API GLboolean GLIsEnabledLineStipple ( ) [friend]

Replacement of glIsEnabled( GL_LINE_STIPPLE ).

This function returns the state of the GL_LINE_STIPPLE capability.

NVSG_API GLboolean GLIsEnabledLogicOp ( ) [friend]

Replacement of glIsEnabled( GL_LOGIC_OP ).

This function returns the state of the GL_LOGIC_OP capability.

NVSG_API GLboolean GLIsEnabledNormalize ( ) [friend]

Replacement of glIsEnabled( GL_NORMALIZE ).

This function returns the state of the GL_NORMALIZE capability.

NVSG_API GLboolean GLIsEnabledPointSmooth ( ) [friend]

Replacement of glIsEnabled( GL_POINT_SMOOTH ).

This function returns the state of the GL_POINT_SMOOTH capability.

NVSG_API GLboolean GLIsEnabledPolygonOffsetFill ( ) [friend]

Replacement of glIsEnabled( GL_POLYGON_OFFSET_FILL ).

This function returns the state of the GL_POLYGON_OFFSET_FILL capability.

NVSG_API GLboolean GLIsEnabledPolygonOffsetLine ( ) [friend]

Replacement of glIsEnabled( GL_POLYGON_OFFSET_LINE ).

This function returns the state of the GL_POLYGON_OFFSET_LINE capability.

NVSG_API GLboolean GLIsEnabledPolygonOffsetPoint ( ) [friend]

Replacement of glIsEnabled( GL_POLYGON_OFFSET_POINT ).

This function returns the state of the GL_POLYGON_OFFSET_POINT capability.

NVSG_API GLboolean GLIsEnabledPolygonSmooth ( ) [friend]

Replacement of glIsEnabled( GL_POLYGON_SMOOTH ).

This function returns the state of the GL_POLYGON_SMOOTH capability.

NVSG_API GLboolean GLIsEnabledPolygonStipple ( ) [friend]

Replacement of glIsEnabled( GL_POLYGON_STIPPLE ).

This function returns the state of the GL_POLYGON_STIPPLE capability.

NVSG_API GLboolean GLIsEnabledScissorTest ( ) [friend]

Replacement of glIsEnabled( GL_SCISSOR_TEST ).

This function returns the state of the GL_SCISSOR_TEST capability.

NVSG_API GLboolean GLIsEnabledStencilTest ( ) [friend]

Replacement of glIsEnabled( GL_STENCIL_TEST ).

This function returns the state of the GL_STENCIL_TEST capability.

NVSG_API GLboolean GLIsEnabledTexture ( GLenum cap ) [friend]

Replacement of glIsEnabled( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

This function returns the state of the [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] capability.

NVSG_API GLboolean GLIsEnabledTextureGen ( GLenum cap ) [friend]

Replacement of glIsEnabled( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

This function returns the state of the [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] capability.

NVSG_API GLboolean GLIsExtensionAvailable ( const std::string & extension ) [friend]

Test if a given extension is available on the current context.

Note:
Not all exported extensions might be available.
Returns:
true, if all functions of extension are available, otherwise false

NVSG_API GLboolean GLIsExtensionExported ( const std::string & extension ) [friend]

Test if a given extension is exported on the current context.

Note:
Not all exported extensions might be available.
Returns:
true, if extension is exported, otherwise false

NVSG_API GLboolean GLIsFence ( GLuint fence ) [friend]

Replacement of glIsFenceNV.

This function asserts on the result before returning.

NVSG_API GLboolean GLIsList ( GLuint list ) [friend]

Replacement of glIsList.

This function tests if for the current context, list denotes a valid display list and asserts on the result before returning.

NVSG_API GLboolean GLIsOcclusionQuery ( GLuint id ) [friend]

Replacement of glIsOcclusionQueryNV.

This function tests if for the current context, id denotes a valid query and asserts on the result before returning.

NVSG_API GLboolean GLIsProgram ( GLuint program ) [friend]

Replacement of glIsProgram.

This function tests if for the current context, id denotes a valid program and asserts on the result before returning.

NVSG_API GLboolean GLIsQuery ( GLuint id ) [friend]

Replacement of glIsQuery.

This function tests if for the current context, id denotes a valid query and asserts on the result before returning.

NVSG_API GLboolean GLIsShader ( GLuint shader ) [friend]

Replacement of glIsShader.

This function asserts on the result before returning.

NVSG_API GLboolean GLIsTexture ( GLuint texture ) [friend]

Replacement of glIsTexture.

This function tests if for the current context, texture denotes a valid texture and asserts on the result before returning.

NVSG_API void GLLightAmbient | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLLightfv( light, GL_AMBIENT, param ).

This function caches the GL_AMBIENT value on the light. It is faster to call this method instead of GLLightfv( light, GL_AMBIENT, param ) directly.

NVSG_API void GLLightConstantAttenuation | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [friend]

Cached version of GLLightf( light, GL_CONSTANT_ATTENUATION, param ).

This function caches the GL_CONSTANT_ATTENUATION value on the light. It is faster to call this method instead of GLLightf( light, GL_CONSTANT_ATTENUATION, param ) directly.

NVSG_API void GLLightDiffuse | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLLightfv( light, GL_DIFFUSE, param ).

This function caches the GL_DIFFUSE value on the light. It is faster to call this method instead of GLLightfv( light, GL_DIFFUSE, param ) directly.

NVSG_API void GLLightf | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glLightf.

This function caches on some pname values and asserts on the result.

NVSG_API void GLLightfv | ( | GLenum | light,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glLightfv.

This function caches on some pname values and asserts on the result.

NVSG_API void GLLighti | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glLighti.

This function caches on some pname values and asserts on the result.

NVSG_API void GLLightiv | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glLightiv.

This function caches on some pname values and asserts on the result.

NVSG_API void GLLightPosition | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLLightfv( light, GL_POSITION, param ).

The light position is not cached, and it should not be. This function just exists for completeness.

NVSG_API void GLLightLinearAttenuation | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [friend]

Cached version of GLLightf( light, GL_LINEAR_ATTENUATION, param ).

This function caches the GL_LINEAR_ATTENUATION value on the light. It is faster to call this method instead of GLLightf( light, GL_LINEAR_ATTENUATION, param ) directly.

NVSG_API void GLLightQuadraticAttenuation | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [friend]

Cached version of GLLightf( light, GL_QUADRATIC_ATTENUATION, param ).

This function caches the GL_QUADRATIC_ATTENUATION value on the light. It is faster to call this method instead of GLLightf( light, GL_QUADRATIC_ATTENUATION, param ) directly.

NVSG_API void GLLightSpecular | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLLightfv( light, GL_SPECULAR, param ).

This function caches the GL_SPECULAR value on the light. It is faster to call this method instead of GLLightfv( light, GL_SPECULAR, param ) directly.

NVSG_API void GLLightSpotCutoff | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [friend]

Cached version of GLLightf( light, GL_SPOT_CUTOFF, param ).

This function caches the GL_SPOT_CUTOFF value on the light. It is faster to call this method instead of GLLightf( light, GL_SPOT_CUTOFF, param ) directly.

NVSG_API void GLLightSpotDirection | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLLightfv( light, GL_SPOT_DIRECTION, param ).

The light spot direction is not cached, and it should not be. This function just exists for completeness.

NVSG_API void GLLightSpotExponent | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [friend]

Cached version of GLLightf( light, GL_SPOT_EXPONENT, param ).

This function caches the GL_SPOT_EXPONENT value on the light. It is faster to call this method instead of GLLightf( light, GL_SPOT_EXPONENT, param ) directly.

NVSG_API void GLLightModelf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glLightModelf.

This function caches some of the light model settings and asserts on the result before returning.

NVSG_API void GLLightModelfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glLightModelfv.

This function caches some the light model settings and asserts on the result before returning.

NVSG_API void GLLightModeli | ( | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glLightModeli.

This function caches some of the light model settings and asserts on the result before returning.

NVSG_API void GLLightModeliv | ( | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glLightModeliv.

This function caches some of the light model settings and asserts on the result before returning.

NVSG_API void GLLightModelAmbient ( const GLfloat * params ) [friend]

Replacement of glLightModelfv( GL_LIGHT_MODEL_AMBIENT, params ).

This function caches the light model settings and asserts on the result before returning.

NVSG_API void GLLightModelLocalViewer ( GLint param ) [friend]

Replacement of GLLightModelLocalViewer.

This function caches the light model settings and asserts on the result before returning.

NVSG_API void GLLightModelTwoSide ( GLint param ) [friend]

Replacement of GLLightModelTwoSide.

This function caches the light model settings and asserts on the result before returning.

NVSG_API void GLLightModelTwoSideLock ( GLint param ) [friend]

Helper function to set two sided lighting and lock it.

Parameters:
param The value to set and lock two sided lighting to.
Remarks:
This function sets two sided lighting to param and locks it. Any subsequent calls to GLLightModelTwoSide or GLLightModel{if}(GL_LIGHT_MODEL_TWO_SIDE,) will not change that setting, until the next call to GLLightModelTwoSideUnlock.
See also:
GLLightModelTwoSide, GLLightModelTwoSideUnlock

NVSG_API void GLLightModelTwoSideUnlock ( GLint param ) [friend]

Helper function to unlock the two sided lighting and set it.

Parameters:
param The value to set the unlocked two sided lighting to.
Remarks:
This function unlocks two sided lighting and sets it to param.
See also:
GLLightModelTwoSide, GLLightModelTwoSideLock

NVSG_API void GLLineStipple | ( | GLint | factor,
 |  | GLushort | pattern
 | ) | [friend]

Replacement of glLineStipple.

This function caches the line stipple settings and asserts on the result before returning.

NVSG_API void GLLineWidth ( GLfloat width ) [friend]

Replacement of glLineWidth.

This function caches the line width setting and asserts on the result before returning.

NVSG_API void GLLinkProgram ( GLuint program ) [friend]

Replacement of glLinkProgram.

This function asserts on the result before returning.

NVSG_API void GLListBase ( GLuint base ) [friend]

Replacement of glListBase.

This function asserts on the result before returning.

NVSG_API void GLLoadIdentity ( void ) [friend]

Replacement of glLoadItentity.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLLoadMatrixd ( const GLdouble * m ) [friend]

Replacement of glLoadMatrixd.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLLoadMatrixf ( const GLfloat * m ) [friend]

Replacement of glLoadMatrixf.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLLoadTransposedMatrixd ( const GLdouble * m ) [friend]

Replacement of glLoadTransposeMatrixd.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLLoadTransposeMatrixf ( const GLfloat * m ) [friend]

Replacement of glLoadTransposMatrixf.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLLoadName ( GLuint name ) [friend]

Replacement of glLoadName.

This function asserts on the result before returning.

NVSG_API void GLLoadProgram | ( | GLenum | target,
 |  | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | program
 | ) | [friend]

Replacement of glLoadProgramNV.

This function hides the extension character of glLoadProgramNV and asserts on the result before returning.

NVSG_API void GLLockArrays | ( | GLint | first,
 |  | GLsizei | count
 | ) | [friend]

Replacement of glLockArrays.

This function asserts on the result before returning.

NVSG_API void GLLogicOp ( GLenum opcode ) [friend]

Replacement of glLogicOp.

This function asserts on the result before returning.

NVSG_API void GLMap1d | ( | GLenum | target,
 |  | GLdouble | u1,
 |  | GLdouble | u2,
 |  | GLint | stride,
 |  | GLint | order,
 |  | const GLdouble * | points
 | ) | [friend]

Replacement of glMap1d.

This function asserts on the result before returning.

NVSG_API void GLMap1f | ( | GLenum | target,
 |  | GLfloat | u1,
 |  | GLfloat | u2,
 |  | GLint | stride,
 |  | GLint | order,
 |  | const GLfloat * | points
 | ) | [friend]

Replacement of glMap1f.

This function asserts on the result before returning.

NVSG_API void GLMap2d | ( | GLenum | target,
 |  | GLdouble | u1,
 |  | GLdouble | u2,
 |  | GLint | ustride,
 |  | GLint | uorder,
 |  | GLdouble | v1,
 |  | GLdouble | v2,
 |  | GLint | vstride,
 |  | GLint | vorder,
 |  | const GLdouble * | points
 | ) | [friend]

Replacement of glMap2d.

This function asserts on the result before returning.

NVSG_API void GLMap2f | ( | GLenum | target,
 |  | GLfloat | u1,
 |  | GLfloat | u2,
 |  | GLint | ustride,
 |  | GLint | uorder,
 |  | GLfloat | v1,
 |  | GLfloat | v2,
 |  | GLint | vstride,
 |  | GLint | vorder,
 |  | const GLfloat * | points
 | ) | [friend]

Replacement of glMap2f.

This function asserts on the result before returning.

NVSG_API GLvoid* GLMapBuffer | ( | GLenum | target,
 |  | GLenum | access
 | ) | [friend]

Replacement of glMapBuffer.

This function hides the extension character of glMapBufferARB and asserts on the result before returning.

NVSG_API void GLMapGrid1d | ( | GLint | un,
 |  | GLdouble | u1,
 |  | GLdouble | u2
 | ) | [friend]

Replacement of glMapGrid1d.

This function asserts on the result before returning.

NVSG_API void GLMapGrid1f | ( | GLint | un,
 |  | GLfloat | u1,
 |  | GLfloat | u2
 | ) | [friend]

Replacement of glMapGrid1f.

This function asserts on the result before returning.

NVSG_API void GLMapGrid2d | ( | GLint | un,
 |  | GLdouble | u1,
 |  | GLdouble | u2,
 |  | GLint | vn,
 |  | GLdouble | v1,
 |  | GLdouble | v2
 | ) | [friend]

Replacement of glMapGrid2d.

This function asserts on the result before returning.

NVSG_API void GLMapGrid2f | ( | GLint | un,
 |  | GLfloat | u1,
 |  | GLfloat | u2,
 |  | GLint | vn,
 |  | GLfloat | v1,
 |  | GLfloat | v2
 | ) | [friend]

Replacement of glMapGrid2f.

This function asserts on the result before returning.

NVSG_API void GLMaterialAmbient | ( | GLenum | face,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLMaterialfv( face, GL_AMBIENT, params ).

This function caches the GL_AMBIENT value of the material. It is faster to call this method instead of GLMaterialfv(face,GL_AMBIENT,params) directly.

NVSG_API void GLMaterialAmbientBack ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_BACK, GL_AMBIENT, param ).

This function caches the GL_AMBIENT value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_AMBIENT, param ) directly.

NVSG_API void GLMaterialAmbientFront ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_FRONT, GL_AMBIENT, param ).

This function caches the GL_AMBIENT value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_AMBIENT, param ) directly.

NVSG_API void GLMaterialAmbientFrontAndBack ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_AMBIENT, param ).

This function caches the GL_AMBIENT value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_AMBIENT, param ) directly.

NVSG_API void GLMaterialDiffuse | ( | GLenum | face,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLMaterialfv( face, GL_DIFFUSE, params ).

This function caches the GL_DIFFUSE value of the material. It is faster to call this method instead of GLMaterialfv(face,GL_DIFFUSE,params) directly.

NVSG_API void GLMaterialDiffuseBack ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_BACK, GL_DIFFUSE, param ).

This function caches the GL_DIFFUSE value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_DIFFUSE, param ) directly.

NVSG_API void GLMaterialDiffuseFront ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_FRONT, GL_DIFFUSE, param ).

This function caches the GL_DIFFUSE value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_DIFFUSE, param ) directly.

NVSG_API void GLMaterialDiffuseFrontAndBack ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_DIFFUSE, param ).

This function caches the GL_DIFFUSE value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_DIFFUSE, param ) directly.

NVSG_API void GLMaterialEmission | ( | GLenum | face,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLMaterialfv( face, GL_EMISSION, params ).

This function caches the GL_EMISSION value of the material. It is faster to call this method instead of GLMaterialfv(face,GL_EMISSION,params) directly.

NVSG_API void GLMaterialEmissionBack ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_BACK, GL_EMISSION, param ).

This function caches the GL_EMISSION value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_EMISSION, param ) directly.

NVSG_API void GLMaterialEmissionFront ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_FRONT, GL_EMISSION, param ).

This function caches the GL_EMISSION value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_EMISSION, param ) directly.

NVSG_API void GLMaterialEmissionFrontAndBack ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_EMISSION, param ).

This function caches the GL_EMISSION value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_EMISSION, param ) directly.

NVSG_API void GLMaterialf | ( | GLenum | face,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glMaterialf.

This function caches on some face and pname values and asserts on the result before returning.

NVSG_API void GLMaterialfv | ( | GLenum | face,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glMaterialfv.

This function caches on some face and pname values and asserts on the result before returning.

NVSG_API void GLMateriali | ( | GLenum | face,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glMateriali.

This function caches on some face and pname values and asserts on the result before returning.

NVSG_API void GLMaterialiv | ( | GLenum | face,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glMaterialiv.

This function caches on some face and pname values and asserts on the result before returning.

NVSG_API void GLMaterialShininess | ( | GLenum | face,
 |  | GLfloat | param
 | ) | [friend]

Cached version of GLMaterialf( face, GL_SHININESS, param ).

This function caches the GL_SHININESS value of the material. It is faster to call this method instead of GLMaterialf(face,GL_SHININESS,param) directly.

NVSG_API void GLMaterialShininessBack ( GLfloat param ) [friend]

Cached version of GLMaterialf( GL_BACK, GL_SHININESS, param ).

This function caches the GL_SHININESS value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_SHININESS, param ) directly.

NVSG_API void GLMaterialShininessFront ( GLfloat param ) [friend]

Cached version of GLMaterialf( GL_FRONT, GL_SHININESS, param ).

This function caches the GL_SHININESS value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_SHININESS, param ) directly.

NVSG_API void GLMaterialShininessFrontAndBack ( GLfloat param ) [friend]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, param ).

This function caches the GL_SHININESS value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, param ) directly.

NVSG_API void GLMaterialSpecular | ( | GLenum | face,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLMaterialfv( face, GL_SPECULAR, params ).

This function caches the GL_SPECULAR value of the material. It is faster to call this method instead of GLMaterialfv(face,GL_SPECULAR,params) directly.

NVSG_API void GLMaterialSpecularBack ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_BACK, GL_SPECULAR, param ).

This function caches the GL_SPECULAR value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_SPECULAR, param ) directly.

NVSG_API void GLMaterialSpecularFront ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_FRONT, GL_SPECULAR, param ).

This function caches the GL_SPECULAR value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_SPECULAR, param ) directly.

NVSG_API void GLMaterialSpecularFrontAndBack ( const GLfloat * params ) [friend]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SPECULAR, param ).

This function caches the GL_SPECULAR value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_SPECULAR, param ) directly.

NVSG_API void GLMatrixMode ( GLenum mode ) [friend]

Replacement of glMatrixMode.

This function caches the matrix mode setting and asserts on the result before returning.

NVSG_API void GLMinmax | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLboolean | sink
 | ) | [friend]

Replacement of glMinmax.

This function asserts on the result before returning.

NVSG_API void GLMultiDrawArrays | ( | GLenum | mode,
 |  | const GLint * | first,
 |  | const GLsizei * | count,
 |  | GLsizei | primcount
 | ) | [friend]

Replacement of glMultiDrawArrays.

This function asserts on the result before returning.

NVSG_API void GLMultiDrawElements | ( | GLenum | mode,
 |  | const GLsizei * | count,
 |  | GLenum | type,
 |  | const GLvoid ** | indices,
 |  | GLsizei | primcount
 | ) | [friend]

Replacement of glMultiDrawElements.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1d | ( | GLenum | target,
 |  | GLdouble | s
 | ) | [friend]

Replacement of glMultiTexCoord1d.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1dv | ( | GLenum | target,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glMultiTexCoord1dv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1f | ( | GLenum | target,
 |  | GLfloat | s
 | ) | [friend]

Replacement of glMultiTexCoord1f.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1fv | ( | GLenum | target,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glMultiTexCoord1fv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1h | ( | GLenum | target,
 |  | GLhalf | s
 | ) | [friend]

Replacement of glMultiTexCoord1hNV.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1hv | ( | GLenum | target,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glMultiTexCoord1hv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1i | ( | GLenum | target,
 |  | GLint | s
 | ) | [friend]

Replacement of glMultiTexCoord1i.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1iv | ( | GLenum | target,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glMultiTexCoord1iv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1s | ( | GLenum | target,
 |  | GLshort | s
 | ) | [friend]

Replacement of glMultiTexCoord1s.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord1sv | ( | GLenum | target,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glMultiTexCoord1sv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2d | ( | GLenum | target,
 |  | GLdouble | s,
 |  | GLdouble | t
 | ) | [friend]

Replacement of glMultiTexCoord2d.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2dv | ( | GLenum | target,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glMultiTexCoord2dv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2f | ( | GLenum | target,
 |  | GLfloat | s,
 |  | GLfloat | t
 | ) | [friend]

Replacement of glMultiTexCoord2f.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2fv | ( | GLenum | target,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glMultiTexCoord2fv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2h | ( | GLenum | target,
 |  | GLhalf | s,
 |  | GLhalf | t
 | ) | [friend]

Replacement of glMultiTexCoord2hNV.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2hv | ( | GLenum | target,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glMultiTexCoord2hv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2i | ( | GLenum | target,
 |  | GLint | s,
 |  | GLint | t
 | ) | [friend]

Replacement of glMultiTexCoord2i.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2iv | ( | GLenum | target,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glMultiTexCoord2iv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2s | ( | GLenum | target,
 |  | GLshort | s,
 |  | GLshort | t
 | ) | [friend]

Replacement of glMultiTexCoord2s.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord2sv | ( | GLenum | target,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glMultiTexCoord2sv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3d | ( | GLenum | target,
 |  | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r
 | ) | [friend]

Replacement of glMultiTexCoord3d.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3dv | ( | GLenum | target,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glMultiTexCoord3dv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3f | ( | GLenum | target,
 |  | GLfloat | s,
 |  | GLfloat | t,
 |  | GLfloat | r
 | ) | [friend]

Replacement of glMultiTexCoord3f.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3fv | ( | GLenum | target,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glMultiTexCoord3fv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3h | ( | GLenum | target,
 |  | GLhalf | s,
 |  | GLhalf | t,
 |  | GLhalf | r
 | ) | [friend]

Replacement of glMultiTexCoord3hNV.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3hv | ( | GLenum | target,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glMultiTexCoord3hv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3i | ( | GLenum | target,
 |  | GLint | s,
 |  | GLint | t,
 |  | GLint | r
 | ) | [friend]

Replacement of glMultiTexCoord3i.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3iv | ( | GLenum | target,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glMultiTexCoord3iv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3s | ( | GLenum | target,
 |  | GLshort | s,
 |  | GLshort | t,
 |  | GLshort | r
 | ) | [friend]

Replacement of glMultiTexCoord3s.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord3sv | ( | GLenum | target,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glMultiTexCoord3sv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4d | ( | GLenum | target,
 |  | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r,
 |  | GLdouble | q
 | ) | [friend]

Replacement of glMultiTexCoord4d.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4dv | ( | GLenum | target,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glMultiTexCoord4dv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4f | ( | GLenum | target,
 |  | GLfloat | s,
 |  | GLfloat | t,
 |  | GLfloat | r,
 |  | GLfloat | q
 | ) | [friend]

Replacement of glMultiTexCoord4f.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4fv | ( | GLenum | target,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glMultiTexCoord4fv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4h | ( | GLenum | target,
 |  | GLhalf | s,
 |  | GLhalf | t,
 |  | GLhalf | r,
 |  | GLhalf | q
 | ) | [friend]

Replacement of glMultiTexCoord4hNV.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4hv | ( | GLenum | target,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glMultiTexCoord4hv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4i | ( | GLenum | target,
 |  | GLint | s,
 |  | GLint | t,
 |  | GLint | r,
 |  | GLint | q
 | ) | [friend]

Replacement of glMultiTexCoord4i.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4iv | ( | GLenum | target,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glMultiTexCoord4iv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4s | ( | GLenum | target,
 |  | GLshort | s,
 |  | GLshort | t,
 |  | GLshort | r,
 |  | GLshort | q
 | ) | [friend]

Replacement of glMultiTexCoord4s.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoord4sv | ( | GLenum | target,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glMultiTexCoord4sv.

This function asserts on the result before returning.

NVSG_API void GLMultiTexCoordPointer | ( | GLenum | target,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glMultiTexCoordPointer.

This function asserts on the result before returning.

NVSG_API void GLMultMatrixd ( const GLdouble * m ) [friend]

Replacement of glMultMatrixd.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLMultMatrixf ( const GLfloat * m ) [friend]

Replacement of glMultMatrixf.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLMultTransposeMatrixd ( const GLdouble * m ) [friend]

Replacement of glMultTransposeMatrixd.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLMultTransposeMatrixf ( const GLfloat * m ) [friend]

Replacement of glMultTransposeMatrixf.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLNewList | ( | GLuint | list,
 |  | GLenum | mode
 | ) | [friend]

Replacement of glNewList.

This function asserts on the result before returning.

NVSG_API void GLNormal3b | ( | GLbyte | nx,
 |  | GLbyte | ny,
 |  | GLbyte | nz
 | ) | [friend]

Replacement of glNormal3b.

This function asserts on the result before returning.

NVSG_API void GLNormal3bv ( const GLbyte * v ) [friend]

Replacement of glNormal3bv.

This function asserts on the result before returning.

NVSG_API void GLNormal3d | ( | GLdouble | nx,
 |  | GLdouble | ny,
 |  | GLdouble | nz
 | ) | [friend]

Replacement of glNormal3d.

This function asserts on the result before returning.

NVSG_API void GLNormal3dv ( const GLdouble * v ) [friend]

Replacement of glNormal3dv.

This function asserts on the result before returning.

NVSG_API void GLNormal3f | ( | GLfloat | nx,
 |  | GLfloat | ny,
 |  | GLfloat | nz
 | ) | [friend]

Replacement of glNormal3f.

This function asserts on the result before returning.

NVSG_API void GLNormal3fv ( const GLfloat * v ) [friend]

Replacement of glNormal3fv.

This function asserts on the result before returning.

NVSG_API void GLNormal3h | ( | GLhalf | nx,
 |  | GLhalf | ny,
 |  | GLhalf | nz
 | ) | [friend]

Replacement of glNormal3hNV.

This function asserts on the result before returning.

NVSG_API void GLNormal3hv ( const GLhalf * v ) [friend]

Replacement of glNormal3hv.

This function asserts on the result before returning.

NVSG_API void GLNormal3i | ( | GLint | nx,
 |  | GLint | ny,
 |  | GLint | nz
 | ) | [friend]

! Replacement of glNormal3i

This function asserts on the result before returning.

NVSG_API void GLNormal3iv ( const GLint * v ) [friend]

Replacement of glNormal3iv.

This function asserts on the result before returning.

NVSG_API void GLNormal3s | ( | GLshort | nx,
 |  | GLshort | ny,
 |  | GLshort | nz
 | ) | [friend]

Replacement of glNormal3s.

This function asserts on the result before returning.

NVSG_API void GLNormal3sv ( const GLshort * v ) [friend]

Replacement of glNormal3sv.

This function asserts on the result before returning.

NVSG_API void GLNormalPointer | ( | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glNormalPointer.

This function caches the normal pointer and asserts on the result before returning.

NVSG_API void GLOrtho | ( | GLdouble | left,
 |  | GLdouble | right,
 |  | GLdouble | bottom,
 |  | GLdouble | top,
 |  | GLdouble | zNear,
 |  | GLdouble | zFar
 | ) | [friend]

Replacement of glOrtho.

This function asserts on the result before returning.

NVSG_API void GLPassThrough ( GLfloat token ) [friend]

Replacement of glPassThrough.

This function asserts on the result before returning.

NVSG_API void GLPixelDataRange | ( | GLenum | target,
 |  | GLsizei | size,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glPixelDataRangeNV.

This function asserts on the result before returning.

NVSG_API void GLPixelMapfv | ( | GLenum | map,
 |  | GLsizei | mapsize,
 |  | const GLfloat * | values
 | ) | [friend]

Replacement of glPixelMapfv.

This function asserts on the result before returning.

NVSG_API void GLPixelMapuiv | ( | GLenum | map,
 |  | GLsizei | mapsize,
 |  | const GLuint * | values
 | ) | [friend]

Replacement of glPixelMapuiv.

This function asserts on the result before returning.

NVSG_API void GLPixelMapusv | ( | GLenum | map,
 |  | GLsizei | mapsize,
 |  | const GLushort * | values
 | ) | [friend]

Replacement of glPixelMapusv.

This function asserts on the result before returning.

NVSG_API void GLPixelStoref | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glPixelStoref.

This function asserts on the result before returning.

NVSG_API void GLPixelStorei | ( | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glPixelStorei.

This function asserts on the result before returning.

NVSG_API void GLPixelTransferf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glPixelTransferf.

This function asserts on the result before returning.

NVSG_API void GLPixelTransferi | ( | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glPixelTransferi.

This function asserts on the result before returning.

NVSG_API void GLPixelZoom | ( | GLfloat | xfactor,
 |  | GLfloat | yfactor
 | ) | [friend]

Replacement of glPixelZoom.

This function asserts on the result before returning.

NVSG_API void GLPointParameterf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glPointParameterf.

This function asserts on the result before returning.

NVSG_API void GLPointParameterfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glPointParameterfv.

This function asserts on the result before returning.

NVSG_API void GLPointParameteri | ( | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glPointParameteri.

This function asserts on the result before returning.

NVSG_API void GLPointParameteriv | ( | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glPointParameteriv.

This function asserts on the result before returning.

NVSG_API void GLPointSize ( GLfloat size ) [friend]

Replacement of glPointSize.

This function caches the point size setting and asserts on the result before returning.

NVSG_API void GLPolygonMode | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [friend]

Cached version of GLPolygonMode( face, mode ).

This function caches the polygon mode and assert on the result.

NVSG_API void GLPolygonModeBack ( GLenum mode ) [friend]

Cached version of GLPolygonMode( GL_BACK, mode ).

This function caches the polygon mode on the GL_BACK face of polygon. It is faster to call this method instead of GLPolygonMode( GL_BACK, mode ) directly.

NVSG_API void GLPolygonModeFront ( GLenum mode ) [friend]

Cached version of GLPolygonMode( GL_FRONT, mode ).

This function caches the polygon mode on the GL_FRONT face of polygon. It is faster to call this method instead of GLPolygonMode( GL_FRONT, mode ) directly.

NVSG_API void GLPolygonModeFrontAndBack ( GLenum mode ) [friend]

Cached version of GLPolygonMode( GL_FRONT_AND_BACK, mode ).

This function caches the polygon mode on both the GL_FRONT and GL_BACK face of polygon. It is faster to call this method instead of GLPolygonMode( GL_FRONT_AND_BACK, mode ) directly.

NVSG_API void GLPolygonModeLock | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [friend]

Helper function to set the polygon mode and lock it.

Parameters:
face | The face for which the polygon mode is to set and lock.
mode | The polygon mode to set and lock.
Remarks:
This function sets the polygon mode for face to mode and locks it. Any subsequent calls to GLPolygonMode, GLPolygonModeBack, or GLPolygonModeFront on the same face will not change that setting, until the next call to GLPolygonModeUnlock.
See also:
GLPolygonMode, GLPolygonModeUnlock

NVSG_API void GLPolygonModeUnlock | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [friend]

Helper function to unlock the polygon mode and set it.

Parameters:
face | The face for which the polygon mode is to be unlocked and set.
mode | The polygon mode to set.
Remarks:
This function unlocks the polygon mode for face and sets it to mode.
See also:
GLPolygonMode, GLPolygonModeLock

NVSG_API void GLPolygonOffset | ( | GLfloat | factor,
 |  | GLfloat | units
 | ) | [friend]

Replacement of glPolygonOffset.

This function caches the polygon offset settings and asserts on the result before returning.

NVSG_API void GLPolygonStipple ( const GLubyte * mask ) [friend]

Replacement of glPolygonStipple.

This function asserts on the result before returning.

NVSG_API void GLPopAttrib ( void ) [friend]

Replacement of glPopAttrib.

This function asserts on the result before returning.

Note:
Currently we don't hold a stack of cached GL states, so GLPushAttrib/GLPopAttrib doesn't affect our cached values. It is therefore recommended to used GLPushAttrib/GLPopAttrib very local and to not use other potentially caching GL* functions (with uppercase GL), inbetween such a pair.

NVSG_API void GLPopClientAttrib ( void ) [friend]

Replacement of glPopClientAttrib.

This function asserts on the result before returning.

Note:
Currently we don't hold a stack of cached GL states, so GLPushClientAttrib/GLPopClientAttrib doesn't affect our cached values. It is therefore recommended to used GLPushAttrib/GLPopAttrib very local and to not use other potentially caching GL* functions (with uppercase GL), inbetween such a pair.

NVSG_API void GLPopMatrix ( void ) [friend]

Replacement of glPopMatrix.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLPopName ( void ) [friend]

Replacement of glPopName.

This function asserts on the result before returning.

NVSG_API void GLPrimitiveRestart ( ) [friend]

Replacement of glPrimitiveRestart.

This function asserts on the result before returning.

NVSG_API void GLPrimitiveRestartIndex ( GLuint index ) [friend]

Replacement of glPrimitiveRestartIndex.

This function caches the primitive restart index and asserts on the result before returning.

NVSG_API void GLPrioritizeTextures | ( | GLsizei | n,
 |  | const GLuint * | textures,
 |  | const GLclampf * | priorities
 | ) | [friend]

Replacement of glPrioritizeTextures.

This function asserts on the result before returning.

NVSG_API void GLProgramBufferParametersfv | ( | GLenum | target,
 |  | GLuint | buffer,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glProgramBufferParametersfvNV.

This function asserts on the result before returning.

NVSG_API void GLProgramBufferParametersIiv | ( | GLenum | target,
 |  | GLuint | buffer,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glProgramBufferParametersIivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramBufferParametersIuiv | ( | GLenum | target,
 |  | GLuint | buffer,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLuint * | params
 | ) | [friend]

Replacement of glProgramBufferParametersIuivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameter4d | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [friend]

Replacement of glProgramEnvParameter4dARB.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameter4dv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLdouble * | params
 | ) | [friend]

Replacement of glProgramEnvParameter4dvARB.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameter4f | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [friend]

Replacement of glProgramEnvParameter4fARB.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameter4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glProgramEnvParameter4fvARB.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParametersI4iv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glProgramEnvParametersI4ivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameterI4i | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [friend]

Replacement of glProgramEnvParameterI4iNV.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameterI4iv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glProgramEnvParameterI4ivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParametersI4uiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLuint * | params
 | ) | [friend]

Replacement of glProgramEnvParametersI4uivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameterI4ui | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y,
 |  | GLuint | z,
 |  | GLuint | w
 | ) | [friend]

Replacement of glProgramEnvParameterI4uiNV.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameterI4uiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLuint * | params
 | ) | [friend]

Replacement of glProgramEnvParameterI4uivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramEnvParameters4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glProgramEnvParameters4fvEXT.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameter4d | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [friend]

Replacement of glProgramLocalParameter4dARB.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameter4dv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLdouble * | params
 | ) | [friend]

Replacement of glProgramLocalParameter4dvARB.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameter4f | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [friend]

Replacement of glProgramLocalParameter4fARB.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameter4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glProgramLocalParameter4fvARB.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParametersI4iv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glProgramLocalParametersI4ivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParametersI4uiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLuint * | params
 | ) | [friend]

Replacement of glProgramLocalParametersI4uivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameterI4i | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [friend]

Replacement of glProgramLocalParameterI4iNV.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameterI4iv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glProgramLocalParameterI4ivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameterI4ui | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y,
 |  | GLuint | z,
 |  | GLuint | w
 | ) | [friend]

Replacement of glProgramLocalParameterI4uiNV.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameterI4uiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLuint * | params
 | ) | [friend]

Replacement of glProgramLocalParameterI4uivNV.

This function asserts on the result before returning.

NVSG_API void GLProgramLocalParameters4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | params
 | ) | [friend]

Replacement of glProgramLocalParameters4fvEXT.

This function asserts on the result before returning.

NVSG_API void GLProgramNamedParameter4d | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [friend]

Replacement of glProgramNamedParameter4dNV.

This function asserts on the result before returning.

NVSG_API void GLProgramNamedParameter4dv | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glProgramNamedParameter4dvNV.

This function asserts on the result before returning.

NVSG_API void GLProgramNamedParameter4f | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [friend]

Replacement of glProgramNamedParameter4fNV.

This function asserts on the result before returning.

NVSG_API void GLProgramNamedParameter4fv | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glProgramNamedParameter4fvNV.

This function asserts on the result before returning.

NVSG_API void GLProgramParameter4d | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [friend]

Replacement of glProgramParameter4dNV.

This function asserts on the result before returning.

NVSG_API void GLProgramParameter4dv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glProgramParameter4dvNV.

This function asserts on the result before returning.

NVSG_API void GLProgramParameter4f | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [friend]

Replacement of glProgramParameter4fNV.

This function asserts on the result before returning.

NVSG_API void GLProgramParameter4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glProgramParameter4fvNV.

This function asserts on the result before returning.

NVSG_API void GLProgramParameteri | ( | GLuint | program,
 |  | GLenum | pname,
 |  | GLint | value
 | ) | [friend]

Replacement of glProgramParameteriEXT.

This function asserts on the result before returning.

NVSG_API void GLProgramParameters4dv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glProgramParameters4dvNV.

This function asserts on the result before returning.

NVSG_API void GLProgramParameters4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glProgramParameters4fvNV.

This function asserts on the result before returning.

NVSG_API void GLProgramString | ( | GLenum | target,
 |  | GLenum | format,
 |  | GLsizei | len,
 |  | const GLvoid * | string
 | ) | [friend]

Replacement of glProgramStringARB.

This function asserts on the result before returning.

NVSG_API void GLProgramVertexLimit | ( | GLenum | target,
 |  | GLint | limit
 | ) | [friend]

Replacement of glProgramVertexLimitNV.

This function asserts on the result before returning.

NVSG_API void GLPushAttrib ( GLbitfield mask ) [friend]

Replacement of glPushAttrib.

This function asserts on the result before returning.

Note:
Currently we don't hold a stack of cached GL states, so GLPushAttrib/GLPopAttrib doesn't affect our cached values. It is therefore recommended to used GLPushAttrib/GLPopAttrib very local and to not use other potentially caching GL* functions (with uppercase GL), inbetween such a pair.

NVSG_API void GLPushClientAttrib ( GLbitfield mask ) [friend]

Replacement of glPushClientAttrib.

This function asserts on the result before returning.

Note:
Currently we don't hold a stack of cached GL states, so GLPushClientAttrib/GLPopClientAttrib doesn't affect our cached values. It is therefore recommended to used GLPushAttrib/GLPopAttrib very local and to not use other potentially caching GL* functions (with uppercase GL), inbetween such a pair.

NVSG_API void GLPushMatrix ( void ) [friend]

Replacement of glPushMatrix.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLPushName ( GLuint name ) [friend]

Replacement of glPushName.

This function asserts on the result before returning.

NVSG_API void GLRasterPos2d | ( | GLdouble | x,
 |  | GLdouble | y
 | ) | [friend]

Replacement of glRasterPos2d.

This function asserts on the result before returning.

NVSG_API void GLRasterPos2f | ( | GLfloat | x,
 |  | GLfloat | y
 | ) | [friend]

Replacement of glRasterPos2f.

This function asserts on the result before returning.

NVSG_API void GLRasterPos2i | ( | GLint | x,
 |  | GLint | y
 | ) | [friend]

Replacement of glRasterPos2i.

This function asserts on the result before returning.

NVSG_API void GLRasterPos2s | ( | GLshort | x,
 |  | GLshort | y
 | ) | [friend]

Replacement of glRasterPos2s.

This function asserts on the result before returning.

NVSG_API void GLRasterPos3d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [friend]

Replacement of glRasterPos3d.

This function asserts on the result before returning.

NVSG_API void GLRasterPos3f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [friend]

Replacement of glRasterPos3f.

This function asserts on the result before returning.

NVSG_API void GLRasterPos3i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [friend]

Replacement of glRasterPos3i.

This function asserts on the result before returning.

NVSG_API void GLRasterPos3s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z
 | ) | [friend]

Replacement of glRasterPos3s.

This function asserts on the result before returning.

NVSG_API void GLRasterPos4d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [friend]

Replacement of glRasterPos4d.

This function asserts on the result before returning.

NVSG_API void GLRasterPos4f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [friend]

Replacement of glRasterPos4f.

This function asserts on the result before returning.

NVSG_API void GLRasterPos4i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [friend]

Replacement of glRasterPos4i.

This function asserts on the result before returning.

NVSG_API void GLRasterPos4s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z,
 |  | GLshort | w
 | ) | [friend]

Replacement of glRasterPos4s.

This function asserts on the result before returning.

NVSG_API void GLReadBuffer ( GLenum mode ) [friend]

Replacement of glReadBuffer.

This function asserts on the result before returning.

NVSG_API void GLReadPixels | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | pixels
 | ) | [friend]

Replacement of glReadPixels.

This function asserts on the result before returning.

NVSG_API void GLRectd | ( | GLdouble | x1,
 |  | GLdouble | y1,
 |  | GLdouble | x2,
 |  | GLdouble | y2
 | ) | [friend]

Replacement of glRectd.

This function asserts on the result before returning.

NVSG_API void GLRectf | ( | GLfloat | x1,
 |  | GLfloat | y1,
 |  | GLfloat | x2,
 |  | GLfloat | y2
 | ) | [friend]

Replacement of glRectf.

This function asserts on the result before returning.

NVSG_API void GLRecti | ( | GLint | x1,
 |  | GLint | y1,
 |  | GLint | x2,
 |  | GLint | y2
 | ) | [friend]

Replacement of glRecti.

This function asserts on the result before returning.

NVSG_API void GLRects | ( | GLshort | x1,
 |  | GLshort | y1,
 |  | GLshort | x2,
 |  | GLshort | y2
 | ) | [friend]

Replacement of glRects.

This function asserts on the result before returning.

NVSG_API void GLRenderMode ( GLenum mode ) [friend]

Replacement of glRenderMode.

This function asserts on the result before returning.

NVSG_API void GLRequestResidentPrograms | ( | GLsizei | n,
 |  | const GLuint * | programs
 | ) | [friend]

Replacement of glRequestResidentProgramsNV.

This function asserts on the result before returning.

NVSG_API void GLResetHistogram ( GLenum target ) [friend]

Replacement of glResetHistogram.

This function asserts on the result before returning.

NVSG_API void GLResetMinmax ( GLenum target ) [friend]

Replacement of glResetMinmax.

This function asserts on the result before returning.

NVSG_API void GLRotated | ( | GLdouble | angle,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [friend]

Replacement of glRotated.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLRotatef | ( | GLfloat | angle,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [friend]

Replacement of glRotatef.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLScaled | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [friend]

Replacement of glScaled.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLScalef | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [friend]

Replacement of glScalef.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLSampleCoverage | ( | GLclampf | value,
 |  | GLboolean | invert
 | ) | [friend]

Replacement of glSampleCoverage.

This function asserts on the result before returning.

NVSG_API void GLScissor | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glScissor.

This function caches the scissor settings and asserts on the result before returning.

NVSG_API void GLSecondaryColor3b | ( | GLbyte | red,
 |  | GLbyte | green,
 |  | GLbyte | blue
 | ) | [friend]

Replacement of glSecondaryColor3b.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3bv ( const GLbyte * v ) [friend]

Replacement of glSecondaryColor3bv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3d | ( | GLdouble | red,
 |  | GLdouble | green,
 |  | GLdouble | blue
 | ) | [friend]

Replacement of glSecondaryColor3d.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3dv ( const GLdouble * v ) [friend]

Replacement of glSecondaryColor3dv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3f | ( | GLfloat | red,
 |  | GLfloat | green,
 |  | GLfloat | blue
 | ) | [friend]

Replacement of glSecondaryColor3f.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3fv ( const GLfloat * v ) [friend]

Replacement of glSecondaryColor3fv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3h | ( | GLhalf | red,
 |  | GLhalf | green,
 |  | GLhalf | blue
 | ) | [friend]

Replacement of glSecondaryColor3h.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3hv ( const GLhalf * v ) [friend]

Replacement of glSecondaryColor3hv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3i | ( | GLint | red,
 |  | GLint | green,
 |  | GLint | blue
 | ) | [friend]

Replacement of glSecondaryColor3i.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3iv ( const GLint * v ) [friend]

Replacement of glSecondaryColor3iv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3s | ( | GLshort | red,
 |  | GLshort | green,
 |  | GLshort | blue
 | ) | [friend]

Replacement of glSecondaryColor3s.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3sv ( const GLshort * v ) [friend]

Replacement of glSecondaryColor3sv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3ub | ( | GLubyte | red,
 |  | GLubyte | green,
 |  | GLubyte | blue
 | ) | [friend]

Replacement of glSecondaryColor3ub.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3ubv ( const GLubyte * v ) [friend]

Replacement of glSecondaryColor3ubv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3ui | ( | GLuint | red,
 |  | GLuint | green,
 |  | GLuint | blue
 | ) | [friend]

Replacement of glSecondaryColor3ui.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3uiv ( const GLuint * v ) [friend]

Replacement of glSecondaryColor3uiv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3us | ( | GLushort | red,
 |  | GLushort | green,
 |  | GLushort | blue
 | ) | [friend]

Replacement of glSecondaryColor3us.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColor3usv ( const GLushort * v ) [friend]

Replacement of glSecondaryColor3usv.

This function asserts on the result before returning.

NVSG_API void GLSecondaryColorPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glSecondaryColorPointer.

This function caches the secondary color pointer setting and asserts on the result before returning.

NVSG_API void GLSelectBuffer | ( | GLsizei | size,
 |  | GLuint * | buffer
 | ) | [friend]

Replacement of glSelectBuffer.

This function asserts on the result before returning.

NVSG_API void GLSelectTexture ( GLenum target ) [friend]

Replacement of glSelectTexture.

This function simply maps to GLActiveTexture.

NVSG_API void GLSelectTextureCoordSet ( GLenum target ) [friend]

Replacement of GLSelectTextureCoordSet.

This function simply maps to GLClientActiveTexture.

NVSG_API void GLSeparableFilter2D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | row,
 |  | const GLvoid * | column
 | ) | [friend]

Replacement of glSeparableFilter2D.

This function asserts on the result before returning.

NVSG_API void GLSetFence | ( | GLuint | fence,
 |  | GLenum | condition
 | ) | [friend]

Replacement of glSetFenceNV.

NVSG_API void GLSetWindowStereoMode ( GLboolean displayMode ) [friend]

Replacement of glSetWindowStereoModeNV.

This function asserts on the result before returning.

NVSG_API void GLShadeModel ( GLenum mode ) [friend]

Replacement of glShadeModel.

This function caches the shade model setting and asserts on the result before returning.

NVSG_API void GLShaderSource | ( | GLuint | shader,
 |  | GLsizei | count,
 |  | const GLcharARB ** | string,
 |  | const GLint * | length
 | ) | [friend]

Replacement of glShaderSource.

NVSG_API void GLStencilClearTag | ( | GLsizei | tagBits,
 |  | GLuint | clearTag
 | ) | [friend]

Replacement of glStencilClearTag.

NVSG_API void GLStencilFunc | ( | GLenum | func,
 |  | GLint | ref,
 |  | GLuint | mask
 | ) | [friend]

Replacement of glStencilFunc.

This function caches the stencil function setting and asserts on the result before returning.

NVSG_API void GLStencilFuncSeparate | ( | GLenum | face,
 |  | GLenum | func,
 |  | GLint | ref,
 |  | GLuint | mask
 | ) | [friend]

Replacement of glStencilFuncSeparate.

NVSG_API void GLStencilOpSeparate | ( | GLenum | face,
 |  | GLenum | fail,
 |  | GLenum | zfail,
 |  | GLenum | zpass
 | ) | [friend]

Replacement of glStencilOpSeparate.

NVSG_API void GLStencilMaskSeparate | ( | GLenum | face,
 |  | GLuint | mask
 | ) | [friend]

Replacement of glStencilMaskSeparate.

NVSG_API void GLStencilMask ( GLuint mask ) [friend]

Replacement of glStencilMask.

This function caches the stencil mask setting and asserts on the result before returning.

NVSG_API void GLStencilOp | ( | GLenum | fail,
 |  | GLenum | zfail,
 |  | GLenum | zpass
 | ) | [friend]

Replacement of glStencilOp.

This function caches the stencil operation setting and asserts on the result before returning.

NVSG_API void GLStringMarker | ( | GLsizei | len,
 |  | const GLvoid * | string
 | ) | [friend]

Replacement of glStringMarkerGREMEDY.

This function simply does nothing if the extension is not available

NVSG_API GLboolean GLTestFence ( GLuint fence ) [friend]

Replacement of glTestFenceNV.

This function asserts on the result before returning.

NVSG_API void GLTexBuffer | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLuint | buffer
 | ) | [friend]

Replacement of glTexBufferEXT.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1d ( GLdouble s ) [friend]

Replacement of glTexCoord1d.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1dv ( const GLdouble * v ) [friend]

Replacement of glTexCoord1dv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1f ( GLfloat s ) [friend]

Replacement of glTexCoord1f.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1fv ( const GLfloat * v ) [friend]

Replacement of glTexCoord1fv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1h ( GLhalf s ) [friend]

Replacement of glTexCoord1hNV.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1hv ( const GLhalf * v ) [friend]

Replacement of glTexCoord1hv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1i ( GLint s ) [friend]

Replacement of glTexCoord1i.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1iv ( const GLint * v ) [friend]

Replacement of glTexCoord1iv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1s ( GLshort s ) [friend]

Replacement of glTexCoord1s.

This function asserts on the result before returning.

NVSG_API void GLTexCoord1sv ( const GLshort * v ) [friend]

Replacement of glTexCoord1sv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2d | ( | GLdouble | s,
 |  | GLdouble | t
 | ) | [friend]

Replacement of glTexCoord2d.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2dv ( const GLdouble * v ) [friend]

Replacement of glTexCoord2dv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2f | ( | GLfloat | s,
 |  | GLfloat | t
 | ) | [friend]

Replacement of glTexCoord2f.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2fv ( const GLfloat * v ) [friend]

Replacement of glTexCoord2fv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2h | ( | GLhalf | s,
 |  | GLhalf | t
 | ) | [friend]

Replacement of glTexCoord2hNV.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2hv ( const GLhalf * v ) [friend]

Replacement of glTexCoord2hv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2i | ( | GLint | s,
 |  | GLint | t
 | ) | [friend]

Replacement of glTexCoord2i.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2iv ( const GLint * v ) [friend]

Replacement of glTexCoord2iv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2s | ( | GLshort | s,
 |  | GLshort | t
 | ) | [friend]

Replacement of glTexCoord2s.

This function asserts on the result before returning.

NVSG_API void GLTexCoord2sv ( const GLshort * v ) [friend]

Replacement of glTexCoord2sv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3d | ( | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r
 | ) | [friend]

Replacement of glTexCoord3d.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3dv ( const GLdouble * v ) [friend]

Replacement of glTexCoord3dv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3f | ( | GLfloat | s,
 |  | GLfloat | t,
 |  | GLfloat | r
 | ) | [friend]

Replacement of glTexCoord3f.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3fv ( const GLfloat * v ) [friend]

Replacement of glTexCoord3fv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3h | ( | GLhalf | s,
 |  | GLhalf | t,
 |  | GLhalf | r
 | ) | [friend]

Replacement of glTexCoord3hNV.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3hv ( const GLhalf * v ) [friend]

Replacement of glTexCoord3hv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3i | ( | GLint | s,
 |  | GLint | t,
 |  | GLint | r
 | ) | [friend]

Replacement of glTexCoord3i.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3iv ( const GLint * v ) [friend]

Replacement of glTexCoord3iv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3s | ( | GLshort | s,
 |  | GLshort | t,
 |  | GLshort | r
 | ) | [friend]

Replacement of glTexCoord3s.

This function asserts on the result before returning.

NVSG_API void GLTexCoord3sv ( const GLshort * v ) [friend]

Replacement of glTexCoord3sv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4d | ( | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r,
 |  | GLdouble | q
 | ) | [friend]

Replacement of glTexCoord4d.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4dv ( const GLdouble * v ) [friend]

Replacement of glTexCoord4dv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4f | ( | GLfloat | s,
 |  | GLfloat | t,
 |  | GLfloat | r,
 |  | GLfloat | q
 | ) | [friend]

Replacement of glTexCoord4f.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4fv ( const GLfloat * v ) [friend]

Replacement of glTexCoord4fv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4h | ( | GLhalf | s,
 |  | GLhalf | t,
 |  | GLhalf | r,
 |  | GLhalf | q
 | ) | [friend]

Replacement of glTexCoord4hNV.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4hv ( const GLhalf * v ) [friend]

Replacement of glTexCoord4hv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4i | ( | GLint | s,
 |  | GLint | t,
 |  | GLint | r,
 |  | GLint | q
 | ) | [friend]

Replacement of glTexCoord4i.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4iv ( const GLint * v ) [friend]

Replacement of glTexCoord4iv.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4s | ( | GLshort | s,
 |  | GLshort | t,
 |  | GLshort | r,
 |  | GLshort | q
 | ) | [friend]

Replacement of glTexCoord4s.

This function asserts on the result before returning.

NVSG_API void GLTexCoord4sv ( const GLshort * v ) [friend]

Replacement of glTexCoord4sv.

This function asserts on the result before returning.

NVSG_API void GLTexCoordPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glTexCoordPointer.

This function caches the tex coord pointer setting and asserts on the result before returning.

NVSG_API void GLTexEnvf | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Cached version of glTexEnvf( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

NVSG_API void GLTexEnvfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of glTexEnvf( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

NVSG_API void GLTexEnvi | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Cached version of glTexEnvi( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

NVSG_API void GLTexEnviv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Cached version of glTexEnviv( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

NVSG_API void GLTexGend | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLdouble | param
 | ) | [friend]

Replacement of glTexGend.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTexGenf | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Replacement of glTexGenf.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTexGenfv | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | const GLfloat * | param
 | ) | [friend]

Replacement of glTexGenfv.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTexGeni | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Replacement of glTexGeni.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTexImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | internalformat,
 |  | GLsizei | width,
 |  | GLint | border,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [friend]

Replacement of glTexImage1D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTexImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLint | border,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [friend]

Replacement of glTexImage2D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTexImage3D | ( | GLenum | target,
 |  | int | level,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLsizei | depth,
 |  | int | border,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const void * | pixels
 | ) | [friend]

Replacement of glTexImage3D.

This function hides the extension character of glTexImage3D, updates the active texture, and asserts on the result before returning.

NVSG_API void GLTexParameterf | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [friend]

Cached version of glTexParameterf( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

NVSG_API void GLTexParameteri | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [friend]

Cached version of glTexParameteri( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

NVSG_API void GLTexParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of glTexParameterfv( target, pname, params ).

This function caches some of the texture environment parameters and asserts on the result before returning.

NVSG_API void GLTexParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Cached version of glTexParameteriv( target, pname, params ).

This function caches some of the texture environment parameters and asserts on the result before returning.

NVSG_API void GLTexParameterIiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [friend]

Replacement of glTexParameterIivEXT.

This function asserts on the result before returning.

NVSG_API void GLTexParameterIuiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLuint * | params
 | ) | [friend]

Replacement of glTexParameterIuivEXT.

This function asserts on the result before returning.

NVSG_API void GLTexSubImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [friend]

Replacement of glTexSubImage1D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTexSubImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [friend]

Replacement of glTexSubImage2D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTexSubImage3D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLint | zoffset,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLsizei | depth,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [friend]

Replacement of glTexSubImage3D.

This function updates the active texture and asserts on the result before returning.

NVSG_API void GLTextureBorderColor | ( | GLenum | target,
 |  | const GLfloat * | params
 | ) | [friend]

Cached version of GLTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, params ).

This function caches the GL_TEXTURE_BORDER_COLOR values of the texture currently bound to target. It is faster to call this method instead of GLTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, params) directly.

NVSG_API void GLTextureEnvColor ( const GLfloat * params ) [friend]

Cached version of GLTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params ).

This function caches the GL_TEXTURE_ENV_COLOR value of the active texture unit. It is faster to call this method instead of GLTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params) directly.

NVSG_API void GLTextureEnvMode ( GLint param ) [friend]

Cached version of GLTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, param ).

This function caches the GL_TEXTURE_ENV_MODE value of the active texture unit. It is faster to call this method instead of GLTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, param) directly.

NVSG_API void GLTextureMagFilter | ( | GLenum | target,
 |  | GLint | param
 | ) | [friend]

Cached version of GLTexParameteri( target, GL_TEXTURE_MAG_FILTER, param ).

This function caches the GL_TEXTURE_MAG_FILTER values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_MAG_FILTER, param) directly.

NVSG_API void GLTextureMinFilter | ( | GLenum | target,
 |  | GLint | param
 | ) | [friend]

Cached version of GLTexParameteri( target, GL_TEXTURE_MIN_FILTER, param ).

This function caches the GL_TEXTURE_MIN_FILTER values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_MIN_FILTER, param) directly.

NVSG_API void GLTextureWrapR | ( | GLenum | target,
 |  | GLint | param
 | ) | [friend]

Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_R, param ).

This function caches the GL_TEXTURE_WRAP_R values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_WRAP_R, param) directly.

NVSG_API void GLTextureWrapS | ( | GLenum | target,
 |  | GLint | param
 | ) | [friend]

Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_S, param ).

This function caches the GL_TEXTURE_WRAP_S values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_WRAP_S, param) directly.

NVSG_API void GLTextureWrapT | ( | GLenum | target,
 |  | GLint | param
 | ) | [friend]

Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_T, param ).

This function caches the GL_TEXTURE_WRAP_T values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_WRAP_T, param) directly.

NVSG_API void GLTrackMatrix | ( | GLenum | target,
 |  | GLuint | address,
 |  | GLenum | matrix,
 |  | GLenum | transform
 | ) | [friend]

Cached version of glTrackMatrixNV.

This function asserts on the result before returning.

NVSG_API void GLTransformFeedbackAttribs | ( | GLuint | count,
 |  | const GLint * | attribs,
 |  | GLenum | bufferMode
 | ) | [friend]

Cached version of glTransformFeedbackAttribsNV.

This function asserts on the result before returning.

NVSG_API void GLTransformFeedbackVaryings | ( | GLuint | program,
 |  | GLsizei | count,
 |  | const GLint * | locations,
 |  | GLenum | bufferMode
 | ) | [friend]

Cached version of glTransformFeedbackVaryingsNV.

This function asserts on the result before returning.

NVSG_API void GLTranslated | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [friend]

Replacement of glTranslated.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLTranslatef | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [friend]

Replacement of glTranslatef.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

NVSG_API void GLUnlockArrays ( ) [friend]

Replacement of glUnlockArrays.

This function asserts on the result before returning.

NVSG_API void GLUniform1f | ( | GLint | location,
 |  | GLfloat | v0
 | ) | [friend]

Replacement of glUniform1f.

This function asserts on the result before returning.

NVSG_API void GLUniform1fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniform1fv.

This function asserts on the result before returning.

NVSG_API void GLUniform1i | ( | GLint | location,
 |  | GLint | v0
 | ) | [friend]

Replacement of glUniform1i.

This function asserts on the result before returning.

NVSG_API void GLUniform1iv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLint * | value
 | ) | [friend]

Replacement of glUniform1iv.

This function asserts on the result before returning.

NVSG_API void GLUniform1ui | ( | GLint | location,
 |  | GLuint | v0
 | ) | [friend]

Replacement of glUniform1uiEXT.

This function asserts on the result before returning.

NVSG_API void GLUniform1uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) | [friend]

Replacement of glUniform1uivEXT.

This function asserts on the result before returning.

NVSG_API void GLUniform2f | ( | GLint | location,
 |  | GLfloat | v0,
 |  | GLfloat | v1
 | ) | [friend]

Replacement of glUniform2f.

This function asserts on the result before returning.

NVSG_API void GLUniform2fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniform2fv.

This function asserts on the result before returning.

NVSG_API void GLUniform2i | ( | GLint | location,
 |  | GLint | v0,
 |  | GLint | v1
 | ) | [friend]

Replacement of glUniform2i.

This function asserts on the result before returning.

NVSG_API void GLUniform2iv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLint * | value
 | ) | [friend]

Replacement of glUniform2iv.

This function asserts on the result before returning.

NVSG_API void GLUniform2ui | ( | GLint | location,
 |  | GLuint | v0,
 |  | GLuint | v1
 | ) | [friend]

Replacement of glUniform2ui.

This function asserts on the result before returning.

NVSG_API void GLUniform2uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) | [friend]

Replacement of glUniform2uiv.

This function asserts on the result before returning.

NVSG_API void GLUniform3f | ( | GLint | location,
 |  | GLfloat | v0,
 |  | GLfloat | v1,
 |  | GLfloat | v2
 | ) | [friend]

Replacement of glUniform3f.

This function asserts on the result before returning.

NVSG_API void GLUniform3fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniform3fv.

This function asserts on the result before returning.

NVSG_API void GLUniform3i | ( | GLint | location,
 |  | GLint | v0,
 |  | GLint | v1,
 |  | GLint | v2
 | ) | [friend]

Replacement of glUniform3i.

This function asserts on the result before returning.

NVSG_API void GLUniform3iv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLint * | value
 | ) | [friend]

Replacement of glUniform3iv.

This function asserts on the result before returning.

NVSG_API void GLUniform3ui | ( | GLint | location,
 |  | GLuint | v0,
 |  | GLuint | v1,
 |  | GLuint | v2
 | ) | [friend]

Replacement of glUniform3ui.

This function asserts on the result before returning.

NVSG_API void GLUniform3uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) | [friend]

Replacement of glUniform3uiv.

This function asserts on the result before returning.

NVSG_API void GLUniform4f | ( | GLint | location,
 |  | GLfloat | v0,
 |  | GLfloat | v1,
 |  | GLfloat | v2,
 |  | GLfloat | v3
 | ) | [friend]

Replacement of glUniform4f.

This function asserts on the result before returning.

NVSG_API void GLUniform4fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniform4fv.

This function asserts on the result before returning.

NVSG_API void GLUniform4i | ( | GLint | location,
 |  | GLint | v0,
 |  | GLint | v1,
 |  | GLint | v2,
 |  | GLint | v3
 | ) | [friend]

Replacement of glUniform4i.

This function asserts on the result before returning.

NVSG_API void GLUniform4iv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLint * | value
 | ) | [friend]

Replacement of glUniform4iv.

This function asserts on the result before returning.

NVSG_API void GLUniform4ui | ( | GLint | location,
 |  | GLuint | v0,
 |  | GLuint | v1,
 |  | GLuint | v2,
 |  | GLuint | v3
 | ) | [friend]

Replacement of glUniform4ui.

This function asserts on the result before returning.

NVSG_API void GLUniform4uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) | [friend]

Replacement of glUniform4uiv.

This function asserts on the result before returning.

NVSG_API void GLUniformBuffer | ( | GLuint | program,
 |  | GLint | location,
 |  | GLuint | buffer
 | ) | [friend]

Replacement of glUniformBufferEXT.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix2fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix2fv.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix2x3fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix2x3fv.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix2x4fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix2x4fv.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix3fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix3fv.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix3x2fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix3x2fv.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix3x4fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix3x4fv.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix4fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix4fv.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix4x2fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix4x2fv.

This function asserts on the result before returning.

NVSG_API void GLUniformMatrix4x3fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [friend]

Replacement of glUniformMatrix4x3fv.

This function asserts on the result before returning.

NVSG_API GLboolean GLUnmapBuffer ( GLenum target ) [friend]

Replacement of glUnmapBuffer.

This function asserts on the result before returning.

NVSG_API void GLUseProgram ( GLuint program ) [friend]

Replacement of glUseProgram.

This function asserts on the result before returning.

NVSG_API void GLUseProgramObject ( GLhandleARB programObj ) [friend]

Replacement of glUseProgramObjectARB.

This function asserts on the result before returning.

NVSG_API GLboolean GLValidBackBufferHint | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glValidBackBufferHintAutodesk.

NVSG_API void GLValidateProgram ( GLuint program ) [friend]

Replacement of glValidateProgram.

This function asserts on the result before returning.

NVSG_API void GLVertex2d | ( | GLdouble | x,
 |  | GLdouble | y
 | ) | [friend]

Replacement of glVertex2d.

This function asserts on the result before returning.

NVSG_API void GLVertex2dv ( const GLdouble * v ) [friend]

Replacement of glVertex2dv.

This function asserts on the result before returning.

NVSG_API void GLVertex2f | ( | GLfloat | x,
 |  | GLfloat | y
 | ) | [friend]

Replacement of glVertex2f.

This function asserts on the result before returning.

NVSG_API void GLVertex2fv ( const GLfloat * v ) [friend]

Replacement of glVertex2fv.

This function asserts on the result before returning.

NVSG_API void GLVertex2h | ( | GLhalf | x,
 |  | GLhalf | y
 | ) | [friend]

Replacement of glVertex2hNV.

This function asserts on the result before returning.

NVSG_API void GLVertex2hv ( const GLhalf * v ) [friend]

Replacement of glVertex2hv.

This function asserts on the result before returning.

NVSG_API void GLVertex2i | ( | GLint | x,
 |  | GLint | y
 | ) | [friend]

Replacement of glVertex2i.

This function asserts on the result before returning.

NVSG_API void GLVertex2iv ( const GLint * v ) [friend]

Replacement of glVertex2iv.

This function asserts on the result before returning.

NVSG_API void GLVertex2s | ( | GLshort | x,
 |  | GLshort | y
 | ) | [friend]

Replacement of glVertex2s.

This function asserts on the result before returning.

NVSG_API void GLVertex2sv ( const GLshort * v ) [friend]

Replacement of glVertex2sv.

This function asserts on the result before returning.

NVSG_API void GLVertex3d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [friend]

Replacement of glVertex3d.

This function asserts on the result before returning.

NVSG_API void GLVertex3dv ( const GLdouble * v ) [friend]

Replacement of glVertex3dv.

This function asserts on the result before returning.

NVSG_API void GLVertex3f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [friend]

Replacement of glVertex3f.

This function asserts on the result before returning.

NVSG_API void GLVertex3fv ( const GLfloat * v ) [friend]

Replacement of glVertex3fv.

This function asserts on the result before returning.

NVSG_API void GLVertex3h | ( | GLhalf | x,
 |  | GLhalf | y,
 |  | GLhalf | z
 | ) | [friend]

Replacement of glVertex3hNV.

This function asserts on the result before returning.

NVSG_API void GLVertex3hv ( const GLhalf * v ) [friend]

Replacement of glVertex3hv.

This function asserts on the result before returning.

NVSG_API void GLVertex3i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [friend]

Replacement of glVertex3i.

This function asserts on the result before returning.

NVSG_API void GLVertex3iv ( const GLint * v ) [friend]

Replacement of glVertex3iv.

This function asserts on the result before returning.

NVSG_API void GLVertex3s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z
 | ) | [friend]

Replacement of glVertex3s.

This function asserts on the result before returning.

NVSG_API void GLVertex3sv ( const GLshort * v ) [friend]

Replacement of glVertex3sv.

This function asserts on the result before returning.

NVSG_API void GLVertex4d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [friend]

Replacement of glVertex4d.

This function asserts on the result before returning.

NVSG_API void GLVertex4dv ( const GLdouble * v ) [friend]

Replacement of glVertex4dv.

This function asserts on the result before returning.

NVSG_API void GLVertex4f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [friend]

Replacement of glVertex4f.

This function asserts on the result before returning.

NVSG_API void GLVertex4fv ( const GLfloat * v ) [friend]

Replacement of glVertex4fv.

This function asserts on the result before returning.

NVSG_API void GLVertex4h | ( | GLhalf | x,
 |  | GLhalf | y,
 |  | GLhalf | z,
 |  | GLhalf | w
 | ) | [friend]

Replacement of glVertex4hNV.

This function asserts on the result before returning.

NVSG_API void GLVertex4hv ( const GLhalf * v ) [friend]

Replacement of glVertex4hv.

This function asserts on the result before returning.

NVSG_API void GLVertex4i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [friend]

Replacement of glVertex4i.

This function asserts on the result before returning.

NVSG_API void GLVertex4iv ( const GLint * v ) [friend]

Replacement of glVertex4iv.

This function asserts on the result before returning.

NVSG_API void GLVertex4s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z,
 |  | GLshort | w
 | ) | [friend]

Replacement of glVertex4s.

This function asserts on the result before returning.

NVSG_API void GLVertex4sv ( const GLshort * v ) [friend]

Replacement of glVertex4sv.

This function asserts on the result before returning.

NVSG_API void GLVertexArrayRange | ( | GLsizei | size,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glVertexArrayRange.

This function asserts on the result before returning.

NVSG_API void GLVertexAttrib1d | ( | GLuint | index,
 |  | GLdouble | x
 | ) | [friend]

Replacement of glVertexAttrib1d.

NVSG_API void GLVertexAttrib1dv | ( | GLuint | index,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glVertexAttrib1dv.

NVSG_API void GLVertexAttrib1f | ( | GLuint | index,
 |  | GLfloat | x
 | ) | [friend]

Replacement of glVertexAttrib1f.

NVSG_API void GLVertexAttrib1fv | ( | GLuint | index,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glVertexAttrib1fv.

NVSG_API void GLVertexAttrib1h | ( | GLuint | index,
 |  | GLhalf | x
 | ) | [friend]

Replacement of glVertexAttrib1h.

NVSG_API void GLVertexAttrib1hv | ( | GLuint | index,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glVertexAttrib1nv.

NVSG_API void GLVertexAttrib1s | ( | GLuint | index,
 |  | GLshort | x
 | ) | [friend]

Replacement of glVertexAttrib1s.

NVSG_API void GLVertexAttrib1sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttrib1sv.

NVSG_API void GLVertexAttrib2d | ( | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y
 | ) | [friend]

Replacement of glVertexAttrib2d.

NVSG_API void GLVertexAttrib2dv | ( | GLuint | index,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glVertexAttrib2dv.

NVSG_API void GLVertexAttrib2f | ( | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y
 | ) | [friend]

Replacement of glVertexAttrib2f.

NVSG_API void GLVertexAttrib2fv | ( | GLuint | index,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glVertexAttrib2fv.

NVSG_API void GLVertexAttrib2h | ( | GLuint | index,
 |  | GLhalf | x,
 |  | GLhalf | y
 | ) | [friend]

Replacement of glVertexAttrib2h.

NVSG_API void GLVertexAttrib2hv | ( | GLuint | index,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glVertexAttrib2hv.

NVSG_API void GLVertexAttrib2s | ( | GLuint | index,
 |  | GLshort | x,
 |  | GLshort | y
 | ) | [friend]

Replacement of glVertexAttrib2s.

NVSG_API void GLVertexAttrib2sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttrib2sv.

NVSG_API void GLVertexAttrib3d | ( | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [friend]

Replacement of glVertexAttrib3d.

NVSG_API void GLVertexAttrib3dv | ( | GLuint | index,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glVertexAttrib3dv.

NVSG_API void GLVertexAttrib3f | ( | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [friend]

Replacement of glVertexAttrib3f.

NVSG_API void GLVertexAttrib3fv | ( | GLuint | index,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glVertexAttrib3fv.

NVSG_API void GLVertexAttrib3h | ( | GLuint | index,
 |  | GLhalf | x,
 |  | GLhalf | y,
 |  | GLhalf | z
 | ) | [friend]

Replacement of glVertexAttrib3h.

NVSG_API void GLVertexAttrib3hv | ( | GLuint | index,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glVertexAttrib3hv.

NVSG_API void GLVertexAttrib3s | ( | GLuint | index,
 |  | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z
 | ) | [friend]

Replacement of glVertexAttrib3s.

NVSG_API void GLVertexAttrib3sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttrib3sv.

NVSG_API void GLVertexAttrib4bv | ( | GLuint | index,
 |  | const GLbyte * | v
 | ) | [friend]

Replacement of glVertexAttrib3bv.

NVSG_API void GLVertexAttrib4d | ( | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [friend]

Replacement of glVertexAttrib4d.

NVSG_API void GLVertexAttrib4dv | ( | GLuint | index,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glVertexAttrib4dv.

NVSG_API void GLVertexAttrib4f | ( | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [friend]

Replacement of glVertexAttrib4f.

NVSG_API void GLVertexAttrib4fv | ( | GLuint | index,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glVertexAttrib4fv.

NVSG_API void GLVertexAttrib4h | ( | GLuint | index,
 |  | GLhalf | x,
 |  | GLhalf | y,
 |  | GLhalf | z,
 |  | GLhalf | w
 | ) | [friend]

Replacement of glVertexAttrib4h.

NVSG_API void GLVertexAttrib4hv | ( | GLuint | index,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glVertexAttrib4hv.

NVSG_API void GLVertexAttrib4iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glVertexAttrib4iv.

NVSG_API void GLVertexAttrib4s | ( | GLuint | index,
 |  | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z,
 |  | GLshort | w
 | ) | [friend]

Replacement of glVertexAttrib4s.

NVSG_API void GLVertexAttrib4sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttrib4sv.

NVSG_API void GLVertexAttrib4ub | ( | GLuint | index,
 |  | GLubyte | x,
 |  | GLubyte | y,
 |  | GLubyte | z,
 |  | GLubyte | w
 | ) | [friend]

Replacement of glVertexAttrib4ub.

NVSG_API void GLVertexAttrib4ubv | ( | GLuint | index,
 |  | const GLubyte * | v
 | ) | [friend]

Replacement of glVertexAttrib4ubv.

NVSG_API void GLVertexAttrib4uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [friend]

Replacement of glVertexAttrib4uiv.

NVSG_API void GLVertexAttrib4usv | ( | GLuint | index,
 |  | const GLushort * | v
 | ) | [friend]

Replacement of glVertexAttrib4usv.

NVSG_API void GLVertexAttrib4Nbv | ( | GLuint | index,
 |  | const GLbyte * | v
 | ) | [friend]

Replacement of glVertexAttrib4Nbv.

NVSG_API void GLVertexAttrib4Niv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glVertexAttrib4Niv.

NVSG_API void GLVertexAttrib4Nsv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttrib4Nsv.

NVSG_API void GLVertexAttrib4Nub | ( | GLuint | index,
 |  | GLubyte | x,
 |  | GLubyte | y,
 |  | GLubyte | z,
 |  | GLubyte | w
 | ) | [friend]

Replacement of glVertexAttrib4Nub.

NVSG_API void GLVertexAttrib4Nubv | ( | GLuint | index,
 |  | const GLubyte * | v
 | ) | [friend]

Replacement of glVertexAttrib4Nubv.

NVSG_API void GLVertexAttrib4Nuiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [friend]

Replacement of glVertexAttrib4Nuiv.

NVSG_API void GLVertexAttrib4Nusv | ( | GLuint | index,
 |  | const GLushort * | v
 | ) | [friend]

Replacement of glVertexAttrib4Nusv.

NVSG_API void GLVertexAttribI1i | ( | GLuint | index,
 |  | GLint | x
 | ) | [friend]

Replacement of glVertexAttribI1iEXT.

NVSG_API void GLVertexAttribI1iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glVertexAttribI1ivEXT.

NVSG_API void GLVertexAttribI1ui | ( | GLuint | index,
 |  | GLuint | x
 | ) | [friend]

Replacement of glVertexAttribI1uiExt.

NVSG_API void GLVertexAttribI1uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [friend]

Replacement of glVertexAttribI1iuvEXT.

NVSG_API void GLVertexAttribI2i | ( | GLuint | index,
 |  | GLint | x,
 |  | GLint | y
 | ) | [friend]

Replacement of glVertexAttribI2iEXT.

NVSG_API void GLVertexAttribI2iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glVertexAttribI2ivEXT.

NVSG_API void GLVertexAttribI2ui | ( | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y
 | ) | [friend]

Replacement of glVertexAttribI2uiExt.

NVSG_API void GLVertexAttribI2uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [friend]

Replacement of glVertexAttribI2uivEXT.

NVSG_API void GLVertexAttribI3i | ( | GLuint | index,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [friend]

Replacement of glVertexAttribI3iEXT.

NVSG_API void GLVertexAttribI3iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glVertexAttribI3ivEXT.

NVSG_API void GLVertexAttribI3ui | ( | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y,
 |  | GLuint | z
 | ) | [friend]

Replacement of glVertexAttribI3uiExt.

NVSG_API void GLVertexAttribI3uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [friend]

Replacement of glVertexAttribI3uivEXT.

NVSG_API void GLVertexAttribI4bv | ( | GLuint | index,
 |  | const GLbyte * | v
 | ) | [friend]

Replacement of glVertexAttribI4bvEXT.

NVSG_API void GLVertexAttribI4i | ( | GLuint | index,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [friend]

Replacement of glVertexAttribI4iEXT.

NVSG_API void GLVertexAttribI4iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [friend]

Replacement of glVertexAttribI4ivEXT.

NVSG_API void GLVertexAttribI4sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttribI4svEXT.

NVSG_API void GLVertexAttribI4ubv | ( | GLuint | index,
 |  | const GLubyte * | v
 | ) | [friend]

Replacement of glVertexAttribI4ubvEXT.

NVSG_API void GLVertexAttribI4ui | ( | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y,
 |  | GLuint | z,
 |  | GLuint | w
 | ) | [friend]

Replacement of glVertexAttribI4uiExt.

NVSG_API void GLVertexAttribI4uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [friend]

Replacement of glVertexAttribI4uivEXT.

NVSG_API void GLVertexAttribI4usv | ( | GLuint | index,
 |  | const GLushort * | v
 | ) | [friend]

Replacement of glVertexAttribI4usvEXT.

NVSG_API void GLVertexAttribIPointer | ( | GLuint | index,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glVertexAttribIPointerEXT.

NVSG_API void GLVertexAttribPointer | ( | GLuint | index,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLboolean | normalize,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glVertexAttribPointer.

NVSG_API void GLVertexAttribPointerNV | ( | GLuint | index,
 |  | GLint | fsize,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glVertexAttribPointerNV.

NVSG_API void GLVertexAttribs1dvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glVertexAttribs1dvNV.

NVSG_API void GLVertexAttribs1fvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glVertexAttribs1fvNV.

NVSG_API void GLVertexAttribs1hv | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glVertexAttribs1hv.

NVSG_API void GLVertexAttribs1svNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttribs1svNV.

NVSG_API void GLVertexAttribs2dvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glVertexAttribs2dvNV.

NVSG_API void GLVertexAttribs2fvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glVertexAttribs2fvNV.

NVSG_API void GLVertexAttribs2hv | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glVertexAttribs2hv.

NVSG_API void GLVertexAttribs2svNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttribs2svNV.

NVSG_API void GLVertexAttribs3dvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glVertexAttribs3dvNV.

NVSG_API void GLVertexAttribs3fvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glVertexAttribs3fvNV.

NVSG_API void GLVertexAttribs3hv | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glVertexAttribs3hv.

NVSG_API void GLVertexAttribs3svNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttribs3svNV.

NVSG_API void GLVertexAttribs4dvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [friend]

Replacement of glVertexAttribs4dvNV.

NVSG_API void GLVertexAttribs4fvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [friend]

Replacement of glVertexAttribs4fvNV.

NVSG_API void GLVertexAttribs4hv | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLhalf * | v
 | ) | [friend]

Replacement of glVertexAttribs4hv.

NVSG_API void GLVertexAttribs4svNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLshort * | v
 | ) | [friend]

Replacement of glVertexAttribs4svNV.

NVSG_API void GLVertexAttribs4ubvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLubyte * | v
 | ) | [friend]

Replacement of glVertexAttribs4svNV.

NVSG_API void GLVertexPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [friend]

Replacement of glVertexPointer.

This function caches the vertex pointer setting and asserts on the result before returning.

NVSG_API void GLViewport | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glViewport.

This function asserts on the result before returning.

NVSG_API void GLWindowBackBufferHint ( ) [friend]

Replacement of glWindowBackBufferHintAutodesk.

NVSG_API void GLWindowPos2d | ( | GLdouble | x,
 |  | GLdouble | y
 | ) | [friend]

Replacement of glWindowPos2d.

This function asserts on the result before returning.

NVSG_API void GLWindowPos2dv ( const GLdouble * p ) [friend]

Replacement of glWindowPos2dv.

This function asserts on the result before returning.

NVSG_API void GLWindowPos2f | ( | GLfloat | x,
 |  | GLfloat | y
 | ) | [friend]

Replacement of glWindowPos2f.

This function asserts on the result before returning.

NVSG_API void GLWindowPos2fv ( const GLfloat * p ) [friend]

Replacement of glWindowPos2fv.

This function asserts on the result before returning.

NVSG_API void GLWindowPos2i | ( | GLint | x,
 |  | GLint | y
 | ) | [friend]

Replacement of glWindowPos2i.

This function asserts on the result before returning.

NVSG_API void GLWindowPos2iv ( const GLint * p ) [friend]

Replacement of glWindowPos2iv.

This function asserts on the result before returning.

NVSG_API void GLWindowPos2s | ( | GLshort | x,
 |  | GLshort | y
 | ) | [friend]

Replacement of glWindowPos2s.

This function asserts on the result before returning.

NVSG_API void GLWindowPos2sv ( const GLshort * p ) [friend]

Replacement of glWindowPos2sv.

This function asserts on the result before returning.

NVSG_API void GLWindowPos3d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [friend]

Replacement of glWindowPos3d.

This function asserts on the result before returning.

NVSG_API void GLWindowPos3dv ( const GLdouble * p ) [friend]

Replacement of glWindowPos3dv.

This function asserts on the result before returning.

NVSG_API void GLWindowPos3f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [friend]

Replacement of glWindowPos3f.

This function asserts on the result before returning.

NVSG_API void GLWindowPos3fv ( const GLfloat * p ) [friend]

Replacement of glWindowPos3fv.

This function asserts on the result before returning.

NVSG_API void GLWindowPos3i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [friend]

Replacement of glWindowPos3i.

This function asserts on the result before returning.

NVSG_API void GLWindowPos3iv ( const GLint * p ) [friend]

Replacement of glWindowPos3iv.

This function asserts on the result before returning.

NVSG_API void GLWindowPos3s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z
 | ) | [friend]

Replacement of glWindowPos3s.

This function asserts on the result before returning.

NVSG_API void GLWindowPos3sv ( const GLshort * p ) [friend]

Replacement of glWindowPos3sv.

This function asserts on the result before returning.

NVSG_API GLboolean GLIsRenderbuffer ( GLuint renderbuffer ) [friend]

Replacement of glIsRenderbufferEXT.

Parameters:
renderbuffer The id to test.
Returns:
TRUE, if renderbuffer is the id of a render buffer, otherwise FALSE.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLRenderbufferStorage, GLGetRenderbufferParameteriv

NVSG_API void GLBindRenderbuffer | ( | GLenum | target,
 |  | GLuint | renderbuffer
 | ) | [friend]

Replacement of glBindRenderbufferEXT.

Parameters:
target | The id of the target to bind the render buffer to. Must be GL_RENDERBUFFER_EXT.
renderbuffer | The id of the unused render buffer to bind.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLRenderbufferStorage, GLGetRenderbufferParameteriv

NVSG_API void GLDeleteRenderbuffers | ( | GLsizei | n,
 |  | const GLuint * | renderbuffers
 | ) | [friend]

Replacement of glDeleteRenderbuffersEXT.

Parameters:
n | The number of render buffer ids to delete.
renderbuffers | A pointer to the render buffer ids to delete.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLGenRenderbuffers, GLRenderbufferStorage, GLGetRenderbufferParameteriv

NVSG_API void GLGenRenderbuffers | ( | GLsizei | n,
 |  | GLuint * | renderbuffers
 | ) | [friend]

Replacement of glGenRenderbuffersEXT.

Parameters:
n | The number of render buffer ids to generate.
renderbuffers | A pointer to the memory to fill with the generated render buffer ids.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLRenderbufferStorage, GLGetRenderbufferParameteriv

NVSG_API void GLRenderbufferStorage | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glRenderbufferStorageEXT.

Parameters:
target | Must be GL_RENDERBUFFER_EXT.
internalformat | Must be color-renderable, depth-renderable, or stencil-renderable.
width | The width of the render buffer in pixels.
height | The height of the render buffer in pixels.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLGetRenderbufferParameteriv

NVSG_API void GLRenderbufferStorageMultisample | ( | GLenum | target,
 |  | GLsizei | samples,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glRenderbufferStorageMultisampleEXT.

Parameters:
target | Must be GL_RENDERBUFFER_EXT.
samples | Is the number of multisample buffers you wish to allocate.
internalformat | Must be color-renderable, depth-renderable, or stencil-renderable.
width | The width of the render buffer in pixels.
height | The height of the render buffer in pixels.
Note:
It is assumed that the extension GL_EXT_framebuffer_multisample is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLGetRenderbufferParameteriv, GLRenderbufferStorage, GLRenderbufferStorageMultisampleCoverage

NVSG_API void GLRenderbufferStorageMultisampleCoverage | ( | GLenum | target,
 |  | GLsizei | coverage,
 |  | GLsizei | samples,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [friend]

Replacement of glRenderbufferStorageMultisampleCoverageNV.

Parameters:
target | Must be GL_RENDERBUFFER_EXT.
coverageSamples | Is the number of pseudo multisample buffers to allocate.
colorSamples | Is the number of multisample buffers to allocate.
internalformat | Must be color-renderable, depth-renderable, or stencil-renderable.
width | The width of the render buffer in pixels.
height | The height of the render buffer in pixels.
Note:
It is assumed that the extension GL_NV_framebuffer_multisample_coverage is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLGetRenderbufferParameteriv, GLRenderbufferStorage, GLRenderbufferStorageMultisampleCoverage

NVSG_API void GLGetRenderbufferParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetRenderbufferParameterivEXT.

Parameters:
target | Must be GL_RENDERBUFFER_EXT.
pname | The id of the value to get.
params | Pointer to the memory to write the queried value to.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLRenderbufferStorage

NVSG_API GLboolean GLIsFramebuffer ( GLuint framebuffer ) [friend]

Replacement of glIsFramebufferEXT.

Parameters:
framebuffer The id to test.
Returns:
TRUE, if framebuffer is the id of a frame buffer, otherwise FALSE.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLBindFramebuffer | ( | GLenum | target,
 |  | GLuint | framebuffer
 | ) | [friend]

Replacement of glBindFramebufferEXT.

Parameters:
target | The id of the target to bind the frame buffer to. Must be GL_FRAMEBUFFER_EXT.
framebuffer | The id of the unused frame buffer to bind.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLDeleteFramebuffers | ( | GLsizei | n,
 |  | const GLuint * | framebuffers
 | ) | [friend]

Replacement of glDeleteFramebuffersEXT.

Parameters:
n | The number of frame buffer ids to delete.
framebuffers | A pointer to the frame buffer ids to delete.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLGenFramebuffers | ( | GLsizei | n,
 |  | GLuint * | framebuffers
 | ) | [friend]

Replacement of glGenFramebuffersEXT.

Parameters:
n | The number of frame buffer ids to generate.
framebuffers | A pointer to the memory to fill with the generated frame buffer ids.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API GLenum GLCheckFramebufferStatus ( GLenum target ) [friend]

Replacement of glCheckFramebufferStatusEXT.

Parameters:
target Must be GL_FRAMEBUFFER_EXT.
Returns:
A symbolic value describing the frame buffer status.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLFramebufferTexture1D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level
 | ) | [friend]

Replacement of glFramebufferTexture1DEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
textarget | The texture target.
texture | The id of an existing texture with an target of textarget.
level | The mipmap level of the texture image to be attached.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferTextureLayer GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLFramebufferTexture2D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level
 | ) | [friend]

Replacement of glFramebufferTexture2DEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
textarget | The texture target.
texture | The id of an existing texture with an target of textarget.
level | The mipmap level of the texture image to be attached.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture3D, GLFramebufferTextureLayer GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLFramebufferTexture3D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLint | zoffset
 | ) | [friend]

Replacement of glFramebufferTexture3DEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
textarget | The texture target.
texture | The id of an existing texture with an target of textarget.
level | The mipmap level of the texture image to be attached.
zoffset | Specifies the z-offset of a 2-dimensional image within a 3-dimensional texture.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTextureLayer GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLFramebufferTextureLayer | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLint | layer
 | ) | [friend]

Replacement of glFramebufferTextureLayerEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
texture | The id of an existing texture.
level | The mipmap level of the texture image to be attached.
layer | Specifies the layer/slice of the texture array - or slice of 3D texture.
Note:
It is assumed that the extension GL_EXT_texture_array is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLFramebufferRenderbuffer | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | renderbuffertarget,
 |  | GLuint | renderbuffer
 | ) | [friend]

Replacement of glFramebufferRenderbufferEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
renderbuffertarget | Must be GL_RENDERBUFFER_EXT.
renderbuffer | The id of the render buffer to be attached to the frame buffer.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLGetFramebufferAttachmentParameteriv

NVSG_API void GLGetFramebufferAttachmentParameteriv | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetFramebufferAttachmentParameterivEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
pname | The symbolic values of the attachment parameters to query.
params | A pointer to the memory where result of the query is written to.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer

NVSG_API void GLGenerateMipmap ( GLenum target ) [friend]

Replacement of glGenerateMipmapEXT.

Parameters:
target The symbolic value of the texture target to generate mipmaps for.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

NVSG_API BOOL WGLBindTexImage | ( | HPBUFFERARB | hPbuffer,
 |  | int | iBuffer
 | ) | [friend]

Replacement of wglBindTexImageARB.

This function hides the extension character of wglBindTexImageARB and asserts on its result before returning.

NVSG_API BOOL WGLChoosePixelFormat | ( | HDC | hdc,
 |  | const int * | piAttribIList,
 |  | const FLOAT * | pfAttribFList,
 |  | UINT | nMaxFormats,
 |  | int * | piFormats,
 |  | UINT * | nNumFormats
 | ) | [friend]

Replacement of wglChoosePixelFormatARB.

This function hides the extension character of wglChoosePixelFormatARB and asserts on its result before returning.

NVSG_API HGLRC WGLCreateContext ( HDC hdc ) [friend]

Replacement of wglCreateContext.

If this function is used in conjunction with WGLCreateContext, WGLMakeCurrent, and the functions with uppercase GL prefix, then the states and attributes are cached per context. Moreover, the extension functions of OpenGL are used per context (as they really should!).

NVSG_API HPBUFFERARB WGLCreatePbuffer | ( | HDC | hdc,
 |  | int | pixelFormat,
 |  | int | width,
 |  | int | height,
 |  | const int * | attribList
 | ) | [friend]

Replacement of wglCreatePbufferARB.

This function hides the extension character of wglCreatePbufferARB.

Note:
The creation of a PBuffer might fail dependent on available hardware resources. In this case a NULL handle will be returned.

NVSG_API BOOL WGLDeleteContext ( HGLRC hglrc ) [friend]

Replacement of wglDeleteContext.

If this function is used in conjunction with WGLDeleteContext, WGLMakeCurrent, and functions with uppercase 'GL' prefix, the states and attributes are cached per context. Moreover, OpenGL extension functions are used per context (as they really should!).

NVSG_API BOOL WGLDestroyPbuffer ( HPBUFFERARB hPbuffer ) [friend]

Replacement of wglDestroyPbufferARB.

This function hides the extension character of wglDestroyPbufferARB and asserts on its result before returning.

NVSG_API HGLRC WGLGetCurrentContext ( void ) [friend]

Replacement for wglGetCurrenContext.

The function obtains a handle to the current OpenGL rendering context of the calling thread.

Returns:
A handle to the current OpenGL context of the calling thread, or NULL if the calling thread has no current OpenGL context.

NVSG_API HDC WGLGetCurrentDC ( void ) [friend]

Replacement for wglGetCurrentDC.

The function obtains a handle to the device context that is associated with the current OpenGL rendering context of the calling thread.

Returns:
A handle to the device context which is currently associated with the current OpenGL context of the calling thread by means of WGLMakeCurrent, or NULL if the calling thread has no current OpenGL context.

NVSG_API HDC WGLGetPbufferDC ( HPBUFFERARB hPbuffer ) [friend]

Replacement of wglGetPbufferDCARB.

This function hides the extension character of wglGetPbufferDCARB and asserts on its result before returning.

NVSG_API BOOL WGLQueryPbuffer | ( | HPBUFFERARB | hPbuffer,
 |  | int | attribute,
 |  | int * | value
 | ) | [friend]

Replacement of wglQueryPbufferARB.

This function hides the extension character of wglQueryPbufferARB and asserts on its result before returning.

NVSG_API int WGLReleasePbufferDC | ( | HPBUFFERARB | hPbuffer,
 |  | HDC | hdc
 | ) | [friend]

Replacement of wglReleasePbufferDCARB.

This function hides the extension character of wglReleasePbufferDCARB and asserts on its result before returning.

NVSG_API BOOL WGLReleaseTexImage | ( | HPBUFFERARB | hPbuffer,
 |  | int | iBuffer
 | ) | [friend]

Replacement of wglReleaseTexImageARB.

This function hides the extension character of wglReleaseTexImageARB and asserts on its result before returning.

NVSG_API BOOL WGLJoinSwapGroupNV | ( | HDC | hDC,
 |  | GLuint | group
 | ) | [friend]

Replacement of wglJointSwapGroupNV.

NVSG_API BOOL WGLBindSwapBarrierNV | ( | GLuint | group,
 |  | GLuint | barrier
 | ) | [friend]

Replacement of wglBindSwapBarrierNV.

NVSG_API BOOL WGLQuerySwapGroupNV | ( | HDC | hDC,
 |  | GLuint * | group,
 |  | GLuint * | barrier
 | ) | [friend]

Replacement of wglQuerySwapGroupNV.

NVSG_API BOOL WGLQueryMaxSwapGroupsNV | ( | HDC | hDC,
 |  | GLuint * | maxGroups,
 |  | GLuint * | maxBarriers
 | ) | [friend]

Replacement of wglQueryMaxSwapGroupsNV.

NVSG_API BOOL WGLQueryFrameCountNV | ( | HDC | hDC,
 |  | GLuint * | count
 | ) | [friend]

Replacement of wglQueryFrameCountNV.

NVSG_API BOOL WGLResetFrameCountNV ( HDC hDC ) [friend]

Replacement of wglResetFrameCountNV.

NVSG_API BOOL WGLEnumGpus | ( | UINT | iIndex,
 |  | HGPUNV * | hGpu
 | ) | [friend]

Replacement of wglEnumGpusNV.

NVSG_API BOOL WGLEnumGpuDevices | ( | HGPUNV | hGpu,
 |  | UINT | iIndex,
 |  | PGPU_DEVICE | pGpuDevice
 | ) | [friend]

Replacement of wglEnumGpuDevicesNV.

NVSG_API HDC WGLCreateAffinityDC ( const HGPUNV * pGpuList ) [friend]

Replacement for wglCreateAffinityDVNV.

NVSG_API BOOL WGLEnumGpusFromAffinityDC | ( | HDC | hAffinityDC,
 |  | UINT | iIndex,
 |  | HGPUNV * | hGpu
 | ) | [friend]

Replacement for wglEnumGpusFromAffinityDCNV.

NVSG_API BOOL WGLDeleteDC ( HDC hAffinityDC ) [friend]

Replacement for wglDeleteDCNV.

NVSG_API GLXContext GLXCreateContext | ( | Display * | dpy,
 |  | XVisualInfo * | vis,
 |  | GLXContext | shareList,
 |  | Bool | direct
 | ) | [friend]

Replacement of glXCreateContext.

NVSG_API void GLXDestroyContext | ( | Display * | dpy,
 |  | GLXContext | ctx
 | ) | [friend]

Replacement of glXDestroyContext.

NVSG_API GLXContext GLXGetCurrentContext ( ) [friend]

Replacement of glXGetCurrentContext.

NVSG_API GLXDrawable GLXGetCurrentDrawable ( ) [friend]

Replacement of glXGetCurrentDrawable.

NVSG_API void GLResetAlphaFunc ( ) [friend]

Helper function to reset alpha function and alpha reference value.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this functions sets the alpha function and alpha reference value to the previous function and value. Otherwise, the alpha function is set to GL_ALWAYS, and the alpha reference value is set to zero.
See also:
GLAlphaFunc

NVSG_API void GLResetAlphaTest ( ) [friend]

Helper function to reset the enable state of the alpha test.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the alpha test state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableAlphaTest, GLEnableAlphaTest, GLDisable, GLEnable

NVSG_API void GLResetAutoNormal ( ) [friend]

Helper function to reset the enable state of the auto normal calculation.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the auto normal state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableAutoNormal, GLEnableAutoNormal, GLDisable, GLEnable

NVSG_API void GLResetBlend ( ) [friend]

Helper function to reset the enable state of the blending.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the blending state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableBlend, GLEnableBlend, GLDisable, GLEnable

NVSG_API void GLResetBlendFunc ( ) [friend]

Helper function to reset the blend function.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this functions sets the blend function to the previous function. Otherwise, the blend function is set to GL_ONE for the source factor and GL_ZERO for the destination factor.
See also:
GLBlendFunc, GLBlendFuncSeparate

NVSG_API void GLResetBlendFuncSeparate ( ) [friend]

Helper function to reset the blend function, using the GL_EXT_blend_func_separate extention.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this functions sets the four factors of the extended blend function the previous values. Otherwise, the blend function factors are set to GL_ONE, GL_ZERO, GL_ONE, and GL_ZERO, in this order.
See also:
GLBlendFuncSeparate

NVSG_API void GLResetClearColor ( ) [friend]

Helper function to reset the clear color.

Remarks:
if GL_SUPPORT_RESET is defined (per default, it is), this function sets the four values of the clear color to the previous value. Otherwise, they are all set to 0.0f.
See also:
GLClearColor

NVSG_API void GLResetClearDepth ( ) [friend]

Helper function to reset the clear depth.

Remarks:
if ( GL_SUPPORT_RESET is defined (per default, it is), this function sets the clear depth to the previous value. Otherwise, it is set to 1.0f.
See also:
GLClearDepth

NVSG_API void GLResetClearStencil ( ) [friend]

Helper function to reset the stencil clear value.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil clear value to the previous value. Otherwise, it is set to zero.
See also:
GLClearStencil

NVSG_API void GLResetClipPlane ( GLenum plane ) [friend]

Helper function to reset the enable state of the clip plane plane.

Parameters:
plane The id of the plane for which the the enable state is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the clip plane state for plane to it's previous state. Otherwise, it is disabled.
See also:
GLDisableClipPlane, GLEnableClipPlane, GLDisable, GLEnable

NVSG_API void GLResetClipPlaneEquation ( GLenum plane ) [friend]

Helper function to reset a clip plane equation.

Parameters:
plane The id of the clip plane for which the plane equation is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the clip plane equation of plane to the previous equations. Otherwise, it is set to the default plane (0,0,0,0).
See also:
GLClipPlane

NVSG_API void GLResetColorLogicOp ( ) [friend]

Helper function to reset the enable state of the color logic operation.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the color logic operation state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableColorLogicOp, GLEnableColorLogicOp, GLDisable, GLEnable

NVSG_API void GLResetColorMask ( ) [friend]

Helper function to reset the color mask.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the color mask to the previous mask. Otherwise, all four mask components are set to GL_TRUE.
See also:
GLColorMask

NVSG_API void GLResetColorMaterial ( ) [friend]

Helper function to reset the enable state of the color material.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the color material state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableColorMaterial, GLEnableColorMaterial, GLDisable, GLEnable

NVSG_API void GLResetColorMaterialMode ( ) [friend]

Helper function to reset the color material mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the color material mode to the previous mode. Otherwise, it is set to GL_AMBIENT_AND_DIFFUSE for GL_FRONT_AND_BACK faces.
See also:
GLColorMaterial

NVSG_API void GLResetCullFace ( ) [friend]

Helper function to reset the enable state of face culling.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the face culling state to it's previous state. Otherwise, it is enabled. Note, that this enabling face culling by default is NVSG specific and not like in OpenGL.
See also:
GLDisableCullFace, GLEnableCullFace, GLDisable, GLEnable

NVSG_API void GLResetCullFaceMode ( ) [friend]

Helper function to reset the cull face mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the cull face mode to the previous mode. Otherwise, it is set to GL_BACK.
See also:
GLCullFace

NVSG_API void GLResetDepthFunc ( ) [friend]

Helper function to reset the depth func.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the depth func to the previous value. Otherwise, it is set to GL_LESS.
See also:
GLDepthFunc

NVSG_API void GLResetDepthMask ( ) [friend]

Helper function to reset the depth mask.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the depth mask to the previous value. Otherwise, it is set to GL_TRUE.
See also:
GLDepthMask

NVSG_API void GLResetDepthRange ( ) [friend]

Helper function to reset the depth range.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the depth range to the previous values. Otherwise, it sets znear to 0.0 and zfar to 1.0.
See also:
GLDepthRange

NVSG_API void GLResetDepthTest ( ) [friend]

Helper function to reset the enable state of depth testing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the depth test state to it's previous state. Otherwise, it is enabled. Note, that this enabling depth test by default is NVSG specific and not like in OpenGL.
See also:
GLDisableDepthTest, GLEnableDepthTest, GLDisable, GLEnable

NVSG_API void GLResetDither ( ) [friend]

Helper function to reset the enable state of dithering.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the dither state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableDither, GLEnableDither, GLDisable, GLEnable

NVSG_API void GLResetFog ( ) [friend]

Helper function to reset the the enable state of fogging.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableFog, GLEnableFog, GLDisable, GLEnable

NVSG_API void GLResetFogColor ( ) [friend]

Helper function to reset the fog color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog color to it's previous state. Otherwise, it is set to (0,0,0,0).
See also:
GLFogColor

NVSG_API void GLResetFogDensity ( ) [friend]

Helper function to reset the fog density.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog density to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLFogDensity

NVSG_API void GLResetFogEnd ( ) [friend]

Helper function to reset the fog end value.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog end value to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLFogDensity

NVSG_API void GLResetFogMode ( ) [friend]

Helper function to reset the fog mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog mode to it's previous state. Otherwise, it is set to GL_EXP.
See also:
GLFogMode

NVSG_API void GLResetFogStart ( ) [friend]

Helper function to reset the fog start value.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog start value to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLFogStart

NVSG_API void GLResetFrontFace ( ) [friend]

Helper function to reset the front face state.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the front face state to it's previous state. Otherwise, it is set to GL_CCW.
See also:
GLFrontFace

NVSG_API void GLResetLight ( GLenum light ) [friend]

Helper function to reset the enable state of the light light.

Parameters:
light The id of the light for which the enable state is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the light state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLight, GLEnableLight, GLDisable, GLEnable

NVSG_API void GLResetLighting ( ) [friend]

Helper function to reset the enable state of lighting.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the lighting state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLighting, GLEnableLighting, GLDisable, GLEnable

NVSG_API void GLResetLightAmbient ( GLenum light ) [friend]

Helper function to reset the ambient light color.

Parameters:
light The id of the light for which the ambient color is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the ambient light to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLLightAmbient

NVSG_API void GLResetLightConstantAttenuation ( GLenum light ) [friend]

Helper function to reset the constant attenuation of the light light.

Parameters:
light The id of the light for which the constant attenuation is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the constant attenuation of the light light to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLLightConstantAttenuation

NVSG_API void GLResetLightDiffuse ( GLenum light ) [friend]

Helper function to reset the diffuse color of the light light.

Parameters:
light The id of the light for which the diffuse color is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the diffuse lighting to it's previous state. Otherwise, it is set to (1,1,1,1) if light is GL_LIGHT0, or (0,0,0,1) otherwise.
See also:
GLLightDiffuse

NVSG_API void GLResetLightLinearAttenuation ( GLenum light ) [friend]

Helper function to reset the linear attenuation of the light light.

Parameters:
light The id of the light for which the linear attenuation is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the linear attenuation of the light light to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLLightLinearAttenuation

NVSG_API void GLResetLightModelAmbient ( ) [friend]

Helper function to reset the ambient light color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the ambient light color to it's previous state. Otherwise, it is set to (0.2,0.2,0.2,1.0).
See also:
GLLightSpotExponent

NVSG_API void GLResetLightModelLocalViewer ( ) [friend]

Helper function to reset the local viewer setting.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the local viewer to it's previous state. Otherwise, it is set to GL_FALSE.
See also:
GLLightModelLocalViewer

NVSG_API void GLResetLightModelTwoSide ( ) [friend]

Helper function to reset the two sided lighting state.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the two sided lighting to it's previous state. Otherwise, it is set to GL_FALSE.
See also:
GLLightModelTwoSide

NVSG_API void GLResetLightPosition ( GLenum light ) [friend]

Helper function to reset the position of the light light.

Parameters:
light The id of the light for which the position is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the position of the light light to it's previous state. Otherwise, it is set to (0,0,1,0).
See also:
GLLightPosition

NVSG_API void GLResetLightQuadraticAttenuation ( GLenum light ) [friend]

Helper function to reset the quadratic attenuation of the light light.

Parameters:
light The id of the light for which the quadratic attenuation is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the quadratic attenuation of the light light to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLLightQuadraticAttenuation

NVSG_API void GLResetLightSpecular ( GLenum light ) [friend]

Helper function to reset the specular color of the light light.

Parameters:
light The id of the light for which the specular color is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the specular color of the light light to it's previous state. Otherwise, it is set to (1,1,1,1) if light is GL_LIGHT0, or (0,0,0,1) otherwise.
See also:
GLLightSpecular

NVSG_API void GLResetLightSpotCutoff ( GLenum light ) [friend]

Helper function to reset the spot cutoff of the light light.

Parameters:
light The id of the light for which the spot cutoff is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the spot cutoff of the light light to it's previous state. Otherwise, it is set to 180.0f.
See also:
GLLightSpotCutoff

NVSG_API void GLResetLightSpotDirection ( GLenum light ) [friend]

Helper function to reset the spot cutoff of the light light.

Parameters:
light The id of the light for which the spot cutoff is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the spot cutoff of the light light to it's previous state. Otherwise, it is set to 180.0f.
See also:
GLLightSpotCutoff

NVSG_API void GLResetLightSpotExponent ( GLenum light ) [friend]

Helper function to reset the spot exponent of the light light.

Parameters:
light The id of the light for which the spot exponent is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the spot exponent of the light light to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLLightSpotExponent

NVSG_API void GLResetLineSmooth ( ) [friend]

Helper function to reset the enable state of line smoothing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the line smoothing state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLineSmooth, GLEnableLineSmooth, GLDisable, GLEnable

NVSG_API void GLResetLineStipple ( ) [friend]

Helper function to reset the enable state of line stippling.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the line stippling state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLineStipple, GLEnableLineStipple, GLDisable, GLEnable

NVSG_API void GLResetLineStippleDefinition ( ) [friend]

Helper function to reset line stipple repeat and pattern.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the line stipple repeat and pattern to it's previous state. Otherwise, it is set to 1 and 0xFFFF, respectively.
See also:
GLLineStipple

NVSG_API void GLResetLineWidth ( ) [friend]

Helper function to reset the line width.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the line width to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLLineWidth

NVSG_API void GLResetLogicOp ( ) [friend]

Helper function to reset the enable state of logic operation.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the logic operation state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLogicOp, GLEnableLogicOp, GLDisable, GLEnable

NVSG_API void GLResetMaterialAmbientBack ( ) [friend]

Helper function to reset the material back face ambient color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face ambient color to it's previous state. Otherwise, it is set to (0.2,0.2,0.2,1.0).
See also:
GLMaterialAmbientBack

NVSG_API void GLResetMaterialAmbientFront ( ) [friend]

Helper function to reset the material front face ambient color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face ambient color to it's previous state. Otherwise, it is set to (0.2,0.2,0.2,1.0).
See also:
GLMaterialAmbientFront

NVSG_API void GLResetMaterialAmbientFrontAndBack ( ) [friend]

Helper function to reset the material back and front face ambient color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face ambient color to it's previous state. Otherwise, it is set to (0.2,0.2,0.2,1.0).
See also:
GLMaterialAmbientFrontAndBack

NVSG_API void GLResetMaterialDiffuseBack ( ) [friend]

Helper function to reset the material back face diffuse color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face diffuse color to it's previous state. Otherwise, it is set to (0.8,0.8,0.8,1.0).
See also:
GLMaterialDiffuseBack

NVSG_API void GLResetMaterialDiffuseFront ( ) [friend]

Helper function to reset the material front face diffuse color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face diffuse color to it's previous state. Otherwise, it is set to (0.8,0.8,0.8,1.0).
See also:
GLMaterialDiffuseFront

NVSG_API void GLResetMaterialDiffuseFrontAndBack ( ) [friend]

Helper function to reset the material back and front face diffuse color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face diffuse color to it's previous state. Otherwise, it is set to (0.8,0.8,0.8,1.0).
See also:
GLMaterialDiffuseFrontAndBack

NVSG_API void GLResetMaterialEmissionBack ( ) [friend]

Helper function to reset the material back face emission color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face emission color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialEmissionBack

NVSG_API void GLResetMaterialEmissionFront ( ) [friend]

Helper function to reset the material front face emission color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face emission color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialEmissionFront

NVSG_API void GLResetMaterialEmissionFrontAndBack ( ) [friend]

Helper function to reset the material back and front face emission color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face emission color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialEmissionFrontAndBack

NVSG_API void GLResetMaterialShininessBack ( ) [friend]

Helper function to reset the material back face shininess.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face shininess to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLMaterialShininessBack

NVSG_API void GLResetMaterialShininessFront ( ) [friend]

Helper function to reset the material front face shininess.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face shininess to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLMaterialShininessFront

NVSG_API void GLResetMaterialShininessFrontAndBack ( ) [friend]

Helper function to reset the material back and front face shininess.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face shininess to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLMaterialShininessFrontAndBack

NVSG_API void GLResetMaterialSpecularBack ( ) [friend]

Helper function to reset the material back face specular color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face specular color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialSpecularBack

NVSG_API void GLResetMaterialSpecularFront ( ) [friend]

Helper function to reset the material front face specular color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face specular color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialSpecularFront

NVSG_API void GLResetMaterialSpecularFrontAndBack ( ) [friend]

Helper function to reset the material back and front face specular color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face specular color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialSpecularFrontAndBack

NVSG_API void GLResetNormalize ( ) [friend]

Helper function to reset the enable state of normalizing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the normalize state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableNormalize, GLEnableNormalize, GLDisable, GLEnable

NVSG_API void GLResetPointSize ( ) [friend]

Helper function to reset the point size.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the point size to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLPointSize

NVSG_API void GLResetPointSmooth ( ) [friend]

Helper function to reset the enable state of point smoothing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the point smoothing state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePointSmooth, GLEnablePointSmooth, GLDisable, GLEnable

NVSG_API void GLResetPolygonModeBack ( ) [friend]

Helper function to reset back face polygon mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the back face polygon mode to it's previous state. Otherwise, it is set to GL_FILL.
See also:
GLPolygonModeBack

NVSG_API void GLResetPolygonModeFront ( ) [friend]

Helper function to reset front face polygon mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the front face polygon mode to it's previous state. Otherwise, it is set to GL_FILL.
See also:
GLPolygonModeFront

NVSG_API void GLResetPolygonModeFrontAndBack ( ) [friend]

Helper function to reset back and front face polygon mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the back and front face polygon mode to it's previous state. Otherwise, it is set to GL_FILL.
See also:
GLPolygonModeFrontAndBack, GLPolygonModeFront, GLPolygonMode Back

NVSG_API void GLResetPolygonOffset ( ) [friend]

Helper function to reset the polygon offset.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon offset to it's previous state. Otherwise, it is set to (0,0).
See also:
GLPolygonOffset

NVSG_API void GLResetPolygonOffsetFill ( ) [friend]

Helper function to reset the enable state of filled polygon offset.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon offset fill state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonOffsetFill, GLEnablePolygonOffsetFill, GLDisable, GLEnable

NVSG_API void GLResetPolygonOffsetLine ( ) [friend]

Helper function to reset the enable state of lined polygon offset.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon offset line state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonOffsetLine, GLEnablePolygonOffsetLine, GLDisable, GLEnable

NVSG_API void GLResetPolygonOffsetPoint ( ) [friend]

Helper function to reset the enable state of pointed polygon offset.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon offset point state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonOffsetPoint, GLEnablePolygonOffsetPoint, GLDisable, GLEnable

NVSG_API void GLResetPolygonSmooth ( ) [friend]

Helper function to reset the enable state of polygon smoothing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon smooth state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonSmooth, GLEnablePolygonSmooth, GLDisable, GLEnable

NVSG_API void GLResetPolygonStipple ( ) [friend]

Helper function to reset the enable state of polygon stippling.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon stippling state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonStipple, GLEnablePolygonStipple, GLDisable, GLEnable

NVSG_API void GLResetScissor ( ) [friend]

Helper function to reset the scissor rectangle.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the scissor rectangle to it's previous state. Otherwise, it does nothing.
See also:
GLScissor

NVSG_API void GLResetScissorTest ( ) [friend]

Helper function to reset the enable state of scissor testing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the scissor test state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableScissorTest, GLEnableScissorTest, GLDisable, GLEnable

NVSG_API void GLResetShadeModel ( ) [friend]

Helper function to reset the shade model.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the shade model to it's previous state. Otherwise, it is set to GL_SMOOTH.
See also:
GLShadeModel

NVSG_API void GLResetStencilFunc ( ) [friend]

Helper function to reset the stencil function values.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil function values to it's previous state. Otherwise, it sets the function, reference value, and mask to GL_ALWAYS, 0, and ~0, respectively.
See also:
GLStencilFunc

NVSG_API void GLResetStencilMask ( ) [friend]

Helper function to reset the stencil mask.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil mask to it's previous state. Otherwise, it is set to ~0.
See also:
GLStencilMask

NVSG_API void GLResetStencilOp ( ) [friend]

Helper function to reset the stencil operation values.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil operation values to it's previous state. Otherwise, it sets each value (fail, zfail, zpass) to GL_KEEP.
See also:
GLStencilMask

NVSG_API void GLResetStencilTest ( ) [friend]

Helper function to reset the enable state of stencil testing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil test state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableStencilTest, GLEnableStencilTest, GLDisable, GLEnable

NVSG_API void GLResetTexture ( GLenum target ) [friend]

Helper function to reset the enable state of texture target target.

Parameters:
target The texture target for which the enable state has to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the texture target target to it's previous state. Otherwise, it is disabled.
See also:
GLDisableTexture, GLEnableTexture, GLDisable, GLEnable

NVSG_API bool GLGetTexImageFmt | ( | GLTexImageFmt & | tfmt,
 |  | nvsg::Image::PixelFormat | fmt,
 |  | nvsg::Image::PixelDataType | type,
 |  | nvsg::TextureImage::TextureGPUFormat | gpuFmt = nvsg::TextureImage::TGF_DEFAULT
 | ) | [friend]

Returns a GLTexImageFmt according to the passed in PixelFormat and PixelDataType descriptors.

Parameters:
fmt | Input PixelFormat descriptor of an nvsg::Image
type | Input PixelDataType descriptor of an nvsg::Image
Remarks:
The function translates the passed in NVSG specific PixelFormat and PixelDataType descriptors into an OpenGL specific texture image format descriptor. Thereby, the function always tries to return the 'best match' of a texture image format which is supported by the current hardware and driver configuration.
Returns:
The function returns a pointer to a GLTexImageFmt structure representing the best match of an OpenGL texture image format according to the input PixelFormat and PixelDataType descriptors. The function returns NULL if no corresponding format could be found.

NVSG_API GLenum GLGetTexWrapMode ( nvsg::TextureWrapMode twm ) [friend]

Translate an nvsg::TextureWrapMode into a GL-specific texture wrap mode as a GLenum.

Parameters:
twm The TextureWrapMode to translate.
Returns:
The OpenGL-specific GLenum being a 'best match' of the nvsg::TextureWrapMode.

The documentation for this class was generated from the following file:
  • GLContext.h
Generated on Tue Jan 15 10:28:55 2008 for NVSGSDK by NVIDIA


Member List

GLContext Member List

This is the complete list of members for GLContext, including all inherited members.
getDisplay() | GLContext | [inline]
GLAccum(GLenum op, GLfloat value) | GLContext | [friend]
GLActiveStencilFace(GLenum face) | GLContext | [friend]
GLActiveTexture(GLenum texture) | GLContext | [friend]
GLActiveVarying(GLuint program, const GLchar *name) | GLContext | [friend]
GLAddSwapHintRect(GLint x, GLint y, GLsizei width, GLsizei height) | GLContext | [friend]
GLAlphaFunc(GLenum func, GLclampf ref) | GLContext | [friend]
GLAreProgramsResident(GLsizei n, const GLuint *programs, GLboolean *residences) | GLContext | [friend]
GLAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) | GLContext | [friend]
GLArrayElement(GLint i) | GLContext | [friend]
GLAttachObject(GLhandleARB containerObj, GLhandleARB attachedObj) | GLContext | [friend]
GLAttachShader(GLuint program, GLuint shader) | GLContext | [friend]
GLBegin(GLenum mode) | GLContext | [friend]
GLBeginOcclusionQuery(GLuint id) | GLContext | [friend]
GLBeginQuery(GLenum target, GLuint id) | GLContext | [friend]
GLBeginTransformFeedback(GLenum primitiveMode) | GLContext | [friend]
GLBindArraySet(GLuint buffer) | GLContext | [friend]
GLBindAttribLocation(GLuint program, GLuint index, const GLchar *name) | GLContext | [friend]
GLBindBuffer(GLenum target, GLuint id) | GLContext | [friend]
GLBindBufferBase(GLenum target, GLuint index, GLuint buffer) | GLContext | [friend]
GLBindBufferOffset(GLenum target, GLuint index, GLuint buffer, GLintptr offset) | GLContext | [friend]
GLBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) | GLContext | [friend]
GLBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) | GLContext | [friend]
GLBindFramebuffer(GLenum target, GLuint framebuffer) | GLContext | [friend]
GLBindProgram(GLenum target, GLuint id) | GLContext | [friend]
GLBindRenderbuffer(GLenum target, GLuint renderbuffer) | GLContext | [friend]
GLBindTexture(GLenum target, GLuint texture) | GLContext | [friend]
GLBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) | GLContext | [friend]
GLBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) | GLContext | [friend]
GLBlendEquation(GLenum mode) | GLContext | [friend]
GLBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) | GLContext | [friend]
GLBlendFunc(GLenum sfactor, GLenum dfactor) | GLContext | [friend]
GLBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) | GLContext | [friend]
GLBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) | GLContext | [friend]
GLBufferData(GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage) | GLContext | [friend]
GLBufferSubData(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data) | GLContext | [friend]
GLCallList(GLuint list) | GLContext | [friend]
GLCallLists(GLsizei n, GLenum type, const GLvoid *lists) | GLContext | [friend]
GLCgGLApplyProgramSamplers (defined in GLContext) | GLContext | [friend]
GLCgGLBindEffect (defined in GLContext) | GLContext | [friend]
GLCgGLBindPass (defined in GLContext) | GLContext | [friend]
GLCgGLBindProgram (defined in GLContext) | GLContext | [friend]
GLCgGLGetEffect (defined in GLContext) | GLContext | [friend]
GLCgGLGetPass (defined in GLContext) | GLContext | [friend]
GLCgGLGetProgram (defined in GLContext) | GLContext | [friend]
GLCheckFramebufferStatus(GLenum target) | GLContext | [friend]
GLClampColor(GLenum target, GLenum clamp) | GLContext | [friend]
GLClear(GLbitfield mask) | GLContext | [friend]
GLClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) | GLContext | [friend]
GLClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) | GLContext | [friend]
GLClearColorIi(GLint red, GLint green, GLint blue, GLint alpha) | GLContext | [friend]
GLClearColorIui(GLuint red, GLuint green, GLuint blue, GLuint alpha) | GLContext | [friend]
GLClearDepth(GLclampd depth) | GLContext | [friend]
GLClearDepthd(GLdouble depth) | GLContext | [friend]
GLClearIndex(GLfloat c) | GLContext | [friend]
GLClearStencil(GLint s) | GLContext | [friend]
GLClientActiveTexture(GLenum texture) | GLContext | [friend]
GLClipPlane(GLenum plane, const GLdouble *equation) | GLContext | [friend]
GLColor3b(GLbyte red, GLbyte green, GLbyte blue) | GLContext | [friend]
GLColor3bv(const GLbyte *v) | GLContext | [friend]
GLColor3d(GLdouble red, GLdouble green, GLdouble blue) | GLContext | [friend]
GLColor3dv(const GLdouble *v) | GLContext | [friend]
GLColor3f(GLfloat red, GLfloat green, GLfloat blue) | GLContext | [friend]
GLColor3fv(const GLfloat *v) | GLContext | [friend]
GLColor3h(GLhalf red, GLhalf green, GLhalf blue) | GLContext | [friend]
GLColor3hv(const GLhalf *v) | GLContext | [friend]
GLColor3i(GLint red, GLint green, GLint blue) | GLContext | [friend]
GLColor3iv(const GLint *v) | GLContext | [friend]
GLColor3s(GLshort red, GLshort green, GLshort blue) | GLContext | [friend]
GLColor3sv(const GLshort *v) | GLContext | [friend]
GLColor3ub(GLubyte red, GLubyte green, GLubyte blue) | GLContext | [friend]
GLColor3ubv(const GLubyte *v) | GLContext | [friend]
GLColor3ui(GLuint red, GLuint green, GLuint blue) | GLContext | [friend]
GLColor3uiv(const GLuint *v) | GLContext | [friend]
GLColor3us(GLushort red, GLushort green, GLushort blue) | GLContext | [friend]
GLColor3usv(const GLushort *v) | GLContext | [friend]
GLColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) | GLContext | [friend]
GLColor4bv(const GLbyte *v) | GLContext | [friend]
GLColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) | GLContext | [friend]
GLColor4dv(const GLdouble *v) | GLContext | [friend]
GLColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) | GLContext | [friend]
GLColor4fv(const GLfloat *v) | GLContext | [friend]
GLColor4h(GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha) | GLContext | [friend]
GLColor4hv(const GLhalf *v) | GLContext | [friend]
GLColor4i(GLint red, GLint green, GLint blue, GLint alpha) | GLContext | [friend]
GLColor4iv(const GLint *v) | GLContext | [friend]
GLColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) | GLContext | [friend]
GLColor4sv(const GLshort *v) | GLContext | [friend]
GLColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) | GLContext | [friend]
GLColor4ubv(const GLubyte *v) | GLContext | [friend]
GLColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) | GLContext | [friend]
GLColor4uiv(const GLuint *v) | GLContext | [friend]
GLColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) | GLContext | [friend]
GLColor4usv(const GLushort *v) | GLContext | [friend]
GLColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) | GLContext | [friend]
GLColorMaskIndexed(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) | GLContext | [friend]
GLColorMaterial(GLenum face, GLenum mode) | GLContext | [friend]
GLColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) | GLContext | [friend]
GLColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) | GLContext | [friend]
GLColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) | GLContext | [friend]
GLColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) | GLContext | [friend]
GLCombinerInput(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) | GLContext | [friend]
GLCombinerOutput(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum) | GLContext | [friend]
GLCombinerParameterf(GLenum pname, GLfloat param) | GLContext | [friend]
GLCombinerParameterfv(GLenum pname, const GLfloat *params) | GLContext | [friend]
GLCombinerParameteri(GLenum pname, GLint param) | GLContext | [friend]
GLCombinerParameteriv(GLenum pname, const GLint *params) | GLContext | [friend]
GLCombinerStageParameterfv(GLenum stage, GLenum pname, const GLfloat *params) | GLContext | [friend]
GLCompileShader(GLuint shader) | GLContext | [friend]
GLCompressedTexImage1D(GLenum target, int level, GLenum internalformat, GLsizei width, int border, GLsizei imageSize, const void *data) | GLContext | [friend]
GLCompressedTexImage2D(GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, int border, GLsizei imageSize, const void *data) | GLContext | [friend]
GLCompressedTexImage3D(GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLsizei imageSize, const void *data) | GLContext | [friend]
GLCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) | GLContext | [friend]
GLCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) | GLContext | [friend]
GLCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) | GLContext | [friend]
GLConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) | GLContext | [friend]
GLConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) | GLContext | [friend]
GLConvolutionParameterf(GLenum target, GLenum pname, GLfloat params) | GLContext | [friend]
GLConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params) | GLContext | [friend]
GLConvolutionParameteri(GLenum target, GLenum pname, GLint params) | GLContext | [friend]
GLConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params) | GLContext | [friend]
GLCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) | GLContext | [friend]
GLCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) | GLContext | [friend]
GLCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) | GLContext | [friend]
GLCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) | GLContext | [friend]
GLCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) | GLContext | [friend]
GLCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) | GLContext | [friend]
GLCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) | GLContext | [friend]
GLCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) | GLContext | [friend]
GLCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) | GLContext | [friend]
GLCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) | GLContext | [friend]
GLCreateProgram() | GLContext | [friend]
GLCreateProgramObject() | GLContext | [friend]
GLCreateShader(GLenum type) | GLContext | [friend]
GLCreateShaderObject(GLenum shaderType) | GLContext | [friend]
GLCullFace(GLenum mode) | GLContext | [friend]
GLCullFaceLock(GLenum mode) | GLContext | [friend]
GLCullFaceUnlock(GLenum mode) | GLContext | [friend]
GLDeleteArraySets(GLsizei n, const GLuint *buffers) | GLContext | [friend]
GLDeleteBufferCaches (defined in GLContext) | GLContext | [friend]
GLDeleteBuffers(GLsizei n, const GLuint *buffers) | GLContext | [friend]
GLDeleteDisplayListCaches (defined in GLContext) | GLContext | [friend]
GLDeleteFences(GLsizei n, const GLuint *fences) | GLContext | [friend]
GLDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) | GLContext | [friend]
GLDeleteLists(GLuint list, GLsizei range) | GLContext | [friend]
GLDeleteObject(GLhandleARB obj) | GLContext | [friend]
GLDeleteOcclusionQueries(GLsizei n, const GLuint *ids) | GLContext | [friend]
GLDeleteProgram(GLuint program) | GLContext | [friend]
GLDeletePrograms(GLsizei n, const GLuint *ids) | GLContext | [friend]
GLDeleteQueries(GLsizei n, const GLuint *ids) | GLContext | [friend]
GLDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) | GLContext | [friend]
GLDeleteShader(GLuint shader) | GLContext | [friend]
GLDeleteTextureCaches (defined in GLContext) | GLContext | [friend]
GLDeleteTextures(GLsizei n, const GLuint *textures) | GLContext | [friend]
GLDepthBounds(GLclampd zmin, GLclampd zmax) | GLContext | [friend]
GLDepthBoundsd(GLdouble zmin, GLdouble zmax) | GLContext | [friend]
GLDepthFunc(GLenum func) | GLContext | [friend]
GLDepthMask(GLboolean flag) | GLContext | [friend]
GLDepthRange(GLclampd znear, GLclampd zfar) | GLContext | [friend]
GLDepthRanged(GLdouble zNear, GLdouble zFar) | GLContext | [friend]
GLDetachObject(GLhandleARB containerObj, GLhandleARB attachedObj) | GLContext | [friend]
GLDetachShader(GLuint program, GLuint shader) | GLContext | [friend]
GLDisable(GLenum cap) | GLContext | [friend]
GLDisableAlphaTest(void) | GLContext | [friend]
GLDisableAutoNormal(void) | GLContext | [friend]
GLDisableBlend(void) | GLContext | [friend]
GLDisableClientState(GLenum array) | GLContext | [friend]
GLDisableClipPlane(GLenum plane) | GLContext | [friend]
GLDisableColorArray(void) | GLContext | [friend]
GLDisableColorLogicOp(void) | GLContext | [friend]
GLDisableColorMaterial(void) | GLContext | [friend]
GLDisableCullFace(void) | GLContext | [friend]
GLDisableCullFaceLock(void) | GLContext | [friend]
GLDisableCullFaceUnlock(void) | GLContext | [friend]
GLDisableDepthTest(void) | GLContext | [friend]
GLDisableDither(void) | GLContext | [friend]
GLDisableFog(void) | GLContext | [friend]
GLDisableFogCoordinateArray(void) | GLContext | [friend]
GLDisableIndexed(GLenum target, GLuint index) | GLContext | [friend]
GLDisableLight(GLenum light) | GLContext | [friend]
GLDisableLighting(void) | GLContext | [friend]
GLDisableLightingLock(void) | GLContext | [friend]
GLDisableLightingUnlock(void) | GLContext | [friend]
GLDisableLineSmooth(void) | GLContext | [friend]
GLDisableLineStipple(void) | GLContext | [friend]
GLDisableLogicOp(void) | GLContext | [friend]
GLDisableNormalArray(void) | GLContext | [friend]
GLDisableNormalize(void) | GLContext | [friend]
GLDisablePointSmooth(void) | GLContext | [friend]
GLDisablePolygonOffsetFill(void) | GLContext | [friend]
GLDisablePolygonOffsetLine(void) | GLContext | [friend]
GLDisablePolygonOffsetPoint(void) | GLContext | [friend]
GLDisablePolygonSmooth(void) | GLContext | [friend]
GLDisablePolygonStipple(void) | GLContext | [friend]
GLDisableScissorTest(void) | GLContext | [friend]
GLDisableSecondaryColorArray(void) | GLContext | [friend]
GLDisableStencilTest(void) | GLContext | [friend]
GLDisableTexture(GLenum target) | GLContext | [friend]
GLDisableTextureCoordArray(void) | GLContext | [friend]
GLDisableTextureGen(GLenum target) | GLContext | [friend]
GLDisableVertexArray(void) | GLContext | [friend]
GLDisableVertexAttribArray(GLuint index) | GLContext | [friend]
GLDrawArrays(GLenum mode, GLint first, GLsizei count) | GLContext | [friend]
GLDrawArraysInstanced(GLenum mode, GLint start, GLsizei count, GLsizei primcount) | GLContext | [friend]
GLDrawBuffer(GLenum mode) | GLContext | [friend]
GLDrawBuffers(GLsizei n, const GLenum *bufs) | GLContext | [friend]
GLDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) | GLContext | [friend]
GLDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount) | GLContext | [friend]
GLDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) | GLContext | [friend]
GLDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) | GLContext | [friend]
GLEdgeFlag(GLboolean flag) | GLContext | [friend]
GLEdgeFlagPointer(GLsizei stride, const GLboolean *pointer) | GLContext | [friend]
GLEdgeFlagv(const GLboolean *flag) | GLContext | [friend]
GLEnable(GLenum cap) | GLContext | [friend]
GLEnableAlphaTest(void) | GLContext | [friend]
GLEnableAutoNormal(void) | GLContext | [friend]
GLEnableBlend(void) | GLContext | [friend]
GLEnableClientState(GLenum array) | GLContext | [friend]
GLEnableClipPlane(GLenum plane) | GLContext | [friend]
GLEnableColorArray(void) | GLContext | [friend]
GLEnableColorLogicOp(void) | GLContext | [friend]
GLEnableColorMaterial(void) | GLContext | [friend]
GLEnableCullFace(void) | GLContext | [friend]
GLEnableCullFaceLock(void) | GLContext | [friend]
GLEnableCullFaceUnlock(void) | GLContext | [friend]
GLEnableDepthTest(void) | GLContext | [friend]
GLEnableDither(void) | GLContext | [friend]
GLEnableFog(void) | GLContext | [friend]
GLEnableFogCoordinateArray(void) | GLContext | [friend]
GLEnableIndexed(GLenum target, GLuint index) | GLContext | [friend]
GLEnableLight(GLenum light) | GLContext | [friend]
GLEnableLighting(void) | GLContext | [friend]
GLEnableLineSmooth(void) | GLContext | [friend]
GLEnableLineStipple(void) | GLContext | [friend]
GLEnableLogicOp(void) | GLContext | [friend]
GLEnableNormalArray(void) | GLContext | [friend]
GLEnableNormalize(void) | GLContext | [friend]
GLEnablePointSmooth(void) | GLContext | [friend]
GLEnablePolygonOffsetFill(void) | GLContext | [friend]
GLEnablePolygonOffsetLine(void) | GLContext | [friend]
GLEnablePolygonOffsetPoint(void) | GLContext | [friend]
GLEnablePolygonSmooth(void) | GLContext | [friend]
GLEnablePolygonStipple(void) | GLContext | [friend]
GLEnableScissorTest(void) | GLContext | [friend]
GLEnableSecondaryColorArray(void) | GLContext | [friend]
GLEnableStencilTest(void) | GLContext | [friend]
GLEnableTexture(GLenum target) | GLContext | [friend]
GLEnableTextureCoordArray(void) | GLContext | [friend]
GLEnableTextureGen(GLenum target) | GLContext | [friend]
GLEnableVertexArray(void) | GLContext | [friend]
GLEnableVertexAttribArray(GLuint index) | GLContext | [friend]
GLEnd(void) | GLContext | [friend]
GLEndList(void) | GLContext | [friend]
GLEndOcclusionQuery(void) | GLContext | [friend]
GLEndQuery(GLenum target) | GLContext | [friend]
GLEndTransformFeedback() | GLContext | [friend]
GLEvalCoord1d(GLdouble u) | GLContext | [friend]
GLEvalCoord1f(GLfloat u) | GLContext | [friend]
GLEvalCoord2d(GLdouble u, GLdouble v) | GLContext | [friend]
GLEvalCoord2f(GLfloat u, GLfloat v) | GLContext | [friend]
GLEvalMesh1(GLenum mode, GLint i1, GLint i2) | GLContext | [friend]
GLEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) | GLContext | [friend]
GLEvalPoint1(GLint i) | GLContext | [friend]
GLEvalPoint2(GLint i, GLint j) | GLContext | [friend]
GLExecuteProgram(GLenum target, GLuint id, const GLfloat *params) | GLContext | [friend]
GLFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) | GLContext | [friend]
GLFinalCombinerInput(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) | GLContext | [friend]
GLFinish(void) | GLContext | [friend]
GLFinishFence(GLuint fence) | GLContext | [friend]
GLFlush(void) | GLContext | [friend]
GLFlushPixelDataRange(GLenum target) | GLContext | [friend]
GLFlushVertexArrayRange() | GLContext | [friend]
GLFogColor(const GLfloat *color) | GLContext | [friend]
GLFogCoordd(GLdouble fog) | GLContext | [friend]
GLFogCoorddv(const GLdouble *fog) | GLContext | [friend]
GLFogCoordf(GLfloat fog) | GLContext | [friend]
GLFogCoordfv(const GLfloat *fog) | GLContext | [friend]
GLFogCoordh(GLhalf fog) | GLContext | [friend]
GLFogCoordhv(const GLhalf *fog) | GLContext | [friend]
GLFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLFogDensity(GLfloat density) | GLContext | [friend]
GLFogEnd(GLfloat end) | GLContext | [friend]
GLFogf(GLenum pname, GLfloat param) | GLContext | [friend]
GLFogfv(GLenum pname, const GLfloat *params) | GLContext | [friend]
GLFogi(GLenum pname, GLint param) | GLContext | [friend]
GLFogiv(GLenum pname, const GLint *params) | GLContext | [friend]
GLFogMode(GLenum param) | GLContext | [friend]
GLFogStart(GLfloat start) | GLContext | [friend]
GLFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) | GLContext | [friend]
GLFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level) | GLContext | [friend]
GLFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) | GLContext | [friend]
GLFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) | GLContext | [friend]
GLFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) | GLContext | [friend]
GLFramebufferTextureFace(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face) | GLContext | [friend]
GLFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) | GLContext | [friend]
GLFrameTerminator(void) | GLContext | [friend]
GLFrontFace(GLenum mode) | GLContext | [friend]
GLFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) | GLContext | [friend]
GLGenArrayBufferCache (defined in GLContext) | GLContext | [friend]
GLGenArraySets(GLsizei n, GLuint *buffers) | GLContext | [friend]
GLGenBuffers(GLsizei n, GLuint *buffers) | GLContext | [friend]
GLGenDisplayListCache (defined in GLContext) | GLContext | [friend]
GLGenElementArrayBufferCache (defined in GLContext) | GLContext | [friend]
GLGenerateMipmap(GLenum target) | GLContext | [friend]
GLGenFences(GLsizei n, GLuint *fences) | GLContext | [friend]
GLGenFramebuffers(GLsizei n, GLuint *framebuffers) | GLContext | [friend]
GLGenLists(GLsizei range) | GLContext | [friend]
GLGenOcclusionQueries(GLsizei n, GLuint *ids) | GLContext | [friend]
GLGenPixelBufferCache (defined in GLContext) | GLContext | [friend]
GLGenPrograms(GLsizei n, GLuint *ids) | GLContext | [friend]
GLGenQueries(GLsizei n, GLuint *ids) | GLContext | [friend]
GLGenRenderbuffers(GLsizei n, GLuint *renderbuffers) | GLContext | [friend]
GLGenTextureCache (defined in GLContext) | GLContext | [friend]
GLGenTextureCache (defined in GLContext) | GLContext | [friend]
GLGenTextures(GLsizei n, GLuint *textures) | GLContext | [friend]
GLGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) | GLContext | [friend]
GLGetActiveUniform(GLuint program, GLuint index, GLsizei maxLength, GLsizei *length, GLsizei *size, GLenum *type, GLcharARB *name) | GLContext | [friend]
GLGetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) | GLContext | [friend]
GLGetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj) | GLContext | [friend]
GLGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders) | GLContext | [friend]
GLGetAttribLocation(GLuint program, const GLchar *name) | GLContext | [friend]
GLGetBooleanIndexedv(GLenum target, GLuint index, GLboolean *data) | GLContext | [friend]
GLGetBooleanv(GLenum pname, GLboolean *params) | GLContext | [friend]
GLGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params) | GLContext | [friend]
GLGetBufferSubData(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data) | GLContext | [friend]
GLGetClipPlane(GLenum plane, GLdouble *equation) | GLContext | [friend]
GLGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table) | GLContext | [friend]
GLGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetCombinerInputParameterfv(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetCombinerInputParameteriv(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params) | GLContext | [friend]
GLGetCombinerOutputParameterfv(GLenum stage, GLenum portion, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetCombinerOutputParameteriv(GLenum stage, GLenum portion, GLenum pname, GLint *params) | GLContext | [friend]
GLGetCombinerStageParameterfv(GLenum stage, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetCompressedTexImage(GLenum target, GLint lod, GLvoid *img) | GLContext | [friend]
GLGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image) | GLContext | [friend]
GLGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetDoublev(GLenum pname, GLdouble *params) | GLContext | [friend]
GLGetFenceiv(GLuint fence, GLenum pname, GLint *params) | GLContext | [friend]
GLGetFinalCombinerInputParameterfv(GLenum variable, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetFinalCombinerInputParameteriv(GLenum variable, GLenum pname, GLint *params) | GLContext | [friend]
GLGetFloatv(GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetFogColor (defined in GLContext) | GLContext | [friend]
GLGetFragDataLocation(GLuint program, const GLchar *name) | GLContext | [friend]
GLGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) | GLContext | [friend]
GLGetHandle(GLenum pname) | GLContext | [friend]
GLGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) | GLContext | [friend]
GLGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetInfoLog(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog) | GLContext | [friend]
GLGetIntegerIndexedv(GLenum target, GLuint index, GLint *data) | GLContext | [friend]
GLGetIntegerv(GLenum pname, GLint *params) | GLContext | [friend]
GLGetLightfv(GLenum light, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetLightiv(GLenum light, GLenum pname, GLint *params) | GLContext | [friend]
GLGetMapdv(GLenum target, GLenum query, GLdouble *v) | GLContext | [friend]
GLGetMapfv(GLenum target, GLenum query, GLfloat *v) | GLContext | [friend]
GLGetMapiv(GLenum target, GLenum query, GLint *v) | GLContext | [friend]
GLGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetMaterialiv(GLenum face, GLenum pname, GLint *params) | GLContext | [friend]
GLGetMaxTexCoords(void) | GLContext | [friend]
GLGetMaxTexImageUnits(void) | GLContext | [friend]
GLGetMaxTexUnits(void) | GLContext | [friend]
GLGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) | GLContext | [friend]
GLGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetObjectParameterfv(GLhandleARB obj, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetObjectParameteriv(GLhandleARB obj, GLenum pname, GLint *params) | GLContext | [friend]
GLGetOcclusionQueryiv(GLuint id, GLenum pname, GLint *params) | GLContext | [friend]
GLGetOcclusionQueryuiv(GLuint id, GLenum pname, GLuint *params) | GLContext | [friend]
GLGetPixelMapfv(GLenum map, GLfloat *values) | GLContext | [friend]
GLGetPixelMapuiv(GLenum map, GLuint *values) | GLContext | [friend]
GLGetPixelMapusv(GLenum map, GLushort *values) | GLContext | [friend]
GLGetPointerv(GLenum pname, GLvoid **params) | GLContext | [friend]
GLGetPolygonStipple(GLubyte *mask) | GLContext | [friend]
GLGetProgramEnvParameterdv(GLenum target, GLuint index, GLdouble *params) | GLContext | [friend]
GLGetProgramEnvParameterfv(GLenum target, GLuint index, GLfloat *params) | GLContext | [friend]
GLGetProgramEnvParameterIiv(GLenum target, GLuint index, GLint *params) | GLContext | [friend]
GLGetProgramEnvParameterIuiv(GLenum target, GLuint index, GLuint *params) | GLContext | [friend]
GLGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) | GLContext | [friend]
GLGetProgramiv(GLuint program, GLenum pname, GLint *params) | GLContext | [friend]
GLGetProgramLocalParameterdv(GLenum target, GLuint index, GLdouble *params) | GLContext | [friend]
GLGetProgramLocalParameterfv(GLenum target, GLuint index, GLfloat *params) | GLContext | [friend]
GLGetProgramLocalParameterIiv(GLenum target, GLuint index, GLint *params) | GLContext | [friend]
GLGetProgramLocalParameterIuiv(GLenum target, GLuint index, GLuint *params) | GLContext | [friend]
GLGetProgramNamedParameterdv(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params) | GLContext | [friend]
GLGetProgramNamedParameterfv(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params) | GLContext | [friend]
GLGetProgramParameterdv(GLenum target, GLuint index, GLenum pname, GLdouble *params) | GLContext | [friend]
GLGetProgramParameterfv(GLenum target, GLuint index, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetProgramString(GLuint id, GLenum pname, GLubyte *program) | GLContext | [friend]
GLGetQueryiv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetQueryObjecti64v(GLuint id, GLenum pname, GLint64EXT *params) | GLContext | [friend]
GLGetQueryObjectiv(GLuint id, GLenum pname, GLint *params) | GLContext | [friend]
GLGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64EXT *params) | GLContext | [friend]
GLGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) | GLContext | [friend]
GLGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) | GLContext | [friend]
GLGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) | GLContext | [friend]
GLGetShaderiv(GLuint shader, GLenum pname, GLint *params) | GLContext | [friend]
GLGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLcharARB *source) | GLContext | [friend]
GLGetString(GLenum name) | GLContext | [friend]
GLGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetTexEnviv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) | GLContext | [friend]
GLGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetTexGeniv(GLenum coord, GLenum pname, GLint *params) | GLContext | [friend]
GLGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) | GLContext | [friend]
GLGetTexImageFmt(GLTexImageFmt &tfmt, nvsg::Image::PixelFormat fmt, nvsg::Image::PixelDataType type, nvsg::TextureImage::TextureGPUFormat gpuFmt=nvsg::TextureImage::TGF_DEFAULT) | GLContext | [friend]
GLGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) | GLContext | [friend]
GLGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetTexParameterIiv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params) | GLContext | [friend]
GLGetTexParameteriv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetTexWrapMode(nvsg::TextureWrapMode twm) | GLContext | [friend]
GLGetTrackMatrixiv(GLenum target, GLuint address, GLenum pname, GLint *params) | GLContext | [friend]
GLGetTransformFeedbackVarying(GLuint program, GLuint index, GLint *location) | GLContext | [friend]
GLGetUniformBufferSize(GLuint program, GLint location) | GLContext | [friend]
GLGetUniformfv(GLuint program, GLint location, GLfloat *params) | GLContext | [friend]
GLGetUniformiv(GLuint program, GLint location, GLint *params) | GLContext | [friend]
GLGetUniformLocation(GLuint program, const GLcharARB *name) | GLContext | [friend]
GLGetUniformOffset(GLuint program, GLint location) | GLContext | [friend]
GLGetUniformuiv(GLuint program, GLint location, GLuint *params) | GLContext | [friend]
GLGetVaryingLocation(GLuint program, const GLchar *name) | GLContext | [friend]
GLGetVersion() | GLContext | [friend]
GLGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) | GLContext | [friend]
GLGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) | GLContext | [friend]
GLGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) | GLContext | [friend]
GLGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) | GLContext | [friend]
GLGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) | GLContext | [friend]
GLGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) | GLContext | [friend]
GLHint(GLenum target, GLenum mode) | GLContext | [friend]
GLHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) | GLContext | [friend]
GLIndexd(GLdouble c) | GLContext | [friend]
GLIndexf(GLfloat c) | GLContext | [friend]
GLIndexi(GLint c) | GLContext | [friend]
GLIndexMask(GLuint mask) | GLContext | [friend]
GLIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLIndexs(GLshort c) | GLContext | [friend]
GLIndexub(GLubyte c) | GLContext | [friend]
GLInitNames(void) | GLContext | [friend]
GLInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLIsArraySet(GLuint buffer) | GLContext | [friend]
GLIsBuffer(GLuint name) | GLContext | [friend]
GLIsEnabled(GLenum cap) | GLContext | [friend]
GLIsEnabledAlphaTest() | GLContext | [friend]
GLIsEnabledAutoNormal() | GLContext | [friend]
GLIsEnabledBlend() | GLContext | [friend]
GLIsEnabledClipPlane(GLenum plane) | GLContext | [friend]
GLIsEnabledColorLogicOp() | GLContext | [friend]
GLIsEnabledColorMaterial() | GLContext | [friend]
GLIsEnabledCullFace() | GLContext | [friend]
GLIsEnabledDepthTest() | GLContext | [friend]
GLIsEnabledDither() | GLContext | [friend]
GLIsEnabledFog() | GLContext | [friend]
GLIsEnabledIndexed(GLenum target, GLuint index) | GLContext | [friend]
GLIsEnabledLight(GLenum cap) | GLContext | [friend]
GLIsEnabledLighting() | GLContext | [friend]
GLIsEnabledLineSmooth() | GLContext | [friend]
GLIsEnabledLineStipple() | GLContext | [friend]
GLIsEnabledLogicOp() | GLContext | [friend]
GLIsEnabledNormalize() | GLContext | [friend]
GLIsEnabledPointSmooth() | GLContext | [friend]
GLIsEnabledPolygonOffsetFill() | GLContext | [friend]
GLIsEnabledPolygonOffsetLine() | GLContext | [friend]
GLIsEnabledPolygonOffsetPoint() | GLContext | [friend]
GLIsEnabledPolygonSmooth() | GLContext | [friend]
GLIsEnabledPolygonStipple() | GLContext | [friend]
GLIsEnabledScissorTest() | GLContext | [friend]
GLIsEnabledStencilTest() | GLContext | [friend]
GLIsEnabledTexture(GLenum cap) | GLContext | [friend]
GLIsEnabledTextureGen(GLenum cap) | GLContext | [friend]
GLIsExtensionAvailable(const std::string &extension) | GLContext | [friend]
GLIsExtensionExported(const std::string &extension) | GLContext | [friend]
GLIsFence(GLuint fence) | GLContext | [friend]
GLIsFramebuffer(GLuint framebuffer) | GLContext | [friend]
GLIsList(GLuint list) | GLContext | [friend]
GLIsOcclusionQuery(GLuint id) | GLContext | [friend]
GLIsProgram(GLuint program) | GLContext | [friend]
GLIsQuery(GLuint id) | GLContext | [friend]
GLIsRenderbuffer(GLuint renderbuffer) | GLContext | [friend]
GLIsShader(GLuint shader) | GLContext | [friend]
GLIsTexture(GLuint texture) | GLContext | [friend]
GLIsValidArrayBufferCache (defined in GLContext) | GLContext | [friend]
GLIsValidDisplayListCache (defined in GLContext) | GLContext | [friend]
GLIsValidElementArrayBufferCache (defined in GLContext) | GLContext | [friend]
GLIsValidPixelBufferCache (defined in GLContext) | GLContext | [friend]
GLIsValidTextureCache (defined in GLContext) | GLContext | [friend]
GLLightAmbient(GLenum light, const GLfloat *params) | GLContext | [friend]
GLLightConstantAttenuation(GLenum light, GLfloat param) | GLContext | [friend]
GLLightDiffuse(GLenum light, const GLfloat *params) | GLContext | [friend]
GLLightf(GLenum light, GLenum pname, GLfloat param) | GLContext | [friend]
GLLightfv(GLenum light, GLenum pname, const GLfloat *params) | GLContext | [friend]
GLLighti(GLenum light, GLenum pname, GLint param) | GLContext | [friend]
GLLightiv(GLenum light, GLenum pname, GLint *params) | GLContext | [friend]
GLLightLinearAttenuation(GLenum light, GLfloat param) | GLContext | [friend]
GLLightModelAmbient(const GLfloat *params) | GLContext | [friend]
GLLightModelf(GLenum pname, GLfloat param) | GLContext | [friend]
GLLightModelfv(GLenum pname, const GLfloat *params) | GLContext | [friend]
GLLightModeli(GLenum pname, GLint param) | GLContext | [friend]
GLLightModeliv(GLenum pname, const GLint *params) | GLContext | [friend]
GLLightModelLocalViewer(GLint param) | GLContext | [friend]
GLLightModelTwoSide(GLint param) | GLContext | [friend]
GLLightModelTwoSideLock(GLint param) | GLContext | [friend]
GLLightModelTwoSideUnlock(GLint param) | GLContext | [friend]
GLLightPosition(GLenum light, const GLfloat *params) | GLContext | [friend]
GLLightQuadraticAttenuation(GLenum light, GLfloat param) | GLContext | [friend]
GLLightSpecular(GLenum light, const GLfloat *params) | GLContext | [friend]
GLLightSpotCutoff(GLenum light, GLfloat param) | GLContext | [friend]
GLLightSpotDirection(GLenum light, const GLfloat *params) | GLContext | [friend]
GLLightSpotExponent(GLenum light, GLfloat param) | GLContext | [friend]
GLLineStipple(GLint factor, GLushort pattern) | GLContext | [friend]
GLLineWidth(GLfloat width) | GLContext | [friend]
GLLinkProgram(GLuint program) | GLContext | [friend]
GLListBase(GLuint base) | GLContext | [friend]
GLLoadIdentity(void) | GLContext | [friend]
GLLoadMatrixd(const GLdouble *m) | GLContext | [friend]
GLLoadMatrixf(const GLfloat *m) | GLContext | [friend]
GLLoadName(GLuint name) | GLContext | [friend]
GLLoadProgram(GLenum target, GLuint id, GLsizei len, const GLubyte *program) | GLContext | [friend]
GLLoadTransposedMatrixd(const GLdouble *m) | GLContext | [friend]
GLLoadTransposeMatrixf(const GLfloat *m) | GLContext | [friend]
GLLockArrays(GLint first, GLsizei count) | GLContext | [friend]
GLLogicOp(GLenum opcode) | GLContext | [friend]
GLMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) | GLContext | [friend]
GLMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) | GLContext | [friend]
GLMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) | GLContext | [friend]
GLMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) | GLContext | [friend]
GLMapBuffer(GLenum target, GLenum access) | GLContext | [friend]
GLMapGrid1d(GLint un, GLdouble u1, GLdouble u2) | GLContext | [friend]
GLMapGrid1f(GLint un, GLfloat u1, GLfloat u2) | GLContext | [friend]
GLMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) | GLContext | [friend]
GLMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) | GLContext | [friend]
GLMaterialAmbient(GLenum face, const GLfloat *params) | GLContext | [friend]
GLMaterialAmbientBack(const GLfloat *params) | GLContext | [friend]
GLMaterialAmbientFront(const GLfloat *params) | GLContext | [friend]
GLMaterialAmbientFrontAndBack(const GLfloat *params) | GLContext | [friend]
GLMaterialDiffuse(GLenum face, const GLfloat *params) | GLContext | [friend]
GLMaterialDiffuseBack(const GLfloat *params) | GLContext | [friend]
GLMaterialDiffuseFront(const GLfloat *params) | GLContext | [friend]
GLMaterialDiffuseFrontAndBack(const GLfloat *params) | GLContext | [friend]
GLMaterialEmission(GLenum face, const GLfloat *params) | GLContext | [friend]
GLMaterialEmissionBack(const GLfloat *params) | GLContext | [friend]
GLMaterialEmissionFront(const GLfloat *params) | GLContext | [friend]
GLMaterialEmissionFrontAndBack(const GLfloat *params) | GLContext | [friend]
GLMaterialf(GLenum face, GLenum pname, GLfloat param) | GLContext | [friend]
GLMaterialfv(GLenum face, GLenum pname, const GLfloat *params) | GLContext | [friend]
GLMateriali(GLenum face, GLenum pname, GLint param) | GLContext | [friend]
GLMaterialiv(GLenum face, GLenum pname, const GLint *params) | GLContext | [friend]
GLMaterialShininess(GLenum face, GLfloat param) | GLContext | [friend]
GLMaterialShininessBack(GLfloat param) | GLContext | [friend]
GLMaterialShininessFront(GLfloat param) | GLContext | [friend]
GLMaterialShininessFrontAndBack(GLfloat param) | GLContext | [friend]
GLMaterialSpecular(GLenum face, const GLfloat *params) | GLContext | [friend]
GLMaterialSpecularBack(const GLfloat *params) | GLContext | [friend]
GLMaterialSpecularFront(const GLfloat *params) | GLContext | [friend]
GLMaterialSpecularFrontAndBack(const GLfloat *params) | GLContext | [friend]
GLMatrixMode(GLenum mode) | GLContext | [friend]
GLMinmax(GLenum target, GLenum internalformat, GLboolean sink) | GLContext | [friend]
GLMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) | GLContext | [friend]
GLMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount) | GLContext | [friend]
GLMultiTexCoord1d(GLenum target, GLdouble s) | GLContext | [friend]
GLMultiTexCoord1dv(GLenum target, const GLdouble *v) | GLContext | [friend]
GLMultiTexCoord1f(GLenum target, GLfloat s) | GLContext | [friend]
GLMultiTexCoord1fv(GLenum target, const GLfloat *v) | GLContext | [friend]
GLMultiTexCoord1h(GLenum target, GLhalf s) | GLContext | [friend]
GLMultiTexCoord1hv(GLenum target, const GLhalf *v) | GLContext | [friend]
GLMultiTexCoord1i(GLenum target, GLint s) | GLContext | [friend]
GLMultiTexCoord1iv(GLenum target, const GLint *v) | GLContext | [friend]
GLMultiTexCoord1s(GLenum target, GLshort s) | GLContext | [friend]
GLMultiTexCoord1sv(GLenum target, const GLshort *v) | GLContext | [friend]
GLMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) | GLContext | [friend]
GLMultiTexCoord2dv(GLenum target, const GLdouble *v) | GLContext | [friend]
GLMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) | GLContext | [friend]
GLMultiTexCoord2fv(GLenum target, const GLfloat *v) | GLContext | [friend]
GLMultiTexCoord2h(GLenum target, GLhalf s, GLhalf t) | GLContext | [friend]
GLMultiTexCoord2hv(GLenum target, const GLhalf *v) | GLContext | [friend]
GLMultiTexCoord2i(GLenum target, GLint s, GLint t) | GLContext | [friend]
GLMultiTexCoord2iv(GLenum target, const GLint *v) | GLContext | [friend]
GLMultiTexCoord2s(GLenum target, GLshort s, GLshort t) | GLContext | [friend]
GLMultiTexCoord2sv(GLenum target, const GLshort *v) | GLContext | [friend]
GLMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) | GLContext | [friend]
GLMultiTexCoord3dv(GLenum target, const GLdouble *v) | GLContext | [friend]
GLMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) | GLContext | [friend]
GLMultiTexCoord3fv(GLenum target, const GLfloat *v) | GLContext | [friend]
GLMultiTexCoord3h(GLenum target, GLhalf s, GLhalf t, GLhalf r) | GLContext | [friend]
GLMultiTexCoord3hv(GLenum target, const GLhalf *v) | GLContext | [friend]
GLMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) | GLContext | [friend]
GLMultiTexCoord3iv(GLenum target, const GLint *v) | GLContext | [friend]
GLMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r) | GLContext | [friend]
GLMultiTexCoord3sv(GLenum target, const GLshort *v) | GLContext | [friend]
GLMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) | GLContext | [friend]
GLMultiTexCoord4dv(GLenum target, const GLdouble *v) | GLContext | [friend]
GLMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) | GLContext | [friend]
GLMultiTexCoord4fv(GLenum target, const GLfloat *v) | GLContext | [friend]
GLMultiTexCoord4h(GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q) | GLContext | [friend]
GLMultiTexCoord4hv(GLenum target, const GLhalf *v) | GLContext | [friend]
GLMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q) | GLContext | [friend]
GLMultiTexCoord4iv(GLenum target, const GLint *v) | GLContext | [friend]
GLMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) | GLContext | [friend]
GLMultiTexCoord4sv(GLenum target, const GLshort *v) | GLContext | [friend]
GLMultiTexCoordPointer(GLenum target, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLMultMatrixd(const GLdouble *m) | GLContext | [friend]
GLMultMatrixf(const GLfloat *m) | GLContext | [friend]
GLMultTransposeMatrixd(const GLdouble *m) | GLContext | [friend]
GLMultTransposeMatrixf(const GLfloat *m) | GLContext | [friend]
GLNewList(GLuint list, GLenum mode) | GLContext | [friend]
GLNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) | GLContext | [friend]
GLNormal3bv(const GLbyte *v) | GLContext | [friend]
GLNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) | GLContext | [friend]
GLNormal3dv(const GLdouble *v) | GLContext | [friend]
GLNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) | GLContext | [friend]
GLNormal3fv(const GLfloat *v) | GLContext | [friend]
GLNormal3h(GLhalf nx, GLhalf ny, GLhalf nz) | GLContext | [friend]
GLNormal3hv(const GLhalf *v) | GLContext | [friend]
GLNormal3i(GLint nx, GLint ny, GLint nz) | GLContext | [friend]
GLNormal3iv(const GLint *v) | GLContext | [friend]
GLNormal3s(GLshort nx, GLshort ny, GLshort nz) | GLContext | [friend]
GLNormal3sv(const GLshort *v) | GLContext | [friend]
GLNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) | GLContext | [friend]
GLPassThrough(GLfloat token) | GLContext | [friend]
GLPixelDataRange(GLenum target, GLsizei size, const GLvoid *pointer) | GLContext | [friend]
GLPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values) | GLContext | [friend]
GLPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values) | GLContext | [friend]
GLPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values) | GLContext | [friend]
GLPixelStoref(GLenum pname, GLfloat param) | GLContext | [friend]
GLPixelStorei(GLenum pname, GLint param) | GLContext | [friend]
GLPixelTransferf(GLenum pname, GLfloat param) | GLContext | [friend]
GLPixelTransferi(GLenum pname, GLint param) | GLContext | [friend]
GLPixelZoom(GLfloat xfactor, GLfloat yfactor) | GLContext | [friend]
GLPointParameterf(GLenum pname, GLfloat param) | GLContext | [friend]
GLPointParameterfv(GLenum pname, const GLfloat *params) | GLContext | [friend]
GLPointParameteri(GLenum pname, GLint param) | GLContext | [friend]
GLPointParameteriv(GLenum pname, const GLint *params) | GLContext | [friend]
GLPointSize(GLfloat size) | GLContext | [friend]
GLPolygonMode(GLenum face, GLenum mode) | GLContext | [friend]
GLPolygonModeBack(GLenum mode) | GLContext | [friend]
GLPolygonModeFront(GLenum mode) | GLContext | [friend]
GLPolygonModeFrontAndBack(GLenum mode) | GLContext | [friend]
GLPolygonModeLock(GLenum face, GLenum mode) | GLContext | [friend]
GLPolygonModeUnlock(GLenum face, GLenum mode) | GLContext | [friend]
GLPolygonOffset(GLfloat factor, GLfloat units) | GLContext | [friend]
GLPolygonStipple(const GLubyte *mask) | GLContext | [friend]
GLPopAttrib(void) | GLContext | [friend]
GLPopClientAttrib(void) | GLContext | [friend]
GLPopMatrix(void) | GLContext | [friend]
GLPopName(void) | GLContext | [friend]
GLPrimitiveRestart() | GLContext | [friend]
GLPrimitiveRestartIndex(GLuint index) | GLContext | [friend]
GLPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) | GLContext | [friend]
GLProgramBufferParametersfv(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params) | GLContext | [friend]
GLProgramBufferParametersIiv(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params) | GLContext | [friend]
GLProgramBufferParametersIuiv(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params) | GLContext | [friend]
GLProgramEnvParameter4d(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) | GLContext | [friend]
GLProgramEnvParameter4dv(GLenum target, GLuint index, const GLdouble *params) | GLContext | [friend]
GLProgramEnvParameter4f(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) | GLContext | [friend]
GLProgramEnvParameter4fv(GLenum target, GLuint index, const GLfloat *params) | GLContext | [friend]
GLProgramEnvParameterI4i(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) | GLContext | [friend]
GLProgramEnvParameterI4iv(GLenum target, GLuint index, const GLint *params) | GLContext | [friend]
GLProgramEnvParameterI4ui(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) | GLContext | [friend]
GLProgramEnvParameterI4uiv(GLenum target, GLuint index, const GLuint *params) | GLContext | [friend]
GLProgramEnvParameters4fv(GLenum target, GLuint index, GLsizei count, const GLfloat *params) | GLContext | [friend]
GLProgramEnvParametersI4iv(GLenum target, GLuint index, GLsizei count, const GLint *params) | GLContext | [friend]
GLProgramEnvParametersI4uiv(GLenum target, GLuint index, GLsizei count, const GLuint *params) | GLContext | [friend]
GLProgramLocalParameter4d(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) | GLContext | [friend]
GLProgramLocalParameter4dv(GLenum target, GLuint index, const GLdouble *params) | GLContext | [friend]
GLProgramLocalParameter4f(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) | GLContext | [friend]
GLProgramLocalParameter4fv(GLenum target, GLuint index, const GLfloat *params) | GLContext | [friend]
GLProgramLocalParameterI4i(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) | GLContext | [friend]
GLProgramLocalParameterI4iv(GLenum target, GLuint index, const GLint *params) | GLContext | [friend]
GLProgramLocalParameterI4ui(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) | GLContext | [friend]
GLProgramLocalParameterI4uiv(GLenum target, GLuint index, const GLuint *params) | GLContext | [friend]
GLProgramLocalParameters4fv(GLenum target, GLuint index, GLsizei count, const GLfloat *params) | GLContext | [friend]
GLProgramLocalParametersI4iv(GLenum target, GLuint index, GLsizei count, const GLint *params) | GLContext | [friend]
GLProgramLocalParametersI4uiv(GLenum target, GLuint index, GLsizei count, const GLuint *params) | GLContext | [friend]
GLProgramNamedParameter4d(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) | GLContext | [friend]
GLProgramNamedParameter4dv(GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v) | GLContext | [friend]
GLProgramNamedParameter4f(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) | GLContext | [friend]
GLProgramNamedParameter4fv(GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v) | GLContext | [friend]
GLProgramParameter4d(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) | GLContext | [friend]
GLProgramParameter4dv(GLenum target, GLuint index, const GLdouble *v) | GLContext | [friend]
GLProgramParameter4f(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) | GLContext | [friend]
GLProgramParameter4fv(GLenum target, GLuint index, const GLfloat *v) | GLContext | [friend]
GLProgramParameteri(GLuint program, GLenum pname, GLint value) | GLContext | [friend]
GLProgramParameters4dv(GLenum target, GLuint index, GLsizei count, const GLdouble *v) | GLContext | [friend]
GLProgramParameters4fv(GLenum target, GLuint index, GLsizei count, const GLfloat *v) | GLContext | [friend]
GLProgramString(GLenum target, GLenum format, GLsizei len, const GLvoid *string) | GLContext | [friend]
GLProgramVertexLimit(GLenum target, GLint limit) | GLContext | [friend]
GLPushAttrib(GLbitfield mask) | GLContext | [friend]
GLPushClientAttrib(GLbitfield mask) | GLContext | [friend]
GLPushMatrix(void) | GLContext | [friend]
GLPushName(GLuint name) | GLContext | [friend]
GLRasterPos2d(GLdouble x, GLdouble y) | GLContext | [friend]
GLRasterPos2f(GLfloat x, GLfloat y) | GLContext | [friend]
GLRasterPos2i(GLint x, GLint y) | GLContext | [friend]
GLRasterPos2s(GLshort x, GLshort y) | GLContext | [friend]
GLRasterPos3d(GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLRasterPos3f(GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLRasterPos3i(GLint x, GLint y, GLint z) | GLContext | [friend]
GLRasterPos3s(GLshort x, GLshort y, GLshort z) | GLContext | [friend]
GLRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) | GLContext | [friend]
GLRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) | GLContext | [friend]
GLRasterPos4i(GLint x, GLint y, GLint z, GLint w) | GLContext | [friend]
GLRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) | GLContext | [friend]
GLReadBuffer(GLenum mode) | GLContext | [friend]
GLReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) | GLContext | [friend]
GLRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) | GLContext | [friend]
GLRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) | GLContext | [friend]
GLRecti(GLint x1, GLint y1, GLint x2, GLint y2) | GLContext | [friend]
GLRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) | GLContext | [friend]
GLRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) | GLContext | [friend]
GLRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) | GLContext | [friend]
GLRenderbufferStorageMultisampleCoverage(GLenum target, GLsizei coverage, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) | GLContext | [friend]
GLRenderMode(GLenum mode) | GLContext | [friend]
GLRequestResidentPrograms(GLsizei n, const GLuint *programs) | GLContext | [friend]
GLResetAlphaFunc() | GLContext | [friend]
GLResetAlphaTest() | GLContext | [friend]
GLResetAutoNormal() | GLContext | [friend]
GLResetBlend() | GLContext | [friend]
GLResetBlendFunc() | GLContext | [friend]
GLResetBlendFuncSeparate() | GLContext | [friend]
GLResetClearColor() | GLContext | [friend]
GLResetClearDepth() | GLContext | [friend]
GLResetClearStencil() | GLContext | [friend]
GLResetClipPlane(GLenum plane) | GLContext | [friend]
GLResetClipPlaneEquation(GLenum plane) | GLContext | [friend]
GLResetColorLogicOp() | GLContext | [friend]
GLResetColorMask() | GLContext | [friend]
GLResetColorMaterial() | GLContext | [friend]
GLResetColorMaterialMode() | GLContext | [friend]
GLResetCullFace() | GLContext | [friend]
GLResetCullFaceMode() | GLContext | [friend]
GLResetDepthFunc() | GLContext | [friend]
GLResetDepthMask() | GLContext | [friend]
GLResetDepthRange() | GLContext | [friend]
GLResetDepthTest() | GLContext | [friend]
GLResetDither() | GLContext | [friend]
GLResetFog() | GLContext | [friend]
GLResetFogColor() | GLContext | [friend]
GLResetFogDensity() | GLContext | [friend]
GLResetFogEnd() | GLContext | [friend]
GLResetFogMode() | GLContext | [friend]
GLResetFogStart() | GLContext | [friend]
GLResetFrontFace() | GLContext | [friend]
GLResetHistogram(GLenum target) | GLContext | [friend]
GLResetLight(GLenum light) | GLContext | [friend]
GLResetLightAmbient(GLenum light) | GLContext | [friend]
GLResetLightConstantAttenuation(GLenum light) | GLContext | [friend]
GLResetLightDiffuse(GLenum light) | GLContext | [friend]
GLResetLighting() | GLContext | [friend]
GLResetLightLinearAttenuation(GLenum light) | GLContext | [friend]
GLResetLightModelAmbient() | GLContext | [friend]
GLResetLightModelLocalViewer() | GLContext | [friend]
GLResetLightModelTwoSide() | GLContext | [friend]
GLResetLightPosition(GLenum light) | GLContext | [friend]
GLResetLightQuadraticAttenuation(GLenum light) | GLContext | [friend]
GLResetLightSpecular(GLenum light) | GLContext | [friend]
GLResetLightSpotCutoff(GLenum light) | GLContext | [friend]
GLResetLightSpotDirection(GLenum light) | GLContext | [friend]
GLResetLightSpotExponent(GLenum light) | GLContext | [friend]
GLResetLineSmooth() | GLContext | [friend]
GLResetLineStipple() | GLContext | [friend]
GLResetLineStippleDefinition() | GLContext | [friend]
GLResetLineWidth() | GLContext | [friend]
GLResetLogicOp() | GLContext | [friend]
GLResetMaterialAmbientBack() | GLContext | [friend]
GLResetMaterialAmbientFront() | GLContext | [friend]
GLResetMaterialAmbientFrontAndBack() | GLContext | [friend]
GLResetMaterialDiffuseBack() | GLContext | [friend]
GLResetMaterialDiffuseFront() | GLContext | [friend]
GLResetMaterialDiffuseFrontAndBack() | GLContext | [friend]
GLResetMaterialEmissionBack() | GLContext | [friend]
GLResetMaterialEmissionFront() | GLContext | [friend]
GLResetMaterialEmissionFrontAndBack() | GLContext | [friend]
GLResetMaterialShininessBack() | GLContext | [friend]
GLResetMaterialShininessFront() | GLContext | [friend]
GLResetMaterialShininessFrontAndBack() | GLContext | [friend]
GLResetMaterialSpecularBack() | GLContext | [friend]
GLResetMaterialSpecularFront() | GLContext | [friend]
GLResetMaterialSpecularFrontAndBack() | GLContext | [friend]
GLResetMinmax(GLenum target) | GLContext | [friend]
GLResetNormalize() | GLContext | [friend]
GLResetPointSize() | GLContext | [friend]
GLResetPointSmooth() | GLContext | [friend]
GLResetPolygonModeBack() | GLContext | [friend]
GLResetPolygonModeFront() | GLContext | [friend]
GLResetPolygonModeFrontAndBack() | GLContext | [friend]
GLResetPolygonOffset() | GLContext | [friend]
GLResetPolygonOffsetFill() | GLContext | [friend]
GLResetPolygonOffsetLine() | GLContext | [friend]
GLResetPolygonOffsetPoint() | GLContext | [friend]
GLResetPolygonSmooth() | GLContext | [friend]
GLResetPolygonStipple() | GLContext | [friend]
GLResetScissor() | GLContext | [friend]
GLResetScissorTest() | GLContext | [friend]
GLResetShadeModel() | GLContext | [friend]
GLResetStencilFunc() | GLContext | [friend]
GLResetStencilMask() | GLContext | [friend]
GLResetStencilOp() | GLContext | [friend]
GLResetStencilTest() | GLContext | [friend]
GLResetTexture(GLenum target) | GLContext | [friend]
GLRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLSampleCoverage(GLclampf value, GLboolean invert) | GLContext | [friend]
GLScaled(GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLScalef(GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLScissor(GLint x, GLint y, GLsizei width, GLsizei height) | GLContext | [friend]
GLSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) | GLContext | [friend]
GLSecondaryColor3bv(const GLbyte *v) | GLContext | [friend]
GLSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) | GLContext | [friend]
GLSecondaryColor3dv(const GLdouble *v) | GLContext | [friend]
GLSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue) | GLContext | [friend]
GLSecondaryColor3fv(const GLfloat *v) | GLContext | [friend]
GLSecondaryColor3h(GLhalf red, GLhalf green, GLhalf blue) | GLContext | [friend]
GLSecondaryColor3hv(const GLhalf *v) | GLContext | [friend]
GLSecondaryColor3i(GLint red, GLint green, GLint blue) | GLContext | [friend]
GLSecondaryColor3iv(const GLint *v) | GLContext | [friend]
GLSecondaryColor3s(GLshort red, GLshort green, GLshort blue) | GLContext | [friend]
GLSecondaryColor3sv(const GLshort *v) | GLContext | [friend]
GLSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) | GLContext | [friend]
GLSecondaryColor3ubv(const GLubyte *v) | GLContext | [friend]
GLSecondaryColor3ui(GLuint red, GLuint green, GLuint blue) | GLContext | [friend]
GLSecondaryColor3uiv(const GLuint *v) | GLContext | [friend]
GLSecondaryColor3us(GLushort red, GLushort green, GLushort blue) | GLContext | [friend]
GLSecondaryColor3usv(const GLushort *v) | GLContext | [friend]
GLSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLSelectBuffer(GLsizei size, GLuint *buffer) | GLContext | [friend]
GLSelectTexture(GLenum target) | GLContext | [friend]
GLSelectTextureCoordSet(GLenum target) | GLContext | [friend]
GLSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) | GLContext | [friend]
GLSetFence(GLuint fence, GLenum condition) | GLContext | [friend]
GLSetWindowStereoMode(GLboolean displayMode) | GLContext | [friend]
GLShadeModel(GLenum mode) | GLContext | [friend]
GLShaderSource(GLuint shader, GLsizei count, const GLcharARB **string, const GLint *length) | GLContext | [friend]
GLStencilClearTag(GLsizei tagBits, GLuint clearTag) | GLContext | [friend]
GLStencilFunc(GLenum func, GLint ref, GLuint mask) | GLContext | [friend]
GLStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) | GLContext | [friend]
GLStencilMask(GLuint mask) | GLContext | [friend]
GLStencilMaskSeparate(GLenum face, GLuint mask) | GLContext | [friend]
GLStencilOp(GLenum fail, GLenum zfail, GLenum zpass) | GLContext | [friend]
GLStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) | GLContext | [friend]
GLStringMarker(GLsizei len, const GLvoid *string) | GLContext | [friend]
GLTestFence(GLuint fence) | GLContext | [friend]
GLTexBuffer(GLenum target, GLenum internalformat, GLuint buffer) | GLContext | [friend]
GLTexCoord1d(GLdouble s) | GLContext | [friend]
GLTexCoord1dv(const GLdouble *v) | GLContext | [friend]
GLTexCoord1f(GLfloat s) | GLContext | [friend]
GLTexCoord1fv(const GLfloat *v) | GLContext | [friend]
GLTexCoord1h(GLhalf s) | GLContext | [friend]
GLTexCoord1hv(const GLhalf *v) | GLContext | [friend]
GLTexCoord1i(GLint s) | GLContext | [friend]
GLTexCoord1iv(const GLint *v) | GLContext | [friend]
GLTexCoord1s(GLshort s) | GLContext | [friend]
GLTexCoord1sv(const GLshort *v) | GLContext | [friend]
GLTexCoord2d(GLdouble s, GLdouble t) | GLContext | [friend]
GLTexCoord2dv(const GLdouble *v) | GLContext | [friend]
GLTexCoord2f(GLfloat s, GLfloat t) | GLContext | [friend]
GLTexCoord2fv(const GLfloat *v) | GLContext | [friend]
GLTexCoord2h(GLhalf s, GLhalf t) | GLContext | [friend]
GLTexCoord2hv(const GLhalf *v) | GLContext | [friend]
GLTexCoord2i(GLint s, GLint t) | GLContext | [friend]
GLTexCoord2iv(const GLint *v) | GLContext | [friend]
GLTexCoord2s(GLshort s, GLshort t) | GLContext | [friend]
GLTexCoord2sv(const GLshort *v) | GLContext | [friend]
GLTexCoord3d(GLdouble s, GLdouble t, GLdouble r) | GLContext | [friend]
GLTexCoord3dv(const GLdouble *v) | GLContext | [friend]
GLTexCoord3f(GLfloat s, GLfloat t, GLfloat r) | GLContext | [friend]
GLTexCoord3fv(const GLfloat *v) | GLContext | [friend]
GLTexCoord3h(GLhalf s, GLhalf t, GLhalf r) | GLContext | [friend]
GLTexCoord3hv(const GLhalf *v) | GLContext | [friend]
GLTexCoord3i(GLint s, GLint t, GLint r) | GLContext | [friend]
GLTexCoord3iv(const GLint *v) | GLContext | [friend]
GLTexCoord3s(GLshort s, GLshort t, GLshort r) | GLContext | [friend]
GLTexCoord3sv(const GLshort *v) | GLContext | [friend]
GLTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) | GLContext | [friend]
GLTexCoord4dv(const GLdouble *v) | GLContext | [friend]
GLTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) | GLContext | [friend]
GLTexCoord4fv(const GLfloat *v) | GLContext | [friend]
GLTexCoord4h(GLhalf s, GLhalf t, GLhalf r, GLhalf q) | GLContext | [friend]
GLTexCoord4hv(const GLhalf *v) | GLContext | [friend]
GLTexCoord4i(GLint s, GLint t, GLint r, GLint q) | GLContext | [friend]
GLTexCoord4iv(const GLint *v) | GLContext | [friend]
GLTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) | GLContext | [friend]
GLTexCoord4sv(const GLshort *v) | GLContext | [friend]
GLTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLTexEnvf(GLenum target, GLenum pname, GLfloat param) | GLContext | [friend]
GLTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) | GLContext | [friend]
GLTexEnvi(GLenum target, GLenum pname, GLint param) | GLContext | [friend]
GLTexEnviv(GLenum target, GLenum pname, const GLint *params) | GLContext | [friend]
GLTexGend(GLenum coord, GLenum pname, GLdouble param) | GLContext | [friend]
GLTexGenf(GLenum coord, GLenum pname, GLfloat param) | GLContext | [friend]
GLTexGenfv(GLenum coord, GLenum pname, const GLfloat *param) | GLContext | [friend]
GLTexGeni(GLenum coord, GLenum pname, GLint param) | GLContext | [friend]
GLTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) | GLContext | [friend]
GLTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) | GLContext | [friend]
GLTexImage3D(GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type, const void *pixels) | GLContext | [friend]
GLTexParameterf(GLenum target, GLenum pname, GLfloat param) | GLContext | [friend]
GLTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) | GLContext | [friend]
GLTexParameteri(GLenum target, GLenum pname, GLint param) | GLContext | [friend]
GLTexParameterIiv(GLenum target, GLenum pname, const GLint *params) | GLContext | [friend]
GLTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params) | GLContext | [friend]
GLTexParameteriv(GLenum target, GLenum pname, const GLint *params) | GLContext | [friend]
GLTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) | GLContext | [friend]
GLTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) | GLContext | [friend]
GLTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) | GLContext | [friend]
GLTextureBorderColor(GLenum target, const GLfloat *params) | GLContext | [friend]
GLTextureEnvColor(const GLfloat *params) | GLContext | [friend]
GLTextureEnvMode(GLint param) | GLContext | [friend]
GLTextureMagFilter(GLenum target, GLint param) | GLContext | [friend]
GLTextureMinFilter(GLenum target, GLint param) | GLContext | [friend]
GLTextureWrapR(GLenum target, GLint param) | GLContext | [friend]
GLTextureWrapS(GLenum target, GLint param) | GLContext | [friend]
GLTextureWrapT(GLenum target, GLint param) | GLContext | [friend]
GLTrackMatrix(GLenum target, GLuint address, GLenum matrix, GLenum transform) | GLContext | [friend]
GLTransformFeedbackAttribs(GLuint count, const GLint *attribs, GLenum bufferMode) | GLContext | [friend]
GLTransformFeedbackVaryings(GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode) | GLContext | [friend]
GLTranslated(GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLTranslatef(GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLUniform1f(GLint location, GLfloat v0) | GLContext | [friend]
GLUniform1fv(GLint location, GLsizei count, const GLfloat *value) | GLContext | [friend]
GLUniform1i(GLint location, GLint v0) | GLContext | [friend]
GLUniform1iv(GLint location, GLsizei count, const GLint *value) | GLContext | [friend]
GLUniform1ui(GLint location, GLuint v0) | GLContext | [friend]
GLUniform1uiv(GLint location, GLsizei count, const GLuint *value) | GLContext | [friend]
GLUniform2f(GLint location, GLfloat v0, GLfloat v1) | GLContext | [friend]
GLUniform2fv(GLint location, GLsizei count, const GLfloat *value) | GLContext | [friend]
GLUniform2i(GLint location, GLint v0, GLint v1) | GLContext | [friend]
GLUniform2iv(GLint location, GLsizei count, const GLint *value) | GLContext | [friend]
GLUniform2ui(GLint location, GLuint v0, GLuint v1) | GLContext | [friend]
GLUniform2uiv(GLint location, GLsizei count, const GLuint *value) | GLContext | [friend]
GLUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) | GLContext | [friend]
GLUniform3fv(GLint location, GLsizei count, const GLfloat *value) | GLContext | [friend]
GLUniform3i(GLint location, GLint v0, GLint v1, GLint v2) | GLContext | [friend]
GLUniform3iv(GLint location, GLsizei count, const GLint *value) | GLContext | [friend]
GLUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) | GLContext | [friend]
GLUniform3uiv(GLint location, GLsizei count, const GLuint *value) | GLContext | [friend]
GLUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) | GLContext | [friend]
GLUniform4fv(GLint location, GLsizei count, const GLfloat *value) | GLContext | [friend]
GLUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) | GLContext | [friend]
GLUniform4iv(GLint location, GLsizei count, const GLint *value) | GLContext | [friend]
GLUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) | GLContext | [friend]
GLUniform4uiv(GLint location, GLsizei count, const GLuint *value) | GLContext | [friend]
GLUniformBuffer(GLuint program, GLint location, GLuint buffer) | GLContext | [friend]
GLUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) | GLContext | [friend]
GLUnlockArrays() | GLContext | [friend]
GLUnmapBuffer(GLenum target) | GLContext | [friend]
GLUploadTexImage1D (defined in GLContext) | GLContext | [friend]
GLUploadTexImage1DArray (defined in GLContext) | GLContext | [friend]
GLUploadTexImage2D (defined in GLContext) | GLContext | [friend]
GLUploadTexImage2DArray (defined in GLContext) | GLContext | [friend]
GLUploadTexImage3D (defined in GLContext) | GLContext | [friend]
GLUploadTexImageCube (defined in GLContext) | GLContext | [friend]
GLUploadTexImageRectangle (defined in GLContext) | GLContext | [friend]
GLUseProgram(GLuint program) | GLContext | [friend]
GLUseProgramObject(GLhandleARB programObj) | GLContext | [friend]
GLValidateProgram(GLuint program) | GLContext | [friend]
GLValidBackBufferHint(GLint x, GLint y, GLsizei width, GLsizei height) | GLContext | [friend]
GLVertex2d(GLdouble x, GLdouble y) | GLContext | [friend]
GLVertex2dv(const GLdouble *v) | GLContext | [friend]
GLVertex2f(GLfloat x, GLfloat y) | GLContext | [friend]
GLVertex2fv(const GLfloat *v) | GLContext | [friend]
GLVertex2h(GLhalf x, GLhalf y) | GLContext | [friend]
GLVertex2hv(const GLhalf *v) | GLContext | [friend]
GLVertex2i(GLint x, GLint y) | GLContext | [friend]
GLVertex2iv(const GLint *v) | GLContext | [friend]
GLVertex2s(GLshort x, GLshort y) | GLContext | [friend]
GLVertex2sv(const GLshort *v) | GLContext | [friend]
GLVertex3d(GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLVertex3dv(const GLdouble *v) | GLContext | [friend]
GLVertex3f(GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLVertex3fv(const GLfloat *v) | GLContext | [friend]
GLVertex3h(GLhalf x, GLhalf y, GLhalf z) | GLContext | [friend]
GLVertex3hv(const GLhalf *v) | GLContext | [friend]
GLVertex3i(GLint x, GLint y, GLint z) | GLContext | [friend]
GLVertex3iv(const GLint *v) | GLContext | [friend]
GLVertex3s(GLshort x, GLshort y, GLshort z) | GLContext | [friend]
GLVertex3sv(const GLshort *v) | GLContext | [friend]
GLVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) | GLContext | [friend]
GLVertex4dv(const GLdouble *v) | GLContext | [friend]
GLVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) | GLContext | [friend]
GLVertex4fv(const GLfloat *v) | GLContext | [friend]
GLVertex4h(GLhalf x, GLhalf y, GLhalf z, GLhalf w) | GLContext | [friend]
GLVertex4hv(const GLhalf *v) | GLContext | [friend]
GLVertex4i(GLint x, GLint y, GLint z, GLint w) | GLContext | [friend]
GLVertex4iv(const GLint *v) | GLContext | [friend]
GLVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) | GLContext | [friend]
GLVertex4sv(const GLshort *v) | GLContext | [friend]
GLVertexArrayRange(GLsizei size, const GLvoid *pointer) | GLContext | [friend]
GLVertexAttrib1d(GLuint index, GLdouble x) | GLContext | [friend]
GLVertexAttrib1dv(GLuint index, const GLdouble *v) | GLContext | [friend]
GLVertexAttrib1f(GLuint index, GLfloat x) | GLContext | [friend]
GLVertexAttrib1fv(GLuint index, const GLfloat *v) | GLContext | [friend]
GLVertexAttrib1h(GLuint index, GLhalf x) | GLContext | [friend]
GLVertexAttrib1hv(GLuint index, const GLhalf *v) | GLContext | [friend]
GLVertexAttrib1s(GLuint index, GLshort x) | GLContext | [friend]
GLVertexAttrib1sv(GLuint index, const GLshort *v) | GLContext | [friend]
GLVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) | GLContext | [friend]
GLVertexAttrib2dv(GLuint index, const GLdouble *v) | GLContext | [friend]
GLVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) | GLContext | [friend]
GLVertexAttrib2fv(GLuint index, const GLfloat *v) | GLContext | [friend]
GLVertexAttrib2h(GLuint index, GLhalf x, GLhalf y) | GLContext | [friend]
GLVertexAttrib2hv(GLuint index, const GLhalf *v) | GLContext | [friend]
GLVertexAttrib2s(GLuint index, GLshort x, GLshort y) | GLContext | [friend]
GLVertexAttrib2sv(GLuint index, const GLshort *v) | GLContext | [friend]
GLVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLVertexAttrib3dv(GLuint index, const GLdouble *v) | GLContext | [friend]
GLVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLVertexAttrib3fv(GLuint index, const GLfloat *v) | GLContext | [friend]
GLVertexAttrib3h(GLuint index, GLhalf x, GLhalf y, GLhalf z) | GLContext | [friend]
GLVertexAttrib3hv(GLuint index, const GLhalf *v) | GLContext | [friend]
GLVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) | GLContext | [friend]
GLVertexAttrib3sv(GLuint index, const GLshort *v) | GLContext | [friend]
GLVertexAttrib4bv(GLuint index, const GLbyte *v) | GLContext | [friend]
GLVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) | GLContext | [friend]
GLVertexAttrib4dv(GLuint index, const GLdouble *v) | GLContext | [friend]
GLVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) | GLContext | [friend]
GLVertexAttrib4fv(GLuint index, const GLfloat *v) | GLContext | [friend]
GLVertexAttrib4h(GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w) | GLContext | [friend]
GLVertexAttrib4hv(GLuint index, const GLhalf *v) | GLContext | [friend]
GLVertexAttrib4iv(GLuint index, const GLint *v) | GLContext | [friend]
GLVertexAttrib4Nbv(GLuint index, const GLbyte *v) | GLContext | [friend]
GLVertexAttrib4Niv(GLuint index, const GLint *v) | GLContext | [friend]
GLVertexAttrib4Nsv(GLuint index, const GLshort *v) | GLContext | [friend]
GLVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) | GLContext | [friend]
GLVertexAttrib4Nubv(GLuint index, const GLubyte *v) | GLContext | [friend]
GLVertexAttrib4Nuiv(GLuint index, const GLuint *v) | GLContext | [friend]
GLVertexAttrib4Nusv(GLuint index, const GLushort *v) | GLContext | [friend]
GLVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) | GLContext | [friend]
GLVertexAttrib4sv(GLuint index, const GLshort *v) | GLContext | [friend]
GLVertexAttrib4ub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) | GLContext | [friend]
GLVertexAttrib4ubv(GLuint index, const GLubyte *v) | GLContext | [friend]
GLVertexAttrib4uiv(GLuint index, const GLuint *v) | GLContext | [friend]
GLVertexAttrib4usv(GLuint index, const GLushort *v) | GLContext | [friend]
GLVertexAttribI1i(GLuint index, GLint x) | GLContext | [friend]
GLVertexAttribI1iv(GLuint index, const GLint *v) | GLContext | [friend]
GLVertexAttribI1ui(GLuint index, GLuint x) | GLContext | [friend]
GLVertexAttribI1uiv(GLuint index, const GLuint *v) | GLContext | [friend]
GLVertexAttribI2i(GLuint index, GLint x, GLint y) | GLContext | [friend]
GLVertexAttribI2iv(GLuint index, const GLint *v) | GLContext | [friend]
GLVertexAttribI2ui(GLuint index, GLuint x, GLuint y) | GLContext | [friend]
GLVertexAttribI2uiv(GLuint index, const GLuint *v) | GLContext | [friend]
GLVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z) | GLContext | [friend]
GLVertexAttribI3iv(GLuint index, const GLint *v) | GLContext | [friend]
GLVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z) | GLContext | [friend]
GLVertexAttribI3uiv(GLuint index, const GLuint *v) | GLContext | [friend]
GLVertexAttribI4bv(GLuint index, const GLbyte *v) | GLContext | [friend]
GLVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) | GLContext | [friend]
GLVertexAttribI4iv(GLuint index, const GLint *v) | GLContext | [friend]
GLVertexAttribI4sv(GLuint index, const GLshort *v) | GLContext | [friend]
GLVertexAttribI4ubv(GLuint index, const GLubyte *v) | GLContext | [friend]
GLVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) | GLContext | [friend]
GLVertexAttribI4uiv(GLuint index, const GLuint *v) | GLContext | [friend]
GLVertexAttribI4usv(GLuint index, const GLushort *v) | GLContext | [friend]
GLVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalize, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble *v) | GLContext | [friend]
GLVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat *v) | GLContext | [friend]
GLVertexAttribs1hv(GLuint index, GLsizei count, const GLhalf *v) | GLContext | [friend]
GLVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort *v) | GLContext | [friend]
GLVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble *v) | GLContext | [friend]
GLVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat *v) | GLContext | [friend]
GLVertexAttribs2hv(GLuint index, GLsizei count, const GLhalf *v) | GLContext | [friend]
GLVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort *v) | GLContext | [friend]
GLVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble *v) | GLContext | [friend]
GLVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat *v) | GLContext | [friend]
GLVertexAttribs3hv(GLuint index, GLsizei count, const GLhalf *v) | GLContext | [friend]
GLVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort *v) | GLContext | [friend]
GLVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble *v) | GLContext | [friend]
GLVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat *v) | GLContext | [friend]
GLVertexAttribs4hv(GLuint index, GLsizei count, const GLhalf *v) | GLContext | [friend]
GLVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort *v) | GLContext | [friend]
GLVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte *v) | GLContext | [friend]
GLVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLViewport(GLint x, GLint y, GLsizei width, GLsizei height) | GLContext | [friend]
GLWindowBackBufferHint() | GLContext | [friend]
GLWindowPos2d(GLdouble x, GLdouble y) | GLContext | [friend]
GLWindowPos2dv(const GLdouble *p) | GLContext | [friend]
GLWindowPos2f(GLfloat x, GLfloat y) | GLContext | [friend]
GLWindowPos2fv(const GLfloat *p) | GLContext | [friend]
GLWindowPos2i(GLint x, GLint y) | GLContext | [friend]
GLWindowPos2iv(const GLint *p) | GLContext | [friend]
GLWindowPos2s(GLshort x, GLshort y) | GLContext | [friend]
GLWindowPos2sv(const GLshort *p) | GLContext | [friend]
GLWindowPos3d(GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLWindowPos3dv(const GLdouble *p) | GLContext | [friend]
GLWindowPos3f(GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLWindowPos3fv(const GLfloat *p) | GLContext | [friend]
GLWindowPos3i(GLint x, GLint y, GLint z) | GLContext | [friend]
GLWindowPos3iv(const GLint *p) | GLContext | [friend]
GLWindowPos3s(GLshort x, GLshort y, GLshort z) | GLContext | [friend]
GLWindowPos3sv(const GLshort *p) | GLContext | [friend]
GLXAttachContext (defined in GLContext) | GLContext | [friend]
GLXBindSwapBarrier (defined in GLContext) | GLContext | [friend]
GLXBindTexImage (defined in GLContext) | GLContext | [friend]
GLXBindVideoImage (defined in GLContext) | GLContext | [friend]
GLXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct) | GLContext | [friend]
GLXDestroyContext(Display *dpy, GLXContext ctx) | GLContext | [friend]
GLXDetachContext (defined in GLContext) | GLContext | [friend]
GLXGetCurrentContext() | GLContext | [friend]
GLXGetCurrentDrawable() | GLContext | [friend]
GLXGetVideoDevice (defined in GLContext) | GLContext | [friend]
GLXGetVideoInfo (defined in GLContext) | GLContext | [friend]
GLXGetVideoSync (defined in GLContext) | GLContext | [friend]
GLXJoinSwapGroup (defined in GLContext) | GLContext | [friend]
GLXMakeCurrent (defined in GLContext) | GLContext | [friend]
GLXQueryFrameCount (defined in GLContext) | GLContext | [friend]
GLXQueryMaxSwapGroups (defined in GLContext) | GLContext | [friend]
GLXQuerySwapGroup (defined in GLContext) | GLContext | [friend]
GLXReleaseTexImage (defined in GLContext) | GLContext | [friend]
GLXReleaseVideoDevice (defined in GLContext) | GLContext | [friend]
GLXReleaseVideoImage (defined in GLContext) | GLContext | [friend]
GLXResetFrameCount (defined in GLContext) | GLContext | [friend]
GLXSendPbufferToVideo (defined in GLContext) | GLContext | [friend]
GLXSwapInterval (defined in GLContext) | GLContext | [friend]
GLXWaitVideoSync (defined in GLContext) | GLContext | [friend]
WGLAttachContext (defined in GLContext) | GLContext | [friend]
WGLBindSwapBarrierNV(GLuint group, GLuint barrier) | GLContext | [friend]
WGLBindTexImage(HPBUFFERARB hPbuffer, int iBuffer) | GLContext | [friend]
WGLChoosePixelFormat(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats) | GLContext | [friend]
WGLCreateAffinityDC(const HGPUNV *pGpuList) | GLContext | [friend]
WGLCreateContext(HDC hdc) | GLContext | [friend]
WGLCreatePbuffer(HDC hdc, int pixelFormat, int width, int height, const int *attribList) | GLContext | [friend]
WGLDeleteContext(HGLRC hglrc) | GLContext | [friend]
WGLDeleteDC(HDC hAffinityDC) | GLContext | [friend]
WGLDestroyPbuffer(HPBUFFERARB hPbuffer) | GLContext | [friend]
WGLDetachContext (defined in GLContext) | GLContext | [friend]
WGLEnumGpuDevices(HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice) | GLContext | [friend]
WGLEnumGpus(UINT iIndex, HGPUNV *hGpu) | GLContext | [friend]
WGLEnumGpusFromAffinityDC(HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu) | GLContext | [friend]
WGLGetCurrentContext(void) | GLContext | [friend]
WGLGetCurrentDC(void) | GLContext | [friend]
WGLGetPbufferDC(HPBUFFERARB hPbuffer) | GLContext | [friend]
WGLJoinSwapGroupNV(HDC hDC, GLuint group) | GLContext | [friend]
WGLMakeCurrent (defined in GLContext) | GLContext | [friend]
WGLQueryFrameCountNV(HDC hDC, GLuint *count) | GLContext | [friend]
WGLQueryMaxSwapGroupsNV(HDC hDC, GLuint *maxGroups, GLuint *maxBarriers) | GLContext | [friend]
WGLQueryPbuffer(HPBUFFERARB hPbuffer, int attribute, int *value) | GLContext | [friend]
WGLQuerySwapGroupNV(HDC hDC, GLuint *group, GLuint *barrier) | GLContext | [friend]
WGLReleasePbufferDC(HPBUFFERARB hPbuffer, HDC hdc) | GLContext | [friend]
WGLReleaseTexImage(HPBUFFERARB hPbuffer, int iBuffer) | GLContext | [friend]
WGLResetFrameCountNV(HDC hDC) | GLContext | [friend]
WGLShareLists (defined in GLContext) | GLContext | [friend]
Generated on Tue Jan 15 10:28:55 2008 for NVSGSDK by NVIDIA


GLFunctions Class Reference

The GLFunctions class holds the OpenGL extension function pointers. More...

#include <GLFunctions.h>

List of all members.

Public Member Functions

GLFunctions (void)
Constructor.

~GLFunctions (void)
Destructor.

bool | isAvailable (const std::string &extension) const
Test if a given extension is available on the current context.

bool | isExported (const std::string &extension) const
Test if a given extension is exported on the current context.

int | getVersion () const
Returns the version of the OpenGL available on the target system.

Detailed Description

The GLFunctions class holds the OpenGL extension function pointers.

Just like a GLContext, you will never have to use this class explicitly. A GLContext holds a GLFunctions member to hold the extension functions of that OpenGL context. For every OpenGL context there might exist a different set of extension functions. A GLFunctions holds all function pointers of one context. If you're using the uppercase WGL prefix-functions WGLCreateContext(), WGLMakeCurrent(), and WGLDeleteContext(), one GLFunctions object is maintained per OpenGL context and switched accordingly.

Constructor & Destructor Documentation

GLFunctions ( void )

Constructor.

~GLFunctions ( void )

Destructor.

Member Function Documentation

bool isAvailable ( const std::string & extension ) const [inline]

Test if a given extension is available on the current context.

An OpenGL extension is not only exported, but also available, if all the functions required for that extension are exported.

Note:
Not all exported extensions might be available.
Returns:
true, if the extension is available, otherwise false
Parameters:
extension extension to test

bool isExported ( const std::string & extension ) const [inline]

Test if a given extension is exported on the current context.

An OpenGL extension is exported, if it is part of the return value of glGetString(GL_EXTENSIONS).

Note:
Not all exported extensions might be available.
Returns:
true, if extension is exported, otherwise c\ false
Parameters:
extension extension to test

int getVersion ( ) const [inline]

Returns the version of the OpenGL available on the target system.

Returns:
The floating point version of the OpenGL with the representation major.minor is returned as an integer calculated as 10*major+minor.

The OpenGL version 1.4, for example, will be reported as 14.

The documentation for this class was generated from the following file:
  • GLFunctions.h
Generated on Tue Jan 15 10:28:55 2008 for NVSGSDK by NVIDIA


Member List

GLFunctions Member List

This is the complete list of members for GLFunctions, including all inherited members.
getVersion() const | GLFunctions | [inline]
GLFunctions(void) | GLFunctions |
isAvailable(const std::string &extension) const | GLFunctions | [inline]
isExported(const std::string &extension) const | GLFunctions | [inline]
~GLFunctions(void) | GLFunctions |
Generated on Tue Jan 15 10:28:55 2008 for NVSGSDK by NVIDIA


GLMFCRAWnd Class Reference

OpenGL render area window. More...

#include <GLMFCRAWnd.h>

Inheritance diagram for GLMFCRAWnd:

[legend]
Collaboration diagram for GLMFCRAWnd:

[legend]
List of all members.

Public Member Functions

virtual | ~GLMFCRAWnd (void)
virtual declared destructor.

virtual bool | init (RenderArea *shareArea=NULL)
Overrides RenderArea::init to perform a specialized initialization.

afx_msg BOOL | OnEraseBkgnd (CDC *pDC)
Do nothing in here to avoid flickering.

afx_msg void | OnPaint (void)
Do nothing other than get the CPaintDC and leave.

virtual void | setViewportSize (unsigned int x, unsigned int y)
Overrides RenderArea::setViewportSize.

virtual void | destroy ()
Overrides RenderArea::destroy.

virtual void | triggerRedraw ()
Overrides RenderArea::triggerRedraw.

Protected Member Functions

virtual BOOL | PreCreateWindow (CREATESTRUCT &cs)
Overrides CWnd::PreCreateWindow.

Detailed Description

OpenGL render area window.

This class adds MFC CWnd functionality to the MS Windows specific OpenGL RenderArea. Use one of CWnd's Create()/CreateEx() functions to create the window and then call init() to initialize the render area.

Constructor & Destructor Documentation

virtual ~GLMFCRAWnd ( void ) [virtual]

virtual declared destructor.

Remarks:
The implementation does nothing.

Member Function Documentation

virtual bool init ( RenderArea * shareArea = NULL ) [virtual]

Overrides RenderArea::init to perform a specialized initialization.

Parameters:
shareArea Specifies an optional RenderArea to share 'sharable' objects, like display lists, with.
Returns:
true if initialization completed successfully. false otherwise
Remarks:
The function attaches the window inherited from the CWnd base class to the GLWinRenderArea. After that it calls the GLWinRenderArea::init implementation to perform necessary OpenGL initialization.

Reimplemented from GLWinRenderArea.

afx_msg BOOL OnEraseBkgnd ( CDC * pDC )

Do nothing in here to avoid flickering.

afx_msg void OnPaint ( void )

Do nothing other than get the CPaintDC and leave.

virtual void setViewportSize | ( | unsigned int | x,
 |  | unsigned int | y
 | ) | [virtual]

Overrides RenderArea::setViewportSize.

Parameters:
x | Specifies the new width in pixels
y | Specifies the new height in pixels
Remarks:
The function calls the GLWinRenderArea::setViewportSize implementation and broadcasts the resulting new window size to the CWnd base class object.

Reimplemented from GLWinRenderArea.

virtual void destroy ( ) [virtual]

Overrides RenderArea::destroy.

Remarks:
The function calls the GLWinRenderArea::destroy implementation and after that destroys the window inherited from the CWnd base class.

Reimplemented from GLWinRenderArea.

virtual void triggerRedraw ( ) [virtual]

Overrides RenderArea::triggerRedraw.

Remarks:
The function enqueues an update of the client area of the window inherited from the CWnd base class.

Reimplemented from GLWinRenderArea.

virtual BOOL PreCreateWindow ( CREATESTRUCT & cs ) [protected, virtual]

Overrides CWnd::PreCreateWindow.

Remarks:
The function specifies some additional creation flags necessary for OpenGL enabled windows, and then calls the CWnd::PreCreateWindow implementation.

The documentation for this class was generated from the following file:
  • GLMFCRAWnd.h
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


Member List

GLMFCRAWnd Member List

This is the complete list of members for GLMFCRAWnd, including all inherited members.
attachWindow(HWND hWnd) | GLWinRenderArea | [virtual]
createNewRenderAreaID() | RenderArea | [inline, static]
destroy() | GLMFCRAWnd | [virtual]
disableHWFSAA() | GLWinRenderArea |
enableHWFSAA() | GLWinRenderArea |
forcePixelFormat(int pf) | GLWinRenderArea |
getAppTraverser() const | RenderArea | [inline]
getAspectRatio() const | RenderArea | [inline]
getCullTraverser(unsigned int position) const | RenderArea | [inline]
getNumberOfCullTraverser() const | RenderArea | [inline]
getProblems() | RenderArea | [inline]
getRenderTraverser() const | RenderArea | [inline]
getScene() const | RenderArea | [inline]
getViewportHeight() const | RenderArea | [inline]
getViewportWidth() const | RenderArea | [inline]
getViewState() const | RenderArea | [inline]
GLWinRenderArea(void) | GLWinRenderArea |
init(RenderArea *shareArea=NULL) | GLMFCRAWnd | [virtual]
initGL() | GLWinRenderArea | [protected, virtual]
interruptRender() | RenderArea |
isHWFSAAAvailable() | RenderArea |
isHWFSAAEnabled() | GLWinRenderArea |
isStereoAvailable() | RenderArea |
m_appTraverser | RenderArea | [protected]
m_cullTraverser | RenderArea | [protected]
m_features | RenderArea | [protected]
m_hdc | GLWinRenderArea | [protected]
m_hglrc | GLWinRenderArea | [protected]
m_idRenderArea | RenderArea | [protected, static]
m_numMSBuffers | RenderArea | [protected]
m_problemLog | RenderArea | [protected]
m_raCreated | RenderArea | [protected]
m_raHeight | RenderArea | [protected]
m_raWidth | RenderArea | [protected]
m_renderTraverser | RenderArea | [protected]
m_scene | RenderArea | [protected]
m_viewState | RenderArea | [protected]
makeCurrent(void) | GLWinRenderArea |
NVSG_MULTISAMPLE enum value | RenderArea |
NVSG_STEREO enum value | RenderArea |
OnEraseBkgnd(CDC *pDC) | GLMFCRAWnd |
OnPaint(void) | GLMFCRAWnd |
popCullTraverser() | RenderArea | [inline]
PreCreateWindow(CREATESTRUCT &cs) | GLMFCRAWnd | [protected, virtual]
pushCullTraverser(nvtraverser::CullTraverser *tr) | RenderArea | [inline]
RenderArea() | RenderArea | [protected]
renderScene(void) | GLWinRenderArea | [virtual]
requestHWFSAA(bool on, unsigned int numBuffers) | RenderArea |
requestStereoSupport(bool stereo) | RenderArea |
setAppTraverser(nvtraverser::AppTraverser *tr) | RenderArea | [inline]
setRenderTraverser(nvtraverser::RenderTraverser *tr) | RenderArea | [inline]
setScene(nvsg::SceneHandle *scene) | RenderArea | [virtual]
setSceneData(nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState) | RenderArea |
setViewportSize(unsigned int x, unsigned int y) | GLMFCRAWnd | [virtual]
setViewState(nvsg::ViewStateHandle *viewState) | RenderArea | [virtual]
shareLists(GLWinRenderArea *ra) | GLWinRenderArea |
triggerRedraw() | GLMFCRAWnd | [virtual]
wasRenderInterrupted() const | RenderArea | [inline]
~GLMFCRAWnd(void) | GLMFCRAWnd | [virtual]
~GLWinRenderArea(void) | GLWinRenderArea | [virtual]
~RenderArea() | RenderArea | [virtual]
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


GLObjects Class Reference

The GLObjects class is a container of OpenGL objects. More...

#include <GLObjects.h>

List of all members.

Public Member Functions

GLObjects ()
Constructor.

~GLObjects ()
Destructor.

Detailed Description

The GLObjects class is a container of OpenGL objects.

Just like a GLContext, you will never have to use this class explicitly. A GLContext holds a GLObjects member to cache information about OpenGL objects. OpenGL objects for example are display lists, texture objects, or vertex buffer objects.

Constructor & Destructor Documentation

GLObjects ( )

Constructor.

~GLObjects ( )

Destructor.

The documentation for this class was generated from the following file:
  • GLObjects.h
Generated on Tue Jan 15 10:28:55 2008 for NVSGSDK by NVIDIA


Member List

GLObjects Member List

This is the complete list of members for GLObjects, including all inherited members.
GLObjects() | GLObjects
~GLObjects() | GLObjects
Generated on Tue Jan 15 10:28:55 2008 for NVSGSDK by NVIDIA


GLTexImageFmt Struct Reference

GLTexImageFmt specifies the format and data type of a texture image. More...

#include <GLContext.h>

List of all members.

Public Attributes

GLint | intFmt
The OpenGL internal format of a texture.

GLint | usrFmt
The OpenGL user format of a texture.

GLint | type
The OpenGL type of a texture.

GLint | uploadHint
An upload hint for the texture: 0=glTexImage, 1=PBO.

Detailed Description

GLTexImageFmt specifies the format and data type of a texture image.

Member Data Documentation

GLint intFmt

The OpenGL internal format of a texture.

GLint usrFmt

The OpenGL user format of a texture.

GLint type

The OpenGL type of a texture.

GLint uploadHint

An upload hint for the texture: 0=glTexImage, 1=PBO.

The documentation for this struct was generated from the following file:
  • GLContext.h
Generated on Tue Jan 15 10:28:50 2008 for NVSGSDK by NVIDIA


Member List

GLTexImageFmt Member List

This is the complete list of members for GLTexImageFmt, including all inherited members.
intFmt | GLTexImageFmt
type | GLTexImageFmt
uploadHint | GLTexImageFmt
usrFmt | GLTexImageFmt
Generated on Tue Jan 15 10:28:50 2008 for NVSGSDK by NVIDIA


GLTraverser Class Reference

RenderTraverser using OpenGL. More...

#include <GLTraverser.h>

Inheritance diagram for GLTraverser:

[legend]
Collaboration diagram for GLTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | GLTraverser (void)
Default constructor.

virtual NVSG_API bool | isGeometryCacheTechniqueSupported (GeometryCacheTechnique gct) const
Test on supported geometry caching techniques.

virtual NVSG_API void | setGeometryCacheTechnique (GeometryCacheTechnique gct)
Set the geometry caching technique the render should use.

virtual NVSG_API bool | isJitterTechniqueSupported (JitterTechnique jt) const
Test for support of a jitter technique.

virtual NVSG_API bool | isRenderTechniqueSupported (RenderTechnique rt) const
Test on supported render techniques.

virtual NVSG_API bool | isShadowTechniqueSupported (ShadowTechnique st) const
Test on supported shadowing techniques.

virtual NVSG_API void | setShadowMapSize (unsigned int size)
Set the size of the shadow maps.

virtual NVSG_API void | setShadowTechnique (ShadowTechnique st)
Set the shadow technique to use.

virtual NVSG_API void | setTextureSizeLimit (unsigned int size)
Set the texture size limit.

virtual NVSG_API bool | isTransparencyTechniqueSupported (TransparencyTechnique tt) const
Test on supported transparency techniques.

virtual NVSG_API void | setTransparencyTechnique (TransparencyTechnique tt)
Set the transparency technique the render should use.

virtual NVSG_API bool | isOITTechniqueSupported (OITTechnique ot) const
Test on supported OIT techniques.

virtual NVSG_API void | setOITTechnique (OITTechnique ot)
Set the OIT technique the render should use.

virtual NVSG_API void | setOITMaxPasses (unsigned int maxPasses)
Set the number of maximum passes to achieve the desired transparency effect.

NVSG_API void | setLocalViewer (bool onOff)
Enable/Disable "local viewer".

NVSG_API bool | isLocalViewerEnabled () const
Test if "local viewer" is enabled/disabled.

NVSG_API void | setSeparateSpecularColor (bool onOff)
Enable/Disable "separate specular color".

NVSG_API bool | isSeparateSpecularColorEnabled (void) const
Test if "separate specular color" is enabled/disabled.

NVSG_API void | setTextureGenericGPUFormat (nvsg::TextureImage::TextureGPUFormat fmt)
Enable/Disable a Generic texture format.

NVSG_API nvsg::TextureImage::TextureGPUFormat | getTextureGenericGPUFormat (void) const
Test if Texture Compression is enabled/disabled.

virtual NVSG_API bool | isOcclusionCullingSupported (void) const
Test on occlusion culling support.

virtual NVSG_API unsigned int | createOcclusionCullID (void)
Create an occlusion culling ID.

virtual NVSG_API void | destroyOcclusionCullID (unsigned int id)
Destroy an occlusion culling ID.

virtual NVSG_API unsigned int | getOcclusionCullResult (unsigned int id)
Get the result of an occlusion culling test.

virtual NVSG_API void | beginOcclusionCullQuery (unsigned int id)
Begin an occlusion culling test.

virtual NVSG_API void | endOcclusionCullQuery (unsigned int id)
End an occlusion culling test.

virtual NVSG_API void | hiddenBegin (void)
Begin rendering of the hidden drawing elements.

virtual NVSG_API void | hiddenEnd (void)
End rendering of the hidden drawing elements.

Protected Member Functions

virtual NVSG_API | ~GLTraverser (void)
Default-instantiates a GLTraverser object.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
doApply override to perform a specialized treatment.

virtual NVSG_API void | doRender (nvsg::NodeHandle *root)
doRender override to perform GL-rendering

virtual NVSG_API void | handleLines (const nvsg::Lines *p)
handleLines override for specialized handling of Lines.

virtual NVSG_API void | handleLineStrips (const nvsg::LineStrips *p)
handleLineStrips override for specialized handling of LineStrips.

virtual NVSG_API void | handleMapArray (const nvsg::MapArray *p)
handleMapArray override for specialized handling of MapArray.

virtual NVSG_API void | handleMapElement (const nvsg::MapElement *p)
handleMapElement override for specialized handling of MapElement.

virtual NVSG_API void | handleMapList (const nvsg::MapList *p)
handleMapList override for specialized handling of MapList.

virtual NVSG_API void | handleMapMatrix (const nvsg::MapMatrix *p)
handleMapMatrix override for specialized handling of MapMatrix.

virtual NVSG_API void | handlePoints (const nvsg::Points *p)
handlePoints override for specialized handling of Points.

virtual NVSG_API void | handleQuadMeshes (const nvsg::QuadMeshes *p)
handleQuadMeshes override for specialized handling of QuadMeshes.

virtual NVSG_API void | handleQuads (const nvsg::Quads *p)
handleQuads override for specialized handling of Quads.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *p)
handleQuadStrips override for specialized handling of QuadStrips.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *p)
handleTriangles override for specialized handling of Triangles.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *p)
handleTriFans override for specialized handling of TriFans.

virtual NVSG_API void | handleTriStrips (const nvsg::TriStrips *p)
handleTriStrips override for specialized handling of TriStrips.

virtual NVSG_API void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *p)
handleVertexAttributeSet override for specialized handling of VertexAttributeSet.

virtual NVSG_API void | renderBegin (void)
Begin the rendering process.

virtual NVSG_API void | renderEnd (void)
End the rendering process.

virtual NVSG_API void | renderBlendAttribute (const nvsg::BlendAttribute *p, bool enable)
Render a BlendAttribute out of a render list.

virtual NVSG_API void | renderAlphaTestAttribute (const nvsg::AlphaTestAttribute *p, bool enable)
Render a AlphaTestAttribute out of a render list.

virtual NVSG_API void | renderDepthAttribute (const nvsg::DepthAttribute *p, bool enable)
Render a DepthAttribute out of a render list.

virtual NVSG_API void | renderDirectedLight (const nvsg::DirectedLight *p, bool enable)
Render a DirectedLight out of a render list.

virtual NVSG_API void | renderFaceAttribute (const nvsg::FaceAttribute *p, bool enable)
Render a FaceAttribute out of a render list.

virtual NVSG_API void | renderHighlightBox (const nvsg::HighlightBox *p)
Render a HighlightBox out of a render list.

virtual NVSG_API void | renderHighlightEdges (const nvsg::HighlightEdges *p)
Render a HighlightEdges out of a render list.

virtual NVSG_API void | renderLineAttribute (const nvsg::LineAttribute *p, bool enable)
Render a LineAttribute out of a render list.

virtual NVSG_API void | renderLightingAttribute (const nvsg::LightingAttribute *p, bool enable)
Render a LineAttribute out of a render list.

virtual NVSG_API void | renderLines (const nvsg::Lines *p)
Render a Lines out of a render list.

virtual NVSG_API void | renderLineStrips (const nvsg::LineStrips *p)
Render a LineStrips out of a render list.

virtual NVSG_API void | renderPointAttribute (const nvsg::PointAttribute *p, bool enable)
Render a PointAttribute out of a render list.

virtual NVSG_API void | renderPoints (const nvsg::Points *p)
Render a Points out of a render list.

virtual NVSG_API void | renderMaterial (const nvsg::Material *p, bool enable)
Render a Material out of a render list.

virtual NVSG_API void | renderParallelCamera (const nvsg::ParallelCamera *p)
Render a ParallelCamera out of a render list.

virtual NVSG_API void | renderPerspectiveCamera (const nvsg::PerspectiveCamera *p)
Render a PerspectiveCamera out of a render list.

virtual NVSG_API void | renderPointLight (const nvsg::PointLight *p, bool enable)
Render a PointLight out of a render list.

virtual NVSG_API void | renderQuadMeshes (const nvsg::QuadMeshes *p)
Render a QuadMeshes out of a render list.

virtual NVSG_API void | renderQuads (const nvsg::Quads *p)
Render a Quads out of a render list.

virtual NVSG_API void | renderQuadStrips (const nvsg::QuadStrips *p)
Render a QuadStrips out of a render list.

virtual NVSG_API void | renderSkinnedTriangles (const nvsg::SkinnedTriangles *p)
Render a SkinnedTriangles out of a render list.

virtual NVSG_API void | renderSpotLight (const nvsg::SpotLight *p, bool enable)
Render a SpotLight out of a render list.

virtual NVSG_API void | renderStatePass (const nvsg::StatePass *p)
Render a StateSet out of a render list.

virtual NVSG_API void | renderTextureAttribute (const nvsg::TextureAttribute *p, bool enable)
Render a TextureAttribute out of a render list.

virtual NVSG_API void | renderTextureAttributeItem (const nvsg::TextureAttributeItem *p, unsigned int tu)
Render a TextureAttributeItem out of a render list.

virtual NVSG_API void | renderTriangles (const nvsg::Triangles *p)
Render a Triangles out of a render list.

virtual NVSG_API void | renderTriFans (const nvsg::TriFans *p)
Render a TriFans out of a render list.

virtual NVSG_API void | renderTriStrips (const nvsg::TriStrips *p)
Render a TriStrips out of a render list.

virtual NVSG_API void | renderUnlitColorAttribute (const nvsg::UnlitColorAttribute *p, bool enable)
Render an UnlitColorAttribute out of a render list.

virtual NVSG_API void | setClipPlane (unsigned int index, const nvmath::Plane3f &plane, bool enable)
Set a clipping plane.

virtual NVSG_API void | setTransforms (const nvmath::Mat44f &modelToWorld, const nvmath::Mat44f &worldToModel, bool needsNormalize, bool needsMirror)
Set the current model to world and world to model transforms.

virtual NVSG_API void | assignDirectedLightToEffectLight (nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::DirectedLight *directedLight, const nvmath::Mat44f &modelToWorld)
Assigns current settings of a DirectedLight to the specified effect light parameter.

virtual NVSG_API void | assignPointLightToEffectLight (nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::PointLight *pointLight, const nvmath::Mat44f &modelToWorld)
Assigns current settings of a PointLight to the specified effect light parameter.

virtual NVSG_API void | assignSpotLightToEffectLight (nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::SpotLight *spotLight, const nvmath::Mat44f &modelToWorld)
Assigns current settings of a SpotLight to the specified effect light parameter.

virtual NVSG_API void | overlayBegin (void)
Indication of the beginning of rendering overlay parts.

virtual NVSG_API void | overlayEnd (void)
Indication of the end of rendering overlay parts.

virtual NVSG_API void | transparentBegin (void)
Indication of the beginning of rendering transparent parts.

virtual NVSG_API void | transparentEnd (void)
Indication of the end of rendering transparent parts.

virtual NVSG_API void | highlightBegin (void)
Indication of the beginning of rendering highlighted parts.

virtual NVSG_API void | highlightEnd (void)
Indication of the end of rendering highlighted parts.

virtual NVSG_API void | primitiveSetsBegin ()
Initiates PrimitiveSet rendering.

virtual NVSG_API bool | primitiveSetsEnd ()
Post-processes PrimitiveSet rendering.

Detailed Description

RenderTraverser using OpenGL.

Note:
This traverser requires a valid view state when you call the apply method.

Needs a valid ViewState. Call setViewState prior to apply().

Constructor & Destructor Documentation

NVSG_API GLTraverser ( void )

Default constructor.

virtual NVSG_API ~GLTraverser ( void ) [protected, virtual]

Default-instantiates a GLTraverser object.

Member Function Documentation

virtual NVSG_API bool isGeometryCacheTechniqueSupported ( GeometryCacheTechnique gct ) const [virtual]

Test on supported geometry caching techniques.

Use this method to test if this special geometry caching technique is supported.

Returns:
true - supported, false - not supported.
Note:
GCT_NONE and GCT_DL are supported. GCT_VBO is only supported when the OpenGL extension GL_ARB_vertex_buffer_object is available.
Parameters:
gct GeometryCache technique.

Reimplemented from RenderTraverser.

virtual NVSG_API void setGeometryCacheTechnique ( GeometryCacheTechnique gct ) [virtual]

Set the geometry caching technique the render should use.

Parameters:
gct GeometryCache technique.

Reimplemented from RenderTraverser.

virtual NVSG_API bool isJitterTechniqueSupported ( JitterTechnique jt ) const [virtual]

Test for support of a jitter technique.

Parameters:
jt The jitter technique to test for support.
Returns:
true if the jitter technique jt is supported, otherwise false.
Remarks:
Depending on the current graphics hardware, some jitter techniques might not be supported. Only supported jitter techniques should be used.
Note:
JT_NONE and JT_READ_PIXELS are supported. JT_ACCUM is only supported while the shadow technique is not ST_SHADOW_MAP (because this technique already uses the accumulation buffer). JT_PBUFFER is available under Windows, when the OpenGL extension GL_NV_fragment_program is available.
See also:
getJitterTechnique, setJitterTechnique

Reimplemented from RenderTraverser.

virtual NVSG_API bool isRenderTechniqueSupported ( RenderTechnique rt ) const [virtual]

Test on supported render techniques.

Use this technique to test if this special render technique is currently available.

Returns:
true - supported, false - not supported.
Note:
All render techniques from RT_POINTS to RT_EFFECTED are available.
Parameters:
rt Render technique.

Reimplemented from RenderTraverser.

virtual NVSG_API bool isShadowTechniqueSupported ( ShadowTechnique st ) const [virtual]

Test on supported shadowing techniques.

Use this to test if this special shadow technique is currently available.

Returns:
true - supported, false - not supported.
Note:
ST_NONE is supported. ST_SHADOW_MAP is only supported, if neither the jitter technique is JT_ACCUM (because the ST_SHADOW_MAP would also need the accumulation buffer) nor the transparency technique is TT_ORDER_INDEPENDENT (because the current implementation of order independent transparency uses some small fragment programs, that don't handle texture coordinate generation and an additional depth texture).
Parameters:
st shadow technique to test

Reimplemented from RenderTraverser.

virtual NVSG_API void setShadowMapSize ( unsigned int size ) [virtual]

Set the size of the shadow maps.

The size must be a power of two. The default size is 1024.

Parameters:
size size of the shadow map (power of two!)

Reimplemented from RenderTraverser.

virtual NVSG_API void setShadowTechnique ( ShadowTechnique st ) [virtual]

Set the shadow technique to use.

Returns:
true - everything went fine, false - not set
Parameters:
st shadow technique to use

Reimplemented from RenderTraverser.

virtual NVSG_API void setTextureSizeLimit ( unsigned int size ) [virtual]

Set the texture size limit.

Textures are scaled down to that limit if they are larger.

Note:
Setting the size to 0 (zero), disables texture size limit.

Reimplemented from RenderTraverser.

virtual NVSG_API bool isTransparencyTechniqueSupported ( TransparencyTechnique tt ) const [virtual]

Test on supported transparency techniques.

Use this technique to test if this special transparency technique is currently available.

Returns:
true - supported, false - not supported.
Note:
TT_NONE, TT_STIPPLED, TT_BLENDED, and TT_SORTED_BLENDED are supported. TT_ORDER_INDEPENDENT is only supported, if the OpenGL extension GL_NV_fragment_program is available and the shadow technique is not ST_SHADOW_MAP (because the current implementation of order independent transparency uses some small fragment programs, that don't handle texture coordinate generation and an additional depth texture needed for shadow mapping).
Parameters:
tt Transparency technique.

Reimplemented from RenderTraverser.

virtual NVSG_API void setTransparencyTechnique ( TransparencyTechnique tt ) [virtual]

Set the transparency technique the render should use.

Parameters:
tt Transparency technique.

Reimplemented from RenderTraverser.

virtual NVSG_API bool isOITTechniqueSupported ( OITTechnique ot ) const [virtual]

Test on supported OIT techniques.

Use this technique to test if this special OIT technique is currently available.

Returns:
true - supported, false - not supported.
Note:
Both OT_TEXTURE and OT_PBUFFER are supported if order independent transparency itself is supported.
Parameters:
ot OIT technique

Reimplemented from RenderTraverser.

virtual NVSG_API void setOITTechnique ( OITTechnique ot ) [virtual]

Set the OIT technique the render should use.

Returns:
true - everything went fine, false - not set
Parameters:
ot OIT technique

Reimplemented from RenderTraverser.

virtual NVSG_API void setOITMaxPasses ( unsigned int maxPasses ) [virtual]

Set the number of maximum passes to achieve the desired transparency effect.

Parameters:
maxPasses Maximum passes to render, even when threshold is not reached.

Reimplemented from RenderTraverser.

void setLocalViewer ( bool onOff ) [inline]

Enable/Disable "local viewer".

Use OpenGL light model: "local viewer" After creating a new GLTraverser "local viewer" is turned off.

Parameters:
onOff enables/disables local viewer

bool isLocalViewerEnabled ( ) const [inline]

Test if "local viewer" is enabled/disabled.

Test if "local viewer" is enabled. See glLightModel() and GL_LIGHT_MODEL_LOCAL_VIEWER in the OpenGL documentation for more information.

Returns:
true, if "local viewer" is enabled, otherwise false.

void setSeparateSpecularColor ( bool onOff ) [inline]

Enable/Disable "separate specular color".

Use OpenGL light model: "separate specular color" After creating a new GLTraverser "separate specular color" is turned on.

Parameters:
onOff enables/disables separate specular color

bool isSeparateSpecularColorEnabled ( void ) const [inline]

Test if "separate specular color" is enabled/disabled.

Test if "separate specular color" is enabled. See glLightModel() and GL_LIGHT_MODEL_COLOR_CONTROL in the OpenGL documentation for more information.

Returns:
true, if "separate specular color" is enabled, otherwise false.

void setTextureGenericGPUFormat ( nvsg::TextureImage::TextureGPUFormat fmt ) [inline]

Enable/Disable a Generic texture format.

Provide the GLTraverser a hint to format all textures on upload to conform to the generic format given. For instance, set TGF_COMPRESSED_FIXED to compress all compressable textures, or TGF_NONLINEAR to convert all textures to SRGB. This should be one of the generic formats, and not a specific format, although setting this to be a specific format is not restricted. Setting invalid combinations will cause GL errors.

Setting this value to TGF_DEFAULT (the default) will turn off this feature.

Remarks:
The hint takes effect on textures uploaded AFTER this method is called. Any textures that have already been uploaded are unaffected.

nvsg::TextureImage::TextureGPUFormat getTextureGenericGPUFormat ( void ) const [inline]

Test if Texture Compression is enabled/disabled.

Test if the Texture Compression hint is enabled. Requires ARB_texture_compression extension.

Returns:
true, if Texture Compression hint is enabled, otherwise false.

virtual NVSG_API bool isOcclusionCullingSupported ( void ) const [virtual]

Test on occlusion culling support.

Any render traverser supporting occlusion culling, should return true here.

Returns:
The base implementation returns false.

Reimplemented from RenderTraverser.

virtual NVSG_API unsigned int createOcclusionCullID ( void ) [virtual]

Create an occlusion culling ID.

Any RenderTraverser that supports occlusion culling should overwrite this function. It should return an ID to identify one block of occlusion culling, usually one set of PrimitiveSets. This base implementation always returns 0, that is an invalid ID.

Returns:
new occlusion cull ID.

Reimplemented from RenderTraverser.

virtual NVSG_API void destroyOcclusionCullID ( unsigned int id ) [virtual]

Destroy an occlusion culling ID.

Any RenderTraverser that supports occlusion culling should overwrite this function. It should destroy any information held with the occlusion culling ID id. id was previously returned by createOcclusionCullID(). This base implementation is a NOP.

Reimplemented from RenderTraverser.

virtual NVSG_API unsigned int getOcclusionCullResult ( unsigned int id ) [virtual]

Get the result of an occlusion culling test.

Any RenderTraverser that supports occlusion culling should overwrite this function. This function is called to determine the occlusion culling result with the occlusion culling ID id. It should return the number of samples that were rendered between the corresponding calls to beginOcclusionCullQuery and endOcclusionCullQuery. This base implementation always returns a large number, indicating the tested drawing elements would be visible.

Returns:
The number of samples drawn with the occlusion cull test for the ID id.

Reimplemented from RenderTraverser.

virtual NVSG_API void beginOcclusionCullQuery ( unsigned int id ) [virtual]

Begin an occlusion culling test.

Any RenderTraverser that supports occlusion culling should overwrite this function. This function is called before a block of drawing elements to be tested for occlusion culling. The RenderTraverser should start to gather occlusion culling informations for the occlusion culling ID id. This base implementation is a NOP.

Reimplemented from RenderTraverser.

virtual NVSG_API void endOcclusionCullQuery ( unsigned int id ) [virtual]

End an occlusion culling test.

Any RenderTraverser that supports occlusion culling should overwrite this function. This function is called after a block of drawing elements to be tested for occlusion culling. The RenderTraverser should stop gathering occlusion culling informations for the occlusion culling ID id. This base implementation is a NOP.

Reimplemented from RenderTraverser.

virtual NVSG_API void hiddenBegin ( void ) [virtual]

Begin rendering of the hidden drawing elements.

Any RenderTraverser that supports occlusion culling should overwrite this function. The base implementation is a NOP.

Reimplemented from RenderTraverser.

virtual NVSG_API void hiddenEnd ( void ) [virtual]

End rendering of the hidden drawing elements.

Any RenderTraverser that supports occlusion culling should overwrite this function. The base implementation is a NOP.

Reimplemented from RenderTraverser.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

doApply override to perform a specialized treatment.

Reimplemented from RenderTraverser.

Reimplemented in GLUploadTraverser.

virtual NVSG_API void doRender ( nvsg::NodeHandle * root ) [protected, virtual]

doRender override to perform GL-rendering

Implements RenderTraverser.

Reimplemented in GLUploadTraverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

handleLines override for specialized handling of Lines.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

handleLineStrips override for specialized handling of LineStrips.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleMapArray ( const nvsg::MapArray * p ) [protected, virtual]

handleMapArray override for specialized handling of MapArray.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleMapElement ( const nvsg::MapElement * p ) [protected, virtual]

handleMapElement override for specialized handling of MapElement.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleMapList ( const nvsg::MapList * p ) [protected, virtual]

handleMapList override for specialized handling of MapList.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleMapMatrix ( const nvsg::MapMatrix * p ) [protected, virtual]

handleMapMatrix override for specialized handling of MapMatrix.

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

handlePoints override for specialized handling of Points.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

handleQuadMeshes override for specialized handling of QuadMeshes.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

handleQuads override for specialized handling of Quads.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

handleQuadStrips override for specialized handling of QuadStrips.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

handleTriangles override for specialized handling of Triangles.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

handleTriFans override for specialized handling of TriFans.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

handleTriStrips override for specialized handling of TriStrips.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

handleVertexAttributeSet override for specialized handling of VertexAttributeSet.

Reimplemented from SharedTraverser.

virtual NVSG_API void renderBegin ( void ) [protected, virtual]

Begin the rendering process.

Before rendering the first object, this function is called. The LightModel parameters are set here.

Reimplemented from RenderTraverser.

virtual NVSG_API void renderEnd ( void ) [protected, virtual]

End the rendering process.

After rendering the last object, this function is called.

Reimplemented from RenderTraverser.

virtual NVSG_API void renderBlendAttribute | ( | const nvsg::BlendAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a BlendAttribute out of a render list.

Sets or resets the parameters of the BlendAttribute.

Parameters:
p | BlendAttribute to render
enable | enable (true) or disable (false) this BlendAttribute

Reimplemented from RenderTraverser.

virtual NVSG_API void renderAlphaTestAttribute | ( | const nvsg::AlphaTestAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a AlphaTestAttribute out of a render list.

Sets or resets the parameters of the AlphaTestAttribute.

Parameters:
p | BlendAttribute to render
enable | enable (true) or

Reimplemented from RenderTraverser.

virtual NVSG_API void renderDepthAttribute | ( | const nvsg::DepthAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a DepthAttribute out of a render list.

Sets or resets the parameters of the DepthAttribute.

Parameters:
p | DepthAttribute to render
enable | enable(true) or disable (false) this DepthAttribute

Reimplemented from RenderTraverser.

virtual NVSG_API void renderDirectedLight | ( | const nvsg::DirectedLight * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a DirectedLight out of a render list.

Enables or disables the DirectedLight and sets the lights parameters accordingly.

Parameters:
p | DirectedLight to render
enable | enable (true) or disable (false) this DirectedLight

Reimplemented from RenderTraverser.

virtual NVSG_API void renderFaceAttribute | ( | const nvsg::FaceAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a FaceAttribute out of a render list.

Sets or resets the parameters of the FaceAttribute.

Parameters:
p | FaceAttribute to render
enable | enable (true) or disable (false) this FaceAttribute

Reimplemented from RenderTraverser.

virtual NVSG_API void renderHighlightBox ( const nvsg::HighlightBox * p ) [protected, virtual]

Render a HighlightBox out of a render list.

Draws the HighlightBox.

Parameters:
p HighlightBox to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderHighlightEdges ( const nvsg::HighlightEdges * p ) [protected, virtual]

Render a HighlightEdges out of a render list.

Draws the HighlightEdges.

Parameters:
p HighlightEdges to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderLineAttribute | ( | const nvsg::LineAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a LineAttribute out of a render list.

Sets or resets the parameters of the LineAttribute.

Parameters:
p | LineAttribute to render
enable | enable (true) or disable (false) this LineAttribute

Reimplemented from RenderTraverser.

virtual NVSG_API void renderLightingAttribute | ( | const nvsg::LightingAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a LineAttribute out of a render list.

Sets or resets the parameters of the LineAttribute.

Parameters:
p | LightingAttribute to render
enable | enable (true) or disable (false) this LineAttribute

Reimplemented from RenderTraverser.

virtual NVSG_API void renderLines ( const nvsg::Lines * p ) [protected, virtual]

Render a Lines out of a render list.

Draws the Lines.

Parameters:
p Lines to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Render a LineStrips out of a render list.

Draws the LineStrips.

Parameters:
p LineStrips to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderPointAttribute | ( | const nvsg::PointAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a PointAttribute out of a render list.

Sets or resets the parameters of the PointAttribute.

Parameters:
p | PointAttribute to render
enable | enable (true) or disable (false) this PointAttribute

Reimplemented from RenderTraverser.

virtual NVSG_API void renderPoints ( const nvsg::Points * p ) [protected, virtual]

Render a Points out of a render list.

Draws the Points.

Parameters:
p Points to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderMaterial | ( | const nvsg::Material * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a Material out of a render list.

Sets or resets the parameters of the Material.

Parameters:
p | Material to render
enable | enable (true) or disable (false) this Material

Reimplemented from RenderTraverser.

virtual NVSG_API void renderParallelCamera ( const nvsg::ParallelCamera * p ) [protected, virtual]

Render a ParallelCamera out of a render list.

Sets the current Projection and ModelView matrix.

Parameters:
p ParallelCamera to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderPerspectiveCamera ( const nvsg::PerspectiveCamera * p ) [protected, virtual]

Render a PerspectiveCamera out of a render list.

Sets the current Projection and ModelView matrix.

Parameters:
p PerspectiveCamera to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderPointLight | ( | const nvsg::PointLight * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a PointLight out of a render list.

Enables or disables the PointLight and sets the lights parameters accordingly.

Parameters:
p | PointLight to render
enable | enable (true) or disable (false) this PointLight

Reimplemented from RenderTraverser.

virtual NVSG_API void renderQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Render a QuadMeshes out of a render list.

Draws the QuadMeshes.

Parameters:
p QuadMeshes to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderQuads ( const nvsg::Quads * p ) [protected, virtual]

Render a Quads out of a render list.

Draws the Quads.

Parameters:
p Quads to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Render a QuadStrips out of a render list.

Draws the QuadStrips.

Parameters:
p QuadStrips to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Render a SkinnedTriangles out of a render list.

Draws the current Triangles.

Parameters:
p SkinnedTriangles to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderSpotLight | ( | const nvsg::SpotLight * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a SpotLight out of a render list.

Enables or disables the SpotLight and sets the lights parameters accordingly.

Parameters:
p | SpotLight to render
enable | enable (true) or disable (false) this SpotLight

Reimplemented from RenderTraverser.

virtual NVSG_API void renderStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Render a StateSet out of a render list.

Calls RenderTraverser::renderStatePass() and if order independent transparency is active and its a transparent pass, a special fragment program is bound.

Parameters:
p StateSet to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderTextureAttribute | ( | const nvsg::TextureAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a TextureAttribute out of a render list.

Calls RenderTraverser::renderTextureAttribute() and disables all unused texture units.

Parameters:
p | TextureAttribute to render
enable | enable (true) or disable (false) this TextureAttribute

Reimplemented from RenderTraverser.

virtual NVSG_API void renderTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | p,
 |  | unsigned int | tu
 | ) | [protected, virtual]

Render a TextureAttributeItem out of a render list.

Loads the Texture if necessary, sets the texture matrix, parameters, and environments accordingly, enables the texture unit tu and binds the texture.

Parameters:
p | TextureAttributeItem to render
tu | texture unit to use

Reimplemented from RenderTraverser.

virtual NVSG_API void renderTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Render a Triangles out of a render list.

Draws the Triangles.

Parameters:
p Triangles to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Render a TriFans out of a render list.

Draws the TriFans.

Parameters:
p TriFans to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Render a TriStrips out of a render list.

Draws the TriStrips.

Parameters:
p TriStrips to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderUnlitColorAttribute | ( | const nvsg::UnlitColorAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render an UnlitColorAttribute out of a render list.

Sets or resets the parameters of the UnlitColorAttribute.

Parameters:
p | UnlitColorAttribute to render
enable | enable (true) or disable (false) this UnlitColorAttribute

Reimplemented from RenderTraverser.

virtual NVSG_API void setClipPlane | ( | unsigned int | index,
 |  | const nvmath::Plane3f & | plane,
 |  | bool | enable
 | ) | [protected, virtual]

Set a clipping plane.

Sets plane as a clipping plane.

Parameters:
index | index of the plane
plane | plane to use
enable | enable/disable it

Reimplemented from RenderTraverser.

virtual NVSG_API void setTransforms | ( | const nvmath::Mat44f & | modelToWorld,
 |  | const nvmath::Mat44f & | worldToModel,
 |  | bool | needsNormalize,
 |  | bool | needsMirror
 | ) | [protected, virtual]

Set the current model to world and world to model transforms.

Enables or disables normal normalization according to needsNormalize and loads the ModelView matrix as the concatenation of the modelToWorld and the current worldToView (from the latest camera setting).

Parameters:
modelToWorld | current model to world transform
worldToModel | current world to model transform
needsNormalize | true if these transforms include a scaling
needsMirror | true if these transforms includes a negative scaling

Reimplemented from RenderTraverser.

virtual NVSG_API void assignDirectedLightToEffectLight | ( | nvsg::CgFxEffect * | effect,
 |  | nvsg::CgFxParameter | lightParam,
 |  | const nvsg::DirectedLight * | directedLight,
 |  | const nvmath::Mat44f & | modelToWorld
 | ) | [protected, virtual]

Assigns current settings of a DirectedLight to the specified effect light parameter.

The purpose of this function is to transmit the settings of the specified DirectedLight to the specified effect light through the CgFxEffect interface.

Reimplemented from RenderTraverser.

virtual NVSG_API void assignPointLightToEffectLight | ( | nvsg::CgFxEffect * | effect,
 |  | nvsg::CgFxParameter | lightParam,
 |  | const nvsg::PointLight * | pointLight,
 |  | const nvmath::Mat44f & | modelToWorld
 | ) | [protected, virtual]

Assigns current settings of a PointLight to the specified effect light parameter.

The purpose of this function is to transmit the settings of the specified PointLight to the specified effect light through the CgFxEffect interface.

Reimplemented from RenderTraverser.

virtual NVSG_API void assignSpotLightToEffectLight | ( | nvsg::CgFxEffect * | effect,
 |  | nvsg::CgFxParameter | lightParam,
 |  | const nvsg::SpotLight * | spotLight,
 |  | const nvmath::Mat44f & | modelToWorld
 | ) | [protected, virtual]

Assigns current settings of a SpotLight to the specified effect light parameter.

The purpose of this function is to transmit the settings of the specified SpotLight to the specified effect light through the CgFxEffect interface.

Reimplemented from RenderTraverser.

virtual NVSG_API void overlayBegin ( void ) [protected, virtual]

Indication of the beginning of rendering overlay parts.

Reimplemented from RenderTraverser.

virtual NVSG_API void overlayEnd ( void ) [protected, virtual]

Indication of the end of rendering overlay parts.

Reimplemented from RenderTraverser.

virtual NVSG_API void transparentBegin ( void ) [protected, virtual]

Indication of the beginning of rendering transparent parts.

Reimplemented from RenderTraverser.

virtual NVSG_API void transparentEnd ( void ) [protected, virtual]

Indication of the end of rendering transparent parts.

Reimplemented from RenderTraverser.

virtual NVSG_API void highlightBegin ( void ) [protected, virtual]

Indication of the beginning of rendering highlighted parts.

Reimplemented from RenderTraverser.

virtual NVSG_API void highlightEnd ( void ) [protected, virtual]

Indication of the end of rendering highlighted parts.

Reimplemented from RenderTraverser.

virtual NVSG_API void primitiveSetsBegin ( ) [protected, virtual]

Initiates PrimitiveSet rendering.

Reimplemented from RenderTraverser.

virtual NVSG_API bool primitiveSetsEnd ( ) [protected, virtual]

Post-processes PrimitiveSet rendering.

Returns:
true if the PrimitiveSets need to be re-processed again. Otherwise the function returns false.

Reimplemented from RenderTraverser.

The documentation for this class was generated from the following file:
  • GLTraverser.h
Generated on Tue Jan 15 10:29:30 2008 for NVSGSDK by NVIDIA


Member List

GLTraverser Member List

This is the complete list of members for GLTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addObjectRenderer(unsigned int objectCode, RendererType renderer) | RenderTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
assignCustomLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::LightSource *customLight, const nvmath::Mat44f &modelToWorld) | RenderTraverser | [protected, virtual]
assignDirectedLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::DirectedLight *directedLight, const nvmath::Mat44f &modelToWorld) | GLTraverser | [protected, virtual]
assignPointLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::PointLight *pointLight, const nvmath::Mat44f &modelToWorld) | GLTraverser | [protected, virtual]
assignSpotLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::SpotLight *spotLight, const nvmath::Mat44f &modelToWorld) | GLTraverser | [protected, virtual]
beginOcclusionCullQuery(unsigned int id) | GLTraverser | [virtual]
clearRenderLists(void) | RenderTraverser | [protected]
createOcclusionCullID(void) | GLTraverser | [virtual]
destroyOcclusionCullID(unsigned int id) | GLTraverser | [virtual]
doApply(nvsg::NodeHandle *root) | GLTraverser | [protected, virtual]
doRender(nvsg::NodeHandle *root) | GLTraverser | [protected, virtual]
endOcclusionCullQuery(unsigned int id) | GLTraverser | [virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
GCT_DL enum value | RenderTraverser |
GCT_NONE enum value | RenderTraverser |
GCT_VBO enum value | RenderTraverser |
GeometryCacheTechnique enum name | RenderTraverser |
getCollectRenderElements(void) const | RenderTraverser | [protected]
getCurrentCgFx(void) const | RenderTraverser | [inline, protected]
getFaceMode(void) const | RenderTraverser | [inline]
getGeometryCacheTechnique(void) const | RenderTraverser | [inline]
getJitterTechnique(void) const | RenderTraverser | [inline]
getLineWidth(void) const | RenderTraverser | [inline]
getOcclusionCullResult(unsigned int id) | GLTraverser | [virtual]
getOITMaxPasses(void) const | RenderTraverser | [inline]
getOITTechnique(void) const | RenderTraverser | [inline]
getOITThreshold(void) const | RenderTraverser | [inline]
getPointSize(void) const | RenderTraverser | [inline]
getRasterOffsetX() const | RenderTraverser | [inline, protected]
getRasterOffsetY() const | RenderTraverser | [inline, protected]
getRenderTechnique(void) const | RenderTraverser | [inline]
getShadowMapIntensity(void) const | RenderTraverser | [inline]
getShadowMapSize(void) const | RenderTraverser | [inline]
getShadowTechnique(void) const | RenderTraverser | [inline]
getSortingPolicy(void) const | RenderTraverser | [inline]
getTextureGenericGPUFormat(void) const | GLTraverser | [inline]
getTextureSizeLimit(void) const | RenderTraverser | [inline]
getTransparencyTechnique(void) const | RenderTraverser | [inline]
GLTraverser(void) | GLTraverser |
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SharedModelViewTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *p) | RenderTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | RenderTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *anim) | SharedTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *gnode) | SharedTraverser | [protected, virtual]
handleGroup(const nvsg::Group *group) | SharedTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | GLTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | GLTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *lod) | SharedModelViewTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | GLTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | GLTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | GLTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | GLTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | GLTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | GLTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | GLTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | GLTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | RenderTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *swtch) | SharedTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | RenderTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | GLTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | GLTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | GLTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | GLTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *p) | RenderTraverser | [protected, virtual]
hiddenBegin(void) | GLTraverser | [virtual]
hiddenEnd(void) | GLTraverser | [virtual]
highlightBegin(void) | GLTraverser | [protected, virtual]
highlightEnd(void) | GLTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isBackFaceCulling() const | RenderTraverser | [inline]
isFaceCullingOverwrite() const | RenderTraverser | [inline]
isFaceModeOverwrite() const | RenderTraverser | [inline]
isFrontFaceCulling() const | RenderTraverser | [inline]
isGeometryCacheTechniqueSupported(GeometryCacheTechnique gct) const | GLTraverser | [virtual]
isHighlightPass(void) const | RenderTraverser | [inline, protected]
isJitterTechniqueSupported(JitterTechnique jt) const | GLTraverser | [virtual]
isLineAntiAliasingEnabled(void) const | RenderTraverser | [inline]
isLocalViewerEnabled() const | GLTraverser | [inline]
isOcclusionCulling(void) const | RenderTraverser | [inline]
isOcclusionCullingSupported(void) const | GLTraverser | [virtual]
isOITTechniqueSupported(OITTechnique ot) const | GLTraverser | [virtual]
isOverlayPass(void) const | RenderTraverser | [inline, protected]
isPointAntiAliasingEnabled(void) const | RenderTraverser | [inline]
isRenderTechniqueSupported(RenderTechnique rt) const | GLTraverser | [virtual]
isSeparateSpecularColorEnabled(void) const | GLTraverser | [inline]
isShadowTechniqueSupported(ShadowTechnique st) const | GLTraverser | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparencyTechniqueSupported(TransparencyTechnique tt) const | GLTraverser | [virtual]
isTransparentPass(void) const | RenderTraverser | [inline, protected]
isTwoSidedLighting() const | RenderTraverser | [inline]
isTwoSidedLightingOverwrite() const | RenderTraverser | [inline]
JitterTechnique enum name | RenderTraverser |
JT_ACCUM enum value | RenderTraverser |
JT_FBO enum value | RenderTraverser |
JT_NONE enum value | RenderTraverser |
JT_PBUFFER enum value | RenderTraverser |
JT_READ_PIXELS enum value | RenderTraverser |
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedModelViewTraverser | [protected, virtual]
m_collectRenderElements (defined in RenderTraverser) | RenderTraverser | [protected]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_currentRenderElement (defined in RenderTraverser) | RenderTraverser | [protected]
m_hiddenOpaqueList (defined in RenderTraverser) | RenderTraverser | [protected]
m_hiddenTransparentList (defined in RenderTraverser) | RenderTraverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lastRenderElement (defined in RenderTraverser) | RenderTraverser | [protected]
m_lockedCamera | SharedModelViewTraverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | SharedModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
m_visibleOpaqueList (defined in RenderTraverser) | RenderTraverser | [protected]
m_visibleTransparentList (defined in RenderTraverser) | RenderTraverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
occlusionTest(std::list< RenderElement * > &visibleList, std::list< RenderElement * > &hiddenList) | RenderTraverser | [protected]
OITTechnique enum name | RenderTraverser |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OT_FBO enum value | RenderTraverser |
OT_PBUFFER enum value | RenderTraverser |
OT_TEXTURE enum value | RenderTraverser |
overlayBegin(void) | GLTraverser | [protected, virtual]
overlayEnd(void) | GLTraverser | [protected, virtual]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, unsigned int i) | RenderTraverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | RenderTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, unsigned int i) | RenderTraverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | RenderTraverser | [protected, virtual]
primitiveSetsBegin() | GLTraverser | [protected, virtual]
primitiveSetsEnd() | GLTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
renderAlphaTestAttribute(const nvsg::AlphaTestAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderBegin(void) | GLTraverser | [protected, virtual]
renderBillboard(const nvsg::Billboard *p) | RenderTraverser | [protected, virtual]
renderBlendAttribute(const nvsg::BlendAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderCgFx(const nvsg::CgFx *p, bool enable) | RenderTraverser | [protected, virtual]
renderDepthAttribute(const nvsg::DepthAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderDirectedLight(const nvsg::DirectedLight *p, bool enable) | GLTraverser | [protected, virtual]
renderEnd(void) | GLTraverser | [protected, virtual]
renderFaceAttribute(const nvsg::FaceAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderHighlightBox(const nvsg::HighlightBox *p) | GLTraverser | [protected, virtual]
renderHighlightEdges(const nvsg::HighlightEdges *p) | GLTraverser | [protected, virtual]
renderLightingAttribute(const nvsg::LightingAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderLineAttribute(const nvsg::LineAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderLines(const nvsg::Lines *p) | GLTraverser | [protected, virtual]
renderLineStrips(const nvsg::LineStrips *p) | GLTraverser | [protected, virtual]
renderMaterial(const nvsg::Material *p, bool enable) | GLTraverser | [protected, virtual]
renderObject(nvsg::ObjectHandle *oh) | RenderTraverser | [inline, protected]
renderObject(nvsg::ObjectHandle *oh, T arg) | RenderTraverser | [inline, protected]
renderParallelCamera(const nvsg::ParallelCamera *p) | GLTraverser | [protected, virtual]
renderPerspectiveCamera(const nvsg::PerspectiveCamera *p) | GLTraverser | [protected, virtual]
renderPointAttribute(const nvsg::PointAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderPointLight(const nvsg::PointLight *p, bool enable) | GLTraverser | [protected, virtual]
renderPoints(const nvsg::Points *p) | GLTraverser | [protected, virtual]
renderQuadMeshes(const nvsg::QuadMeshes *p) | GLTraverser | [protected, virtual]
renderQuads(const nvsg::Quads *p) | GLTraverser | [protected, virtual]
renderQuadStrips(const nvsg::QuadStrips *p) | GLTraverser | [protected, virtual]
renderSkinnedTriangles(const nvsg::SkinnedTriangles *p) | GLTraverser | [protected, virtual]
renderSpotLight(const nvsg::SpotLight *p, bool enable) | GLTraverser | [protected, virtual]
renderStatePass(const nvsg::StatePass *p) | GLTraverser | [protected, virtual]
RenderTechnique enum name | RenderTraverser |
renderTextureAttribute(const nvsg::TextureAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderTextureAttributeItem(const nvsg::TextureAttributeItem *p, unsigned int tu) | GLTraverser | [protected, virtual]
renderTransform(const nvsg::Transform *p) | RenderTraverser | [protected, virtual]
RenderTraverser(void) | RenderTraverser | [protected]
renderTriangles(const nvsg::Triangles *p) | GLTraverser | [protected, virtual]
renderTriFans(const nvsg::TriFans *p) | GLTraverser | [protected, virtual]
renderTriStrips(const nvsg::TriStrips *p) | GLTraverser | [protected, virtual]
renderUnlitColorAttribute(const nvsg::UnlitColorAttribute *p, bool enable) | GLTraverser | [protected, virtual]
RT_EFFECTED enum value | RenderTraverser |
RT_SHADED enum value | RenderTraverser |
RT_TEXTURED enum value | RenderTraverser |
RT_UNLIT enum value | RenderTraverser |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane, bool enable) | GLTraverser | [protected, virtual]
setCollectRenderElements(bool value) | RenderTraverser | [protected]
setFaceCulling(bool front, bool back) | RenderTraverser | [inline]
setFaceCullingOverwrite(bool overwrite) | RenderTraverser | [inline]
setFaceMode(nvsg::FaceMode mode) | RenderTraverser | [inline]
setFaceModeOverwrite(bool overwrite) | RenderTraverser | [inline]
setGeometryCacheTechnique(GeometryCacheTechnique gct) | GLTraverser | [virtual]
setJitterTechnique(JitterTechnique jt) | RenderTraverser | [inline]
setLineAntiAliasing(bool onOff) | RenderTraverser | [inline]
setLineWidth(float width) | RenderTraverser | [inline]
setLocalViewer(bool onOff) | GLTraverser | [inline]
setOcclusionCulling(bool onOff) | RenderTraverser | [virtual]
setOITMaxPasses(unsigned int maxPasses) | GLTraverser | [virtual]
setOITTechnique(OITTechnique ot) | GLTraverser | [virtual]
setOITThreshold(float threshold) | RenderTraverser | [inline]
setPointAntiAliasing(bool onOff) | RenderTraverser | [inline]
setPointSize(float size) | RenderTraverser | [inline]
setRenderTechnique(RenderTechnique rt) | RenderTraverser |
setScene(nvsg::SceneHandle *scene) | Traverser |
setSeparateSpecularColor(bool onOff) | GLTraverser | [inline]
setShadowMapIntensity(float intensity) | RenderTraverser | [inline]
setShadowMapSize(unsigned int size) | GLTraverser | [virtual]
setShadowTechnique(ShadowTechnique st) | GLTraverser | [virtual]
setSortingPolicy(SortingPolicy sp) | RenderTraverser | [inline]
setTextureGenericGPUFormat(nvsg::TextureImage::TextureGPUFormat fmt) | GLTraverser | [inline]
setTextureSizeLimit(unsigned int size) | GLTraverser | [virtual]
setTransforms(const nvmath::Mat44f &modelToWorld, const nvmath::Mat44f &worldToModel, bool needsNormalize, bool needsMirror) | GLTraverser | [protected, virtual]
setTransparencyTechnique(TransparencyTechnique tt) | GLTraverser | [virtual]
setTwoSidedLighting(bool enable) | RenderTraverser | [inline]
setTwoSidedLightingOverwrite(bool overwrite) | RenderTraverser | [inline]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
ShadowTechnique enum name | RenderTraverser |
SharedModelViewTraverser() | SharedModelViewTraverser | [protected]
SharedTraverser() | SharedTraverser |
SortingPolicy enum name | RenderTraverser |
SP_DEPTH enum value | RenderTraverser |
SP_NONE enum value | RenderTraverser |
SP_STATE enum value | RenderTraverser |
ST_NONE enum value | RenderTraverser |
ST_SHADOW_MAP enum value | RenderTraverser |
theAllocator typedef | IAllocator |
TransparencyTechnique enum name | RenderTraverser |
transparentBegin(void) | GLTraverser | [protected, virtual]
transparentEnd(void) | GLTraverser | [protected, virtual]
traverseCamera(const nvsg::Camera *camera) | SharedModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | RenderTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | RenderTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
TT_BLENDED enum value | RenderTraverser |
TT_MULTISAMPLE enum value | RenderTraverser |
TT_NONE enum value | RenderTraverser |
TT_ORDER_INDEPENDENT enum value | RenderTraverser |
TT_SORTED_BLENDED enum value | RenderTraverser |
TT_STIPPLED enum value | RenderTraverser |
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~GLTraverser(void) | GLTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~RenderTraverser(void) | RenderTraverser | [protected, virtual]
~SharedModelViewTraverser() | SharedModelViewTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:30 2008 for NVSGSDK by NVIDIA


GLUploadTraverser Class Reference

UploadTraverser using OpenGL. More...

#include <GLUploadTraverser.h>

Inheritance diagram for GLUploadTraverser:

[legend]
Collaboration diagram for GLUploadTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | GLUploadTraverser (bool display)
Default constructor.

Protected Member Functions

virtual NVSG_API | ~GLUploadTraverser (void)
Destructor.

virtual NVSG_API void | handleLOD (const nvsg::LOD *lod)
Handler function for an LOD.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *swtch)
Handler function for a Switch.

virtual NVSG_API void | lockViewState ()
Override for locking the ViewState.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
doApply override to perform a specialized treatment.

virtual NVSG_API void | doRender (nvsg::NodeHandle *root)
doRender override to perform GL-rendering

Detailed Description

UploadTraverser using OpenGL.

Remarks:
This traverser will upload (and optionally display) data (such as texture maps) so that they do not have to be uploaded at runtime.
Note:
This traverser requires a valid OpenGL context to be current when constructing the object. Behavior is undefined if there is no current context.

Constructor & Destructor Documentation

NVSG_API GLUploadTraverser ( bool display )

Default constructor.

Parameters:
display Displays the textures/geometry as it is loaded.
Remarks:
There must be a current OpenGL context available during construction.

virtual NVSG_API ~GLUploadTraverser ( void ) [protected, virtual]

Destructor.

Member Function Documentation

virtual NVSG_API void handleLOD ( const nvsg::LOD * lod ) [protected, virtual]

Handler function for an LOD.

Parameters:
lod A pointer to the read-locked LOD being traversed.
Remarks:
This function is called from the framework whenever an LOD is encountered on traversal. The LOD lod is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * swtch ) [protected, virtual]

Handler function for a Switch.

Parameters:
swtch A pointer to the read-locked Switch being traversed.
Remarks:
This function is called from the framework whenever a Switch is encountered on traversal. The Switch switch is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented from SharedTraverser.

virtual NVSG_API void lockViewState ( ) [protected, virtual]

Override for locking the ViewState.

Remarks:
This function is called from the framework when the ViewState set by setViewState is to be locked.
See also:
setViewState, unlockViewState

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

doApply override to perform a specialized treatment.

Reimplemented from GLTraverser.

virtual NVSG_API void doRender ( nvsg::NodeHandle * root ) [protected, virtual]

doRender override to perform GL-rendering

Reimplemented from GLTraverser.

The documentation for this class was generated from the following file:
  • GLUploadTraverser.h
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


Member List

GLUploadTraverser Member List

This is the complete list of members for GLUploadTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addObjectRenderer(unsigned int objectCode, RendererType renderer) | RenderTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
assignCustomLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::LightSource *customLight, const nvmath::Mat44f &modelToWorld) | RenderTraverser | [protected, virtual]
assignDirectedLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::DirectedLight *directedLight, const nvmath::Mat44f &modelToWorld) | GLTraverser | [protected, virtual]
assignPointLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::PointLight *pointLight, const nvmath::Mat44f &modelToWorld) | GLTraverser | [protected, virtual]
assignSpotLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::SpotLight *spotLight, const nvmath::Mat44f &modelToWorld) | GLTraverser | [protected, virtual]
beginOcclusionCullQuery(unsigned int id) | GLTraverser | [virtual]
clearRenderLists(void) | RenderTraverser | [protected]
createOcclusionCullID(void) | GLTraverser | [virtual]
destroyOcclusionCullID(unsigned int id) | GLTraverser | [virtual]
doApply(nvsg::NodeHandle *root) | GLUploadTraverser | [protected, virtual]
doRender(nvsg::NodeHandle *root) | GLUploadTraverser | [protected, virtual]
endOcclusionCullQuery(unsigned int id) | GLTraverser | [virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
GCT_DL enum value | RenderTraverser |
GCT_NONE enum value | RenderTraverser |
GCT_VBO enum value | RenderTraverser |
GeometryCacheTechnique enum name | RenderTraverser |
getCollectRenderElements(void) const | RenderTraverser | [protected]
getCurrentCgFx(void) const | RenderTraverser | [inline, protected]
getFaceMode(void) const | RenderTraverser | [inline]
getGeometryCacheTechnique(void) const | RenderTraverser | [inline]
getJitterTechnique(void) const | RenderTraverser | [inline]
getLineWidth(void) const | RenderTraverser | [inline]
getOcclusionCullResult(unsigned int id) | GLTraverser | [virtual]
getOITMaxPasses(void) const | RenderTraverser | [inline]
getOITTechnique(void) const | RenderTraverser | [inline]
getOITThreshold(void) const | RenderTraverser | [inline]
getPointSize(void) const | RenderTraverser | [inline]
getRasterOffsetX() const | RenderTraverser | [inline, protected]
getRasterOffsetY() const | RenderTraverser | [inline, protected]
getRenderTechnique(void) const | RenderTraverser | [inline]
getShadowMapIntensity(void) const | RenderTraverser | [inline]
getShadowMapSize(void) const | RenderTraverser | [inline]
getShadowTechnique(void) const | RenderTraverser | [inline]
getSortingPolicy(void) const | RenderTraverser | [inline]
getTextureGenericGPUFormat(void) const | GLTraverser | [inline]
getTextureSizeLimit(void) const | RenderTraverser | [inline]
getTransparencyTechnique(void) const | RenderTraverser | [inline]
GLTraverser(void) | GLTraverser |
GLUploadTraverser(bool display) | GLUploadTraverser |
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SharedModelViewTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *p) | RenderTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | RenderTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *anim) | SharedTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *gnode) | SharedTraverser | [protected, virtual]
handleGroup(const nvsg::Group *group) | SharedTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | GLTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | GLTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *lod) | GLUploadTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | GLTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | GLTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | GLTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | GLTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | GLTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | GLTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | GLTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | GLTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | RenderTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *swtch) | GLUploadTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | RenderTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | GLTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | GLTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | GLTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | GLTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *p) | RenderTraverser | [protected, virtual]
hiddenBegin(void) | GLTraverser | [virtual]
hiddenEnd(void) | GLTraverser | [virtual]
highlightBegin(void) | GLTraverser | [protected, virtual]
highlightEnd(void) | GLTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isBackFaceCulling() const | RenderTraverser | [inline]
isFaceCullingOverwrite() const | RenderTraverser | [inline]
isFaceModeOverwrite() const | RenderTraverser | [inline]
isFrontFaceCulling() const | RenderTraverser | [inline]
isGeometryCacheTechniqueSupported(GeometryCacheTechnique gct) const | GLTraverser | [virtual]
isHighlightPass(void) const | RenderTraverser | [inline, protected]
isJitterTechniqueSupported(JitterTechnique jt) const | GLTraverser | [virtual]
isLineAntiAliasingEnabled(void) const | RenderTraverser | [inline]
isLocalViewerEnabled() const | GLTraverser | [inline]
isOcclusionCulling(void) const | RenderTraverser | [inline]
isOcclusionCullingSupported(void) const | GLTraverser | [virtual]
isOITTechniqueSupported(OITTechnique ot) const | GLTraverser | [virtual]
isOverlayPass(void) const | RenderTraverser | [inline, protected]
isPointAntiAliasingEnabled(void) const | RenderTraverser | [inline]
isRenderTechniqueSupported(RenderTechnique rt) const | GLTraverser | [virtual]
isSeparateSpecularColorEnabled(void) const | GLTraverser | [inline]
isShadowTechniqueSupported(ShadowTechnique st) const | GLTraverser | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparencyTechniqueSupported(TransparencyTechnique tt) const | GLTraverser | [virtual]
isTransparentPass(void) const | RenderTraverser | [inline, protected]
isTwoSidedLighting() const | RenderTraverser | [inline]
isTwoSidedLightingOverwrite() const | RenderTraverser | [inline]
JitterTechnique enum name | RenderTraverser |
JT_ACCUM enum value | RenderTraverser |
JT_FBO enum value | RenderTraverser |
JT_NONE enum value | RenderTraverser |
JT_PBUFFER enum value | RenderTraverser |
JT_READ_PIXELS enum value | RenderTraverser |
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | GLUploadTraverser | [protected, virtual]
m_collectRenderElements (defined in RenderTraverser) | RenderTraverser | [protected]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_currentRenderElement (defined in RenderTraverser) | RenderTraverser | [protected]
m_hiddenOpaqueList (defined in RenderTraverser) | RenderTraverser | [protected]
m_hiddenTransparentList (defined in RenderTraverser) | RenderTraverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lastRenderElement (defined in RenderTraverser) | RenderTraverser | [protected]
m_lockedCamera | SharedModelViewTraverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | SharedModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
m_visibleOpaqueList (defined in RenderTraverser) | RenderTraverser | [protected]
m_visibleTransparentList (defined in RenderTraverser) | RenderTraverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
occlusionTest(std::list< RenderElement * > &visibleList, std::list< RenderElement * > &hiddenList) | RenderTraverser | [protected]
OITTechnique enum name | RenderTraverser |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OT_FBO enum value | RenderTraverser |
OT_PBUFFER enum value | RenderTraverser |
OT_TEXTURE enum value | RenderTraverser |
overlayBegin(void) | GLTraverser | [protected, virtual]
overlayEnd(void) | GLTraverser | [protected, virtual]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, unsigned int i) | RenderTraverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | RenderTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, unsigned int i) | RenderTraverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | RenderTraverser | [protected, virtual]
primitiveSetsBegin() | GLTraverser | [protected, virtual]
primitiveSetsEnd() | GLTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
renderAlphaTestAttribute(const nvsg::AlphaTestAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderBegin(void) | GLTraverser | [protected, virtual]
renderBillboard(const nvsg::Billboard *p) | RenderTraverser | [protected, virtual]
renderBlendAttribute(const nvsg::BlendAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderCgFx(const nvsg::CgFx *p, bool enable) | RenderTraverser | [protected, virtual]
renderDepthAttribute(const nvsg::DepthAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderDirectedLight(const nvsg::DirectedLight *p, bool enable) | GLTraverser | [protected, virtual]
renderEnd(void) | GLTraverser | [protected, virtual]
renderFaceAttribute(const nvsg::FaceAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderHighlightBox(const nvsg::HighlightBox *p) | GLTraverser | [protected, virtual]
renderHighlightEdges(const nvsg::HighlightEdges *p) | GLTraverser | [protected, virtual]
renderLightingAttribute(const nvsg::LightingAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderLineAttribute(const nvsg::LineAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderLines(const nvsg::Lines *p) | GLTraverser | [protected, virtual]
renderLineStrips(const nvsg::LineStrips *p) | GLTraverser | [protected, virtual]
renderMaterial(const nvsg::Material *p, bool enable) | GLTraverser | [protected, virtual]
renderObject(nvsg::ObjectHandle *oh) | RenderTraverser | [inline, protected]
renderObject(nvsg::ObjectHandle *oh, T arg) | RenderTraverser | [inline, protected]
renderParallelCamera(const nvsg::ParallelCamera *p) | GLTraverser | [protected, virtual]
renderPerspectiveCamera(const nvsg::PerspectiveCamera *p) | GLTraverser | [protected, virtual]
renderPointAttribute(const nvsg::PointAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderPointLight(const nvsg::PointLight *p, bool enable) | GLTraverser | [protected, virtual]
renderPoints(const nvsg::Points *p) | GLTraverser | [protected, virtual]
renderQuadMeshes(const nvsg::QuadMeshes *p) | GLTraverser | [protected, virtual]
renderQuads(const nvsg::Quads *p) | GLTraverser | [protected, virtual]
renderQuadStrips(const nvsg::QuadStrips *p) | GLTraverser | [protected, virtual]
renderSkinnedTriangles(const nvsg::SkinnedTriangles *p) | GLTraverser | [protected, virtual]
renderSpotLight(const nvsg::SpotLight *p, bool enable) | GLTraverser | [protected, virtual]
renderStatePass(const nvsg::StatePass *p) | GLTraverser | [protected, virtual]
RenderTechnique enum name | RenderTraverser |
renderTextureAttribute(const nvsg::TextureAttribute *p, bool enable) | GLTraverser | [protected, virtual]
renderTextureAttributeItem(const nvsg::TextureAttributeItem *p, unsigned int tu) | GLTraverser | [protected, virtual]
renderTransform(const nvsg::Transform *p) | RenderTraverser | [protected, virtual]
RenderTraverser(void) | RenderTraverser | [protected]
renderTriangles(const nvsg::Triangles *p) | GLTraverser | [protected, virtual]
renderTriFans(const nvsg::TriFans *p) | GLTraverser | [protected, virtual]
renderTriStrips(const nvsg::TriStrips *p) | GLTraverser | [protected, virtual]
renderUnlitColorAttribute(const nvsg::UnlitColorAttribute *p, bool enable) | GLTraverser | [protected, virtual]
RT_EFFECTED enum value | RenderTraverser |
RT_SHADED enum value | RenderTraverser |
RT_TEXTURED enum value | RenderTraverser |
RT_UNLIT enum value | RenderTraverser |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane, bool enable) | GLTraverser | [protected, virtual]
setCollectRenderElements(bool value) | RenderTraverser | [protected]
setFaceCulling(bool front, bool back) | RenderTraverser | [inline]
setFaceCullingOverwrite(bool overwrite) | RenderTraverser | [inline]
setFaceMode(nvsg::FaceMode mode) | RenderTraverser | [inline]
setFaceModeOverwrite(bool overwrite) | RenderTraverser | [inline]
setGeometryCacheTechnique(GeometryCacheTechnique gct) | GLTraverser | [virtual]
setJitterTechnique(JitterTechnique jt) | RenderTraverser | [inline]
setLineAntiAliasing(bool onOff) | RenderTraverser | [inline]
setLineWidth(float width) | RenderTraverser | [inline]
setLocalViewer(bool onOff) | GLTraverser | [inline]
setOcclusionCulling(bool onOff) | RenderTraverser | [virtual]
setOITMaxPasses(unsigned int maxPasses) | GLTraverser | [virtual]
setOITTechnique(OITTechnique ot) | GLTraverser | [virtual]
setOITThreshold(float threshold) | RenderTraverser | [inline]
setPointAntiAliasing(bool onOff) | RenderTraverser | [inline]
setPointSize(float size) | RenderTraverser | [inline]
setRenderTechnique(RenderTechnique rt) | RenderTraverser |
setScene(nvsg::SceneHandle *scene) | Traverser |
setSeparateSpecularColor(bool onOff) | GLTraverser | [inline]
setShadowMapIntensity(float intensity) | RenderTraverser | [inline]
setShadowMapSize(unsigned int size) | GLTraverser | [virtual]
setShadowTechnique(ShadowTechnique st) | GLTraverser | [virtual]
setSortingPolicy(SortingPolicy sp) | RenderTraverser | [inline]
setTextureGenericGPUFormat(nvsg::TextureImage::TextureGPUFormat fmt) | GLTraverser | [inline]
setTextureSizeLimit(unsigned int size) | GLTraverser | [virtual]
setTransforms(const nvmath::Mat44f &modelToWorld, const nvmath::Mat44f &worldToModel, bool needsNormalize, bool needsMirror) | GLTraverser | [protected, virtual]
setTransparencyTechnique(TransparencyTechnique tt) | GLTraverser | [virtual]
setTwoSidedLighting(bool enable) | RenderTraverser | [inline]
setTwoSidedLightingOverwrite(bool overwrite) | RenderTraverser | [inline]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
ShadowTechnique enum name | RenderTraverser |
SharedModelViewTraverser() | SharedModelViewTraverser | [protected]
SharedTraverser() | SharedTraverser |
SortingPolicy enum name | RenderTraverser |
SP_DEPTH enum value | RenderTraverser |
SP_NONE enum value | RenderTraverser |
SP_STATE enum value | RenderTraverser |
ST_NONE enum value | RenderTraverser |
ST_SHADOW_MAP enum value | RenderTraverser |
theAllocator typedef | IAllocator |
TransparencyTechnique enum name | RenderTraverser |
transparentBegin(void) | GLTraverser | [protected, virtual]
transparentEnd(void) | GLTraverser | [protected, virtual]
traverseCamera(const nvsg::Camera *camera) | SharedModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | RenderTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | RenderTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
TT_BLENDED enum value | RenderTraverser |
TT_MULTISAMPLE enum value | RenderTraverser |
TT_NONE enum value | RenderTraverser |
TT_ORDER_INDEPENDENT enum value | RenderTraverser |
TT_SORTED_BLENDED enum value | RenderTraverser |
TT_STIPPLED enum value | RenderTraverser |
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~GLTraverser(void) | GLTraverser | [protected, virtual]
~GLUploadTraverser(void) | GLUploadTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~RenderTraverser(void) | RenderTraverser | [protected, virtual]
~SharedModelViewTraverser() | SharedModelViewTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


GLWinRenderArea Class Reference

RenderArea class for MS Windows OpenGL. More...

#include <GLWinRenderArea.h>

Inheritance diagram for GLWinRenderArea:

[legend]
Collaboration diagram for GLWinRenderArea:

[legend]
List of all members.

Public Member Functions

NVSG_API | GLWinRenderArea (void)
Default constructor.

virtual NVSG_API | ~GLWinRenderArea (void)
Default destructor.

virtual NVSG_API bool | attachWindow (HWND hWnd)
Attach a window to the render area.

virtual NVSG_API bool | init (RenderArea *shareArea=NULL)
Initialize the GLWinRenderArea.

virtual NVSG_API void | destroy (void)
Destroy the render area.

NVSG_API void | makeCurrent (void)
Make OpenGL context current.

virtual NVSG_API void | setViewportSize (unsigned int x, unsigned int y)
Handle the viewport resizing.

NVSG_API bool | shareLists (GLWinRenderArea *ra)
Share the OpenGL lists.

virtual NVSG_API void | renderScene (void)
Render the scene.

virtual NVSG_API void | triggerRedraw (void)
Trigger a redraw of the scene.

NVSG_API void | enableHWFSAA ()
Turn on HWFSAA.

NVSG_API void | disableHWFSAA ()
Turn off HWFSAA.

NVSG_API bool | isHWFSAAEnabled ()
Check if hardware accelerated full-scene anti-aliasing (FSAA) is turned on.

NVSG_API void | forcePixelFormat (int pf)
Force the usage of the specified pixel format.

Protected Member Functions

virtual NVSG_API bool | initGL ()
Initialize additional OpenGL features.

Protected Attributes

HGLRC | m_hglrc
Our OpenGL context.

HDC | m_hdc
Our device context.

Detailed Description

RenderArea class for MS Windows OpenGL.

Namespace: nvui
Remarks:
This class is responsible for MS Windows specific OpenGL functionality. It sets up and destroys the OpenGL context, handles the creation, pixel format, refresh, etc.
The GLWinRenderArea creates an nvtraverser::GLTraverser as the default nvtraverser::RenderTraverser during initialization.
The user can request stereo support - quad-buffered OpenGL stereo - and hardware full-scene antialiasing.

Constructor & Destructor Documentation

NVSG_API GLWinRenderArea ( void )

Default constructor.

virtual NVSG_API ~GLWinRenderArea ( void ) [virtual]

Default destructor.

Member Function Documentation

virtual NVSG_API bool attachWindow ( HWND hWnd ) [virtual]

Attach a window to the render area.

Parameters:
hWnd The window handle of an existing OpenGL-aware window.
Returns:
When the function succeeds, the return value is true.
Remarks:
You have to create an OpenGL capable (WS_CLIPCHILDREN | WS_CLIPSIBLINGS) window and attach it before calling GLWinRenderArea::init or you can derive from this class to integrate the functionality.
Example
This sample code demonstrates how to set up a simple Renderer without MFC. For more details, see the ConsoleViewer tutorial source code.
The Renderer class is derived from GLWinRenderArea. CreateWindow creates a window object that is used as the RenderAreas OpenGL output window.
  bool Renderer::setupRenderArea()
  {
    [...]
    // Create a simple window for the OpenGL context.
    m_hWnd = CreateWindow( "VIEWER"
                         , "NVSG Renderer"
                         , WS_CLIPCHILDREN | WS_CLIPSIBLINGS
                         , 100, 100
                         , 250, 250
                         , NULL
                         , NULL
                         , m_hInst
                         , NULL);

    attachWindow(m_hWnd);
    init();
    setViewportSize(100, 100);
    [...]
  }
See also:
RenderArea::attachWindow, GLMFCRAWnd, GLWinRenderArea

virtual NVSG_API bool init ( RenderArea * shareArea = NULL ) [virtual]

Initialize the GLWinRenderArea.

Parameters:
shareArea Pointer to a RenderArea to share information with. If you do not want to share with another RenderArea, provide NULL.
Returns:
When the function succeeds, the return value is true.
Remarks:
This overload initializes the GLWinRenderArea. In addition to the base class implementation it takes care of choosing the right pixel format by calling GLWinRenderArea::determinePixelFormat and creating an OpenGL rendering context. Additionally, it creates an nvtraverser::GLTraverser as the nvtraverser::RenderTraverser for scene rendering. You can derive from this class and overwrite this function if you, for example, want to implement a RenderArea that renders into a PBuffer.

If the return value is false you can examine the root cause by calling RenderArea::getProblems and evaluating the nvutil::ProblemLogList.
See also:
RenderArea::init, determinePixelFormat

Reimplemented from RenderArea.

Reimplemented in GLMFCRAWnd.

virtual NVSG_API void destroy ( void ) [virtual]

Destroy the render area.

Remarks:
This function destroys and cleans up the GLWinRenderArea. It calls the base class implementation RenderArea::destroy to clean up all the registered traversers. It also destroys the OpenGL context and releases all used resources.
See also:
RenderArea::destroy

Reimplemented from RenderArea.

Reimplemented in GLMFCRAWnd.

NVSG_API void makeCurrent ( void )

Make OpenGL context current.

Remarks:
This is a more clever way to make the context current. This function minimizes wglMakeCurrent calls.

Do not use wglMakeCurrent. Use makeCurrent since this is optimized for NVSG usage.
See also:
nvgl::WGLMakeCurrent

virtual NVSG_API void setViewportSize | ( | unsigned int | x,
 |  | unsigned int | y
 | ) | [virtual]

Handle the viewport resizing.

Parameters:
x | Width of the viewport
y | Height of the viewport
Remarks:
Resize the viewport. React on parent window size changes and report to OpenGL by setting the GLViewport and call the base class implementation.
See also:
RenderArea::setViewportSize

Reimplemented from RenderArea.

Reimplemented in GLMFCRAWnd.

NVSG_API bool shareLists ( GLWinRenderArea * ra )

Share the OpenGL lists.

Parameters:
ra Pointer to the GLWinRenderArea to share with.
Returns:
When the function succeeds, the return value is true.
Remarks:
Share display lists, textures, vertex programs, etc. with another rendering context. It basically makes use of wglShareLists.
See also:
nvgl::WGLShareLists

virtual NVSG_API void renderScene ( void ) [virtual]

Render the scene.

Remarks:
Render the entire scene. This overload makes the OpenGL context current, clears the depth and the color buffer, calls the registered nvtraverser::AppTraverser, nvtraverser::CullTraverser and nvtraverser::RenderTraverser through the base class and swaps the buffers so the result will be visible.

Do not call this function directly. See RenderArea::renderScene for more details on this topic.
See also:
RenderArea::renderScene

Reimplemented from RenderArea.

virtual NVSG_API void triggerRedraw ( void ) [virtual]

Trigger a redraw of the scene.

Remarks:
This overload does the Windows-specific InvalidateRect(NULL) call to trigger a call to the OnDraw-handler where you then can call GLWinRenderArea::renderScene. See RenderArea::triggerRedraw for more information on this topic.
See also:
RenderArea::triggerRedraw, RenderArea::renderScene

Reimplemented from RenderArea.

Reimplemented in GLMFCRAWnd.

NVSG_API void enableHWFSAA ( )

Turn on HWFSAA.

Remarks:
If you have requested a multi-sample pixel format, you can turn on HWFSAA. Be sure to have a multi-sample format by using RenderArea::isHWFSAAAvailable to check it.

No redraw is triggered; the caller must call GLWinRenderArea::triggerRedraw.

If the GL_NV_multisample_filter_hint extension is available we set it to quality mode.
See also:
disableHWFSAA, isHWFSAAEnabled, isHWFSAAAvailable, requestHWFSAA

NVSG_API void disableHWFSAA ( )

Turn off HWFSAA.

Remarks:
If you have requested a multi-sample pixel format you can turn off HWFSAA.

No redraw is triggered; the caller must call triggerRedraw.
See also:
enableHWFSAA, isHWFSAAEnabled, isHWFSAAAvailable, requestHWFSAA

NVSG_API bool isHWFSAAEnabled ( )

Check if hardware accelerated full-scene anti-aliasing (FSAA) is turned on.

Returns:
When hardware accelerated FSAA is tuned on, the return value is true.
Remarks:
Determine if hardware accelerated FSAA is turned on or off. Make sure to have a multi-sample format by using RenderArea::isHWFSAAAvailable to check it.
See also:
enableHWFSAA, isHWFSAAAvailable, requestHWFSAA

NVSG_API void forcePixelFormat ( int pf )

Force the usage of the specified pixel format.

Parameters:
pf The pixel format to use.
Remarks:
This function should be used only before the RenderArea is initialized using.
See also:
init

virtual NVSG_API bool initGL ( ) [protected, virtual]

Initialize additional OpenGL features.

Returns:
When the function succeeds, the return value is true.
Remarks:
This is a handy function that is called from GLWinRenderArea::init. Overload this virtual function to extend the initialization of additional OpenGL features (e.g. framelock extensions, ...).
See also:
init

Member Data Documentation

HGLRC m_hglrc [protected]

Our OpenGL context.

HDC m_hdc [protected]

Our device context.

The documentation for this class was generated from the following file:
  • GLWinRenderArea.h
Generated on Tue Jan 15 10:29:41 2008 for NVSGSDK by NVIDIA


Member List

GLWinRenderArea Member List

This is the complete list of members for GLWinRenderArea, including all inherited members.
attachWindow(HWND hWnd) | GLWinRenderArea | [virtual]
createNewRenderAreaID() | RenderArea | [inline, static]
destroy(void) | GLWinRenderArea | [virtual]
disableHWFSAA() | GLWinRenderArea |
enableHWFSAA() | GLWinRenderArea |
forcePixelFormat(int pf) | GLWinRenderArea |
getAppTraverser() const | RenderArea | [inline]
getAspectRatio() const | RenderArea | [inline]
getCullTraverser(unsigned int position) const | RenderArea | [inline]
getNumberOfCullTraverser() const | RenderArea | [inline]
getProblems() | RenderArea | [inline]
getRenderTraverser() const | RenderArea | [inline]
getScene() const | RenderArea | [inline]
getViewportHeight() const | RenderArea | [inline]
getViewportWidth() const | RenderArea | [inline]
getViewState() const | RenderArea | [inline]
GLWinRenderArea(void) | GLWinRenderArea |
init(RenderArea *shareArea=NULL) | GLWinRenderArea | [virtual]
initGL() | GLWinRenderArea | [protected, virtual]
interruptRender() | RenderArea |
isHWFSAAAvailable() | RenderArea |
isHWFSAAEnabled() | GLWinRenderArea |
isStereoAvailable() | RenderArea |
m_appTraverser | RenderArea | [protected]
m_cullTraverser | RenderArea | [protected]
m_features | RenderArea | [protected]
m_hdc | GLWinRenderArea | [protected]
m_hglrc | GLWinRenderArea | [protected]
m_idRenderArea | RenderArea | [protected, static]
m_numMSBuffers | RenderArea | [protected]
m_problemLog | RenderArea | [protected]
m_raCreated | RenderArea | [protected]
m_raHeight | RenderArea | [protected]
m_raWidth | RenderArea | [protected]
m_renderTraverser | RenderArea | [protected]
m_scene | RenderArea | [protected]
m_viewState | RenderArea | [protected]
makeCurrent(void) | GLWinRenderArea |
NVSG_MULTISAMPLE enum value | RenderArea |
NVSG_STEREO enum value | RenderArea |
popCullTraverser() | RenderArea | [inline]
pushCullTraverser(nvtraverser::CullTraverser *tr) | RenderArea | [inline]
RenderArea() | RenderArea | [protected]
renderScene(void) | GLWinRenderArea | [virtual]
requestHWFSAA(bool on, unsigned int numBuffers) | RenderArea |
requestStereoSupport(bool stereo) | RenderArea |
setAppTraverser(nvtraverser::AppTraverser *tr) | RenderArea | [inline]
setRenderTraverser(nvtraverser::RenderTraverser *tr) | RenderArea | [inline]
setScene(nvsg::SceneHandle *scene) | RenderArea | [virtual]
setSceneData(nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState) | RenderArea |
setViewportSize(unsigned int x, unsigned int y) | GLWinRenderArea | [virtual]
setViewState(nvsg::ViewStateHandle *viewState) | RenderArea | [virtual]
shareLists(GLWinRenderArea *ra) | GLWinRenderArea |
triggerRedraw(void) | GLWinRenderArea | [virtual]
wasRenderInterrupted() const | RenderArea | [inline]
~GLWinRenderArea(void) | GLWinRenderArea | [virtual]
~RenderArea() | RenderArea | [virtual]
Generated on Tue Jan 15 10:29:41 2008 for NVSGSDK by NVIDIA


GPUSkinningProcessor Class Reference

GPUSkinningProcessor Class. More...

#include <GPUSkinningProcessor.h>

List of all members.

Public Member Functions

NVSG_API | GPUSkinningProcessor ()
Default constructor.

virtual NVSG_API void | process (bool process)
apply to scene

virtual NVSG_API AppTraverser::SkinningProcessorType | getType ()

Static Public Member Functions

NVSG_API bool | isSupported (void)
is this processor supported on the current architecture?

Protected Member Functions

virtual NVSG_API | ~GPUSkinningProcessor ()
Default destructor.

Detailed Description

GPUSkinningProcessor Class.

A processor that performs skinning on the CPU.

Note:
Needs a valid ViewState. Call setViewState prior to apply().

Constructor & Destructor Documentation

NVSG_API GPUSkinningProcessor ( )

Default constructor.

virtual NVSG_API ~GPUSkinningProcessor ( ) [protected, virtual]

Default destructor.

Member Function Documentation

virtual NVSG_API void process ( bool process ) [virtual]

apply to scene

NVSG_API bool isSupported ( void ) [static]

is this processor supported on the current architecture?

The documentation for this class was generated from the following file:
  • GPUSkinningProcessor.h
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


Member List

GPUSkinningProcessor Member List

This is the complete list of members for GPUSkinningProcessor, including all inherited members.
getType() (defined in GPUSkinningProcessor) | GPUSkinningProcessor | [virtual]
GPUSkinningProcessor() | GPUSkinningProcessor |
isSupported(void) | GPUSkinningProcessor | [static]
process(bool process) | GPUSkinningProcessor | [virtual]
~GPUSkinningProcessor() | GPUSkinningProcessor | [protected, virtual]
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


Group Class Reference

Provides grouping of Node objects. More...

#include <Group.h>

Inheritance diagram for Group:

[legend]
Collaboration diagram for Group:

[legend]
List of all members.

Public Member Functions

NVSG_API | Group ()
Default-constructs a Group object.

NVSG_API | Group (const Node &rhs)
Constructs a Group from a Node.

NVSG_API | Group (const Group &rhs)
Constructs a Group as a copy of another Group.

virtual NVSG_API | ~Group ()
Destructs a Group object.

NVSG_API unsigned int | getNumberOfChildren () const
Returns the number child nodes for this Group.

NVSG_API unsigned int | addChild (NodeHandle *child, unsigned int position=~0)
Adds a child node.

NVSG_API NodeHandle * | getChild (unsigned int position) const
Returns the child node at a specified position.

NVSG_API bool | removeChild (NodeHandle *child)
Removes all occurrences of a specified child node from this Group.

NVSG_API void | removeChild (unsigned int position)
Removes the child node at the specified position.

NVSG_API bool | replaceChild (NodeHandle *newChild, NodeHandle *oldChild)
Replaces all occurrences of a child node.

NVSG_API void | replaceChild (NodeHandle *newChild, unsigned int position)
Replaces the child node at the specified position.

NVSG_API bool | hasChild (NodeHandle *node) const
Tests whether a specified Node is a child node of this Group.

NVSG_API bool | getChildPositions (NodeHandle *node, std::vector< unsigned int > &positions) const
Returns all occurring positions of a specified child node.

NVSG_API unsigned int | getNumberOfClipPlanes () const
Get the number of clipping planes in this Group.

NVSG_API unsigned int | getNumberOfActiveClipPlanes () const
Get the number of active clipping planes in this Group.

NVSG_API bool | isClipPlaneActive (unsigned int index) const
Ask if the specified clipping plane is active.

NVSG_API const nvmath::Plane3f & | getClipPlane (unsigned int index) const
Returns the specified clipping plane.

NVSG_API void | addClipPlane (const nvmath::Plane3f &plane, bool active=true)
Adds a clipping plane to this Group.

NVSG_API void | activateClipPlane (unsigned int index)
Activates the specified clip plane.

NVSG_API void | deactivateClipPlane (unsigned int index)
Deactivates the specified clip plane.

NVSG_API void | setClipPlane (unsigned int index, const nvmath::Plane3f &plane)
Sets the plane at the specified index.

NVSG_API unsigned int | getNumberOfLightSources () const
Returns the number light sources for this Group.

NVSG_API LightSourceHandle * | getLightSource (unsigned int index) const
Returns the light source at a specified index.

NVSG_API bool | hasLightSource (LightSourceHandle *lsHdl) const
Tests whether a specified LightSource is part of this Group.

NVSG_API void | addLightSource (LightSourceHandle *lsHdl)
Adds a light source.

NVSG_API void | replaceLightSource (unsigned int index, LightSourceHandle *lsHdl)
Replaces the light source at the specified position.

NVSG_API void | replaceLightSource (LightSourceHandle *newHdl, LightSourceHandle *oldHdl)
Replaces a LightSource by an other.

NVSG_API void | removeLightSource (unsigned int index)
Removes the light source at the specified position.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Overrides Object::isEquivalent.

NVSG_API Group & | operator= (const Group &rhs)
Assigns new content from another Group object.

virtual NVSG_API bool | validateIncarnation () const
Validates all incarnations down the hierarchy.

Protected Member Functions

virtual NVSG_API void | preRemoveChild (unsigned int position)
Called from the framework immediately before a child will be removed from the Group.

virtual NVSG_API void | postRemoveChild (unsigned int position)
Called from the framework immediately after a child has been removed from the Group.

virtual NVSG_API void | preAddChild (unsigned int position)
Called from the framework immediately before a child will be added to the Group.

virtual NVSG_API void | postAddChild (unsigned int position)
Called from the framework immediately after a child was added to the Group.

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Called from the framework if re-calculation of the Group's bounding box is required.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Called from the framework if re-calculation of the Group's bounding sphere is required.

virtual NVSG_API unsigned
short 		determineHintsContainment (unsigned short hints) const
Determine the hint containment status of this Group.

virtual NVSG_API bool | determineTransparencyContainment () const
Called from the framework if re-determination of the transparency containment cache is required.

virtual NVSG_API bool | determineCgFxContainment () const
Determines the CgFx containment status.

virtual NVSG_API bool | determineLightContainment () const
Determines the LightSource containment status.

virtual NVSG_API bool | determineLODContainment () const
Determines the LOD containment status.

virtual NVSG_API bool | determineVolumeNodeContainment () const
Determines the VolumeNode containment status.

virtual NVSG_API bool | determineAnimationContainment () const
Determine the animation containment of this object.

NVSG_API void | invalidateCaches (NodeHandle *child, bool insert)
Invalidates owning caches depending on whether a child node was added or removed.

Detailed Description

Provides grouping of Node objects.

Namespace: nvsg
Remarks:
A Group is a special Node that provides grouping of all kinds of Node-derived objects. Nodes that are grouped underneath a Group are referred to as children of the Group.

Constructor & Destructor Documentation

NVSG_API Group ( )

Default-constructs a Group object.

NVSG_API Group ( const Node & rhs ) [explicit]

Constructs a Group from a Node.

Parameters:
rhs Node to construct the Group from.
Remarks:
This is kind of a partial copy constructor only copying the Node part from the source object.

NVSG_API Group ( const Group & rhs )

Constructs a Group as a copy of another Group.

Parameters:
rhs Group to serve as source for the newly constructed Group.

virtual NVSG_API ~Group ( ) [virtual]

Destructs a Group object.

Member Function Documentation

unsigned int getNumberOfChildren ( ) const [inline]

Returns the number child nodes for this Group.

Returns:
The function returns the number of nodes grouped underneath the Group.
See also:
Group::getChild

NVSG_API unsigned int addChild | ( | NodeHandle * | child,
 |  | unsigned int | position = ~0
 | ) |

Adds a child node.

Parameters:
child | Pointer to the Node to be added.
position | Optional position where to place the new child.
Returns:
The function returns the zero-based position where the new child node has been added.
Remarks:
The function increments the reference count of the specified child node and inserts it at the specified position.

When omitting the position parameter, the child node will be added at the end. If position specifies a position greater than the actual number of child nodes, the new child also will be added to the end. If position specifies a valid position - that is, a position between 0 and whatever Group::getNumberOfChildren returns - the child Node will be inserted at that position forcing all subsequent child nodes to move up in the list of children.

Inserting a child node will cause the positions of all subsequent child nodes to change. Group-derived classes that need to manage child positions can override the protected notifiers Group::preAddChild and Group::postAddChild to perform necessary tasks immediately before a new child node will be added and after a child node has been added, respectively.
See also:
Group::removeChild, Group::preAddChild, Group::postAddChild

NodeHandle * getChild ( unsigned int position ) const [inline]

Returns the child node at a specified position.

Parameters:
position Zero-based position of the child node to retrieve.
Returns:
The function returns a pointer to the const child node at the specified position.
Remarks:
This function together with Group::getNumberOfChildren is useful for iterating through all child nodes in a Group.

Calling this function with an invalid position - that is, a position greater or equal to whatever Group::getNumberOfChildren returns - results in undefined behavior.
Example:
 void printNodeNames(const Group * group)
 {
     unsigned int numChilds = group->getNumberOfChildren();
     // iterate through the children and print the name for each in turn
     for ( unsigned int i=0; i<numChilds; ++i )
     {
         printf("child#%i: %s\n", i, group->getChild(i)->getName().c_str());
     }
 }

NVSG_API bool removeChild ( NodeHandle * child )

Removes all occurrences of a specified child node from this Group.

Parameters:
child Pointer to the child node to be removed.
Returns:
The function returns false if no child node was removed from the Group. Otherwise, the functions returns true, indicating that all occurrences of the specified child node have been removed.
Remarks:
For each occurrence of the specified child node the function decrements the child node's reference count and removes it from the internal vector of child nodes. If the child node's reference count reaches zero, it is automatically deleted.

The function causes the position of subsequent child nodes to change. Group-derived classes that need to manage child positions can override the protected notifiers Group::preRemoveChild and Group::postRemoveChild to perform necessary tasks immediately before a child node will be removed and after a child node has been removed, respectively.
See also:
Group::addChild, Group::preRemoveChild, Group::postRemoveChild

NVSG_API void removeChild ( unsigned int position )

Removes the child node at the specified position.

Parameters:
position Zero-based position of the child node to be removed.
Remarks:
The function removes the child node at the specified zero-pased position and decrements the reference count for that child. If the child node's reference count reaches zero, it will be automatically deleted.

The function causes the position of subsequent child nodes to change. Group-derived classes that need to manage child positions can override the protected notifiers Group::preRemoveChild and Group::postRemoveChild to perform necessary tasks immediately before a child node will be removed and after a child node has been removed, respectively.

Calling this function with an invalid position - that is, a position greater or equal to whatever Group::getNumberOfChildren returns - results in undefined behavior.
See also:
Group::addChild, Group::preRemoveChild, Group::postRemoveChild

NVSG_API bool replaceChild | ( | NodeHandle * | newChild,
 |  | NodeHandle * | oldChild
 | ) |

Replaces all occurrences of a child node.

Parameters:
newChild | Pointer to the Node to replace the specified child node.
oldChild | Pointer to the Node to be replaced.
Returns:
The function returns false if no child node was replaced. Otherwise, the function returns true, indicating that all occurrences of oldChild have been replaced by newChild.
Remarks:
The function replaces all occurrences of oldChild by newChild. The reference count of oldChild will be decremented and the reference count of newChild will be incremented for each replacement taking place. If the reference count of oldChild reaches zero, it will be automatically deleted.
See also:
Group::addChild, Group::removeChild

NVSG_API void replaceChild | ( | NodeHandle * | newChild,
 |  | unsigned int | position
 | ) |

Replaces the child node at the specified position.

Parameters:
newChild | Pointer to the Node to replace the child node at the specified position.
position | Zero-based position of the child node to be replaced.
Remarks:
The function replaces the child node at the specified position by the node pointed to by newChild. The function increments the reference count of newChild and decrements the reference count of the replaced child node. If the reference count of the replaced child node reaches zero, it will be automatically deleted.

Calling this function with an invalid position - that is, a position greater or equal to whatever Group::getNumberOfChildren returns - results in undefined behavior.
See also:
Group::addChild, Group::removeChild

bool hasChild ( NodeHandle * node ) const [inline]

Tests whether a specified Node is a child node of this Group.

Parameters:
node Pointer to the Node to test.
Returns:
The function returns true if node is detected to be a child node of this Group. Otherwise, the function returns false.
See also:
Group::addChild, Group::removeChild, Group::replaceChild

NVSG_API bool getChildPositions | ( | NodeHandle * | node,
 |  | std::vector< unsigned int > & | positions
 | ) | const

Returns all occurring positions of a specified child node.

Parameters:
node | Pointer to the child node for which to retrieve the positions inside this Group.
positions | Reference to a vector that receives all occurring positions of node.
Returns:
The function returns true if the requested positions for the specified Node could have been received successfully. Otherwise, the function returns false, indicating that the specified Node is not a child of this Group.
See also:
Group::addChild, Group::removeChild, Group::replaceChild

unsigned int getNumberOfClipPlanes ( ) const [inline]

Get the number of clipping planes in this Group.

Returns:
The number of clipping planes on this Group.
See also:
addClipPlane, isClipPlaneActive, getClipPlane, setClipPlane

NVSG_API unsigned int getNumberOfActiveClipPlanes ( ) const

Get the number of active clipping planes in this Group.

Returns:
The number of active clipping planes in this Group.
See also:
getNumberOfClipPlanes

bool isClipPlaneActive ( unsigned int index ) const [inline]

Ask if the specified clipping plane is active.

Parameters:
index The index in the array of clipping planes.
Returns:
true, if the specified clipping plane is active, otherwise false.
Note:
The behavior is undefined if index is larger than or equal to the number of clipping planes in this Group.
See also:
getNumberOfClipPlanes, getClipPlane, activateClipPlane, deactivateClipPlane

const nvmath::Plane3f & getClipPlane ( unsigned int index ) const [inline]

Returns the specified clipping plane.

Parameters:
index Specifies the zero based index in the array of clipping planes.
Returns:
The function returns a pointer to a Plane3fHandle.
Note:
The behavior is undefined if index is larger than or equal to the number of clipping planes in this Group.
See also:
getNumberOfClipPlanes, isClipPlaneActive, setClipPlane

void addClipPlane | ( | const nvmath::Plane3f & | plane,
 |  | bool | active = true
 | ) | [inline]

Adds a clipping plane to this Group.

Parameters:
plane | A pointer to the Plane3fHandle that specifies the clip plane to be added.
active | Optional parameter to add the clip plane as active (true) or inactive (false); default is active.
See also:
getNumberOfClipPlanes, isClipPlaneActive, getClipPlane

NVSG_API void activateClipPlane ( unsigned int index )

Activates the specified clip plane.

Parameters:
index The zero-based index in the array of clipping planes.
Note:
The behavior is undefined if index is larger than or equal to the number of clip planes in this Group.
See also:
getNumberOfClipPlanes, isClipPlaneActive, deactivateClipPlane

NVSG_API void deactivateClipPlane ( unsigned int index )

Deactivates the specified clip plane.

Parameters:
index The zero-based index in the array of clip planes.
Note:
The behavior is undefined if index is larger than or equal to the number of clip planes in this Group.
See also:
getNumberOfClipPlanes, isClipPlaneActive, activateClipPlane

void setClipPlane | ( | unsigned int | index,
 |  | const nvmath::Plane3f & | plane
 | ) | [inline]

Sets the plane at the specified index.

Parameters:
index | The zero-based index in the array of clip planes.
plane | A pointer to a Plane3fHandle specifying the plane to use as the clip plane.
Note:
The behavior is undefined if index is larger than or equal to the number of clip planes in this Group.
See also:
getNumberOfClipPlanes, activateClipPlane, deactivateClipPlane

unsigned int getNumberOfLightSources ( ) const [inline]

Returns the number light sources for this Group.

Returns:
The function returns the number of light sources in the Group.
See also:
Group::getLightSource

LightSourceHandle * getLightSource ( unsigned int index ) const [inline]

Returns the light source at a specified index.

Parameters:
index Zero-based index of the light source to retrieve.
Returns:
The function returns a pointer to the light source at the specified index.
Remarks:
This function together with Group::getNumberOfLightSources is useful for iterating through all light sources in a Group.

Calling this function with an invalid index - that is, an index greater or equal to whatever Group::getNumberOfLightSources returns - results in undefined behavior.
Example:
  void printLightNames(const Group * group)
  {
    unsigned int numLights = group->getNumberOfLightSources();
    // iterate through the light sources and print the name for each in turn
    for ( unsigned int i=0; i<numLights; ++i )
    {
      ReadableObject<LightSource> ls(group->getLightSource(i);
      printf("light#%i: %s\n", i, ls->getName().c_str());
    }
  }

bool hasLightSource ( LightSourceHandle * lsHdl ) const [inline]

Tests whether a specified LightSource is part of this Group.

Parameters:
lsHdl Pointer to the LightSource to test.
Returns:
The function returns true if lsHdl is detected to be a light source of this Group. Otherwise, the function returns false.
See also:
Group::addLightSource, Group::removeLightSource, Group::replaceLightSource

NVSG_API void addLightSource ( LightSourceHandle * lsHdl )

Adds a light source.

Parameters:
lsHdl Pointer to the LightSource to be added.
Remarks:
The function increments the reference count of the specified light source and adds the light source to its list of light sources.
See also:
Group::removeLightSource

NVSG_API void replaceLightSource | ( | unsigned int | index,
 |  | LightSourceHandle * | lsHdl
 | ) |

Replaces the light source at the specified position.

Parameters:
index | Position of the LightSource in this Group to be replaced.
lsHdl | Pointer to the LightSource to replace the light source at the specified position.
Remarks:
The function replaces the light source at the specified position by the light source pointed to by lsHdl. The function increments the reference count of lsHdl and decrements the reference count of the replaced child node. If the reference count of the replaced child node reaches zero, it will be automatically deleted.

Calling this function with an invalid position - that is, a position greater or equal to whatever Group::getNumberOfLightSources returns - results in undefined behavior.
See also:
Group::addLightSource, Group::removeLightSource

NVSG_API void replaceLightSource | ( | LightSourceHandle * | newHdl,
 |  | LightSourceHandle * | oldHdl
 | ) |

Replaces a LightSource by an other.

Parameters:
newHdl | Pointer to the LightSource to replace the specified light source
oldHdl | Pointer to the LightSource to be replaced.
Remarks:
The function replaces the LightSource oldHdl by newHdl. The reference count of oldHdl will be decremented and the reference count of newHdl will be incremented. If the reference count of oldHdl reaches zero, it will be automatically deleted.
See also:
Group::addLightSource, Group::removeLightSource

NVSG_API void removeLightSource ( unsigned int index )

Removes the light source at the specified position.

Parameters:
index Zero-based position of the light source to be removed.
Remarks:
The function removes the light source at the specified zero-based position and decrements the reference count for that light source. If the light source's reference count reaches zero, it will be automatically deleted.

Calling this function with an invalid position - that is, a position greater or equal to whatever Group::getNumberOfLightSources returns - results in undefined behavior.
See also:
Group::addLightSource

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Overrides Object::isEquivalent.

Parameters:
p | Pointer to the Object to test for equivalence with this Group object.
ignoreNames | Object names will be ignored while testing if this is true.
deepCompare | The function performs a deep-compare instead of a shallow compare if this is true.
Returns:
The function returns true if the Object pointed to by object is detected to be equivalent to this Group object.
Remarks:
The test will be performed considering the optional control parameters ignoreNames and deepCompare. If you omit these two, the function ignores the object names and performs a shallow compare only.
See also:
Object::isEquivalent

Reimplemented from Object.

Reimplemented in AnimatedTransform, Billboard, FlipbookAnimation, LOD, Switch, and Transform.

NVSG_API Group& operator= ( const Group & rhs )

Assigns new content from another Group object.

Parameters:
rhs Group object from which to assign the new content.
Returns:
A reference to this Group object.
Remarks:
The assignment operator unreferences the old content before assigning the new content. The new content will be a deep-copy of the right-hand-sided object's content.
See also:
Group::clone

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validates all incarnations down the hierarchy.

Remarks:
The function is called from the framework. It overrides Object::validateIncarnation and validates all incarnations down the hierarchy, starting with this Group object.
See also:
Object::getIncarnation, Node::invalidateIncarnation

Reimplemented from Node.

Reimplemented in AnimatedTransform, and FlipbookAnimation.

virtual NVSG_API void preRemoveChild ( unsigned int position ) [protected, virtual]

Called from the framework immediately before a child will be removed from the Group.

Parameters:
position Zero-based position of the child that immediately will be removed from the Group.
Remarks:
It is recommended, for Group-derived classes that need to keep track of child nodes removal, to override this function to perform necessary tasks immediately before a child node will be removed from the Group.

The function will be called with the zero-based index that references the child that will be removed immediately after this call.
See also:
Group::postRemoveChild

virtual NVSG_API void postRemoveChild ( unsigned int position ) [protected, virtual]

Called from the framework immediately after a child has been removed from the Group.

Parameters:
position Zero-based position that previously referenced the removed child node.
Remarks:
It is recommended, for Group-derived classes that need to keep track of child nodes removal, to override this notifier to perform necessary tasks immediately after a child node has been removed from the Group.

The function will be called with the zero-based position that previously referenced the removed child. Note that this position can no longer be used to reference the child node, because the child node already has been removed from this Group.
See also:
Group::preRemoveChild

Reimplemented in Switch.

virtual NVSG_API void preAddChild ( unsigned int position ) [protected, virtual]

Called from the framework immediately before a child will be added to the Group.

Parameters:
position Zero-based position where the child node will be added.
Remarks:
It is recommended, for Group-derived classes that need to keep track of child nodes insertion, to override this notifier to perform necessary tasks immediately before a child node will be added to the Group.

The function will be called with the zero-based position where the child node will be added. Note that this position cannot yet be used to reference the child node, because the child node has not been added to this Group at this point.
See also:
Group::postAddChild

virtual NVSG_API void postAddChild ( unsigned int position ) [protected, virtual]

Called from the framework immediately after a child was added to the Group.

Parameters:
position Zero-based position where the child node was added.
Remarks:
It is recommended, for Group-derived classes that need to keep track of child nodes insertion, to override this notifier to perform necessary tasks immediately after a child node has been added to the Group.

The function will be called with the zero-based position where the child node has been added immediately before this call.
See also:
Group::preAddChild

Reimplemented in Switch.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Called from the framework if re-calculation of the Group's bounding box is required.

Returns:
The function returns a nvmath::Box3f that represents the actual bounding box of this Group.
Remarks:
The function calculates the bounding box by accumulating the bounding boxes of all available child nodes.

For Group-derived classes to specialize bounding box calculation, it is recommended to override this function.
See also:
nvmath::Box3f

Implements Node.

Reimplemented in Switch, and Transform.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Called from the framework if re-calculation of the Group's bounding sphere is required.

Returns:
The function returns a nvmath::Sphere3f that represents the actual bounding sphere of this Group.
Remarks:
The function calculates the bounding sphere by accumulating the bounding spheres of all available child nodes.

For Group-derived classes to specialize bounding sphere calculation, it is recommended to override this function.
See also:
nvmath::Sphere3f

Implements Node.

Reimplemented in Switch, and Transform.

virtual NVSG_API unsigned short determineHintsContainment ( unsigned short hints ) const [protected, virtual]

Determine the hint containment status of this Group.

Parameters:
hints An unsigned short whose bits encode the hints containment to determine.
Returns:
An unsigned short whose bits encode the hints that are to be determined and also set in this Group or any of it's children.
Remarks:
This function is called by the framework, if getHintsContainment is called while the hint containment flags mark that information as invalid.
See also:
containsHints, invalidateHintsContainment, getHintsContainment

Reimplemented from Node.

Reimplemented in Switch.

virtual NVSG_API bool determineTransparencyContainment ( ) const [protected, virtual]

Called from the framework if re-determination of the transparency containment cache is required.

Returns:
The function returns true if the Group contains at least one StateSet that causes the corresponding geometry to appear transparent. Otherwise, the function returns false.
Remarks:
This function will be called from the framework if re-determination of the related transparency containment cache is required due to the cache becoming invalid, for example, if child nodes have either been added or removed from the Group.

The function iterates through the child nodes and, for each node, determinates transparency containment. The iteration stops with the first child node found that contains at least one StateSet that causes the corresponding geometry to appear transparent.

For Group-derived classes to specialize this determination, it is recommended to override this function.
See also:
StateSet::isTransparent

Implements Node.

Reimplemented in Switch.

virtual NVSG_API bool determineCgFxContainment ( ) const [protected, virtual]

Determines the CgFx containment status.

Returns:
true, if tree underneath this Group contains at least one CgFx, otherwise false.
Remarks:
This overrides Node::determineCgFxContainment, since the tree underneath a Group can contain a CgFx.

Reimplemented from Node.

Reimplemented in Switch.

virtual NVSG_API bool determineLightContainment ( ) const [protected, virtual]

Determines the LightSource containment status.

Returns:
true, if this Group contains a LightSource, otherwise false.
Remarks:
This overrides Node::determineLightContainment, since a Group can hold a LightSource directly or within the underlying sub-tree.

Reimplemented from Node.

Reimplemented in Switch.

virtual NVSG_API bool determineLODContainment ( ) const [protected, virtual]

Determines the LOD containment status.

Returns:
true, if tree underneath this Group contains at least one LOD, otherwise false.
Remarks:
This overrides Node::determineLODContainment, since the tree underneath a Group can contain a LOD.

Reimplemented from Node.

Reimplemented in LOD, and Switch.

virtual NVSG_API bool determineVolumeNodeContainment ( ) const [protected, virtual]

Determines the VolumeNode containment status.

Returns:
true, if tree underneath this Group contains at least one VolumeNode, otherwise false.
Remarks:
This overrides Node::determineVolumeNodeContainment, since the tree underneath a Group can contain a VolumeNode.

Reimplemented from Node.

Reimplemented in Switch.

virtual NVSG_API bool determineAnimationContainment ( ) const [protected, virtual]

Determine the animation containment of this object.

Returns:
true, if at least on of the children or one of the LightSources of this Group contains an Animation.

Reimplemented from Node.

Reimplemented in AnimatedTransform, and FlipbookAnimation.

NVSG_API void invalidateCaches | ( | NodeHandle * | child,
 |  | bool | insert
 | ) | [protected]

Invalidates owning caches depending on whether a child node was added or removed.

Parameters:
child | Pointer to the child that was either added or removed
insert | Indicates if the child node was added or removed. A value of true indicates that the child node was inserted. A value of false indicates that the child was removed.
Remarks:
The function always invalidates the Group's bounding sphere. If either the CgFX containment, the LightSource containment, the transparency containment, or the number of animation frames changes, the function invalidates the corresponding caches - forcing a re-calculation of these caches with the very next query.
See also:
Group::containsCgFx, Group::invalidateCgFxContainment, Group::containsLight, Group::invalidateLightContainment, Group::containsTransparentGeometry, Group::invalidateTransparencyContainment

The documentation for this class was generated from the following file:
  • Group.h
Generated on Tue Jan 15 10:29:05 2008 for NVSGSDK by NVIDIA


Member List

Group Member List

This is the complete list of members for Group, including all inherited members.
activateClipPlane(unsigned int index) | Group |
addChild(NodeHandle *child, unsigned int position=~0) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addLightSource(LightSourceHandle *lsHdl) | Group |
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const | Group | [protected, virtual]
calculateBoundingSphere() const | Group | [protected, virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
deactivateClipPlane(unsigned int index) | Group |
determineAnimationContainment() const | Group | [protected, virtual]
determineCgFxContainment() const | Group | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineLightContainment() const | Group | [protected, virtual]
determineLODContainment() const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
determineVolumeNodeContainment() const | Group | [protected, virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getChild(unsigned int position) const | Group | [inline]
getChildPositions(NodeHandle *node, std::vector< unsigned int > &positions) const | Group |
getClipPlane(unsigned int index) const | Group | [inline]
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getLightSource(unsigned int index) const | Group | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfLightSources() const | Group | [inline]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getUserData() const | Object | [inline]
Group() | Group |
Group(const Node &rhs) | Group | [explicit]
Group(const Group &rhs) | Group |
hasChild(NodeHandle *node) const | Group | [inline]
hasLightSource(LightSourceHandle *lsHdl) const | Group | [inline]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCaches(NodeHandle *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isClipPlaneActive(unsigned int index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Group | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Group &rhs) | Group |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
postAddChild(unsigned int position) | Group | [protected, virtual]
postRemoveChild(unsigned int position) | Group | [protected, virtual]
preAddChild(unsigned int position) | Group | [protected, virtual]
preRemoveChild(unsigned int position) | Group | [protected, virtual]
removeChild(NodeHandle *child) | Group |
removeChild(unsigned int position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeLightSource(unsigned int index) | Group |
replaceChild(NodeHandle *newChild, NodeHandle *oldChild) | Group |
replaceChild(NodeHandle *newChild, unsigned int position) | Group |
replaceLightSource(unsigned int index, LightSourceHandle *lsHdl) | Group |
replaceLightSource(LightSourceHandle *newHdl, LightSourceHandle *oldHdl) | Group |
setAnnotation(const std::string &anno) | Object |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Group | [virtual]
~Group() | Group | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:05 2008 for NVSGSDK by NVIDIA


Handle Class Reference

Controls access to the the handled object. More...

#include <Handle.h>

Inheritance diagram for Handle:

[legend]

Detailed Description

Controls access to the the handled object.

Parameters:
T | Specifies the type of the handled object.
U | Specifies an optional base class for the particular Handle.
The purpose of a Handle is to limit direct access to the handled object. The user can access the interface of the handled object through the interface of the Handle.

A Handle not only controls access to the handled object but also controls the lifetime of the handled object. The handled object will be created at Handle instantiation and will be automatically destroyed when the Handle's lifetime ends.

The instantiation of a Handle is limited. A Handle can live on heap only. Attempts to create a Handle on stack will be rejected by the compiler. It is also prohibited to explicitely call new or malloc on a Handle. The only ways possible to instantiate a Handle are

  1. by calling CreateHandle, or
  2. by calling CreateHandleFromBase, or
  3. by instantiating a Handle as a copy from another Handle by invoking the Handle's clone member.

The special design of the Handle template helps to limit the definition of different Handle types as folows:

  • A Handle type must either be a stand-alone class, not derived from any other class, or
  • must have another Handle type as base class.

Examples:

        // valid typedefs
        typedef nvutil::Handle<nvsg::Object> ObjectHandle;
        typedef nvutil::Handle<nvsg::Node, ObjectHandle> NodeHandle;

The purpose of the Handle template for NVSG core is to have the compiler generate a particular hierarchy of Handles. This enables us to create a kind of parallel hierarchy of Handles that reflect the same class hierarchy that we have for the NVSG core objects. That is, in the same way nvsg::Node inherits from nvsg::Object, NodeHandle inherits from ObjectHandle, and so on. This special Handle types thus carry the associated NVSG core objects and protect the core objects from direct access.

See also:
Handle<T, NullType>, Handle<T, Handle<U,V> >

The documentation for this class was generated from the following file:
  • Handle.h
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


TemplateHandle< T, Handle< U, V > > class Reference

Handle< T, Handle< U, V > > Class Template Reference

Specialization template for Handle-derived Handle types. More...

#include <Handle.h>

Inheritance diagram for Handle< T, Handle< U, V > >:

[legend]
Collaboration diagram for Handle< T, Handle< U, V > >:

[legend]
List of all members.

Public Types

typedef T | ObjectType

Public Member Functions

Handle * | clone () const
Returns a copy of this Handle.

Detailed Description

template<typename T, typename U, typename V>
class nvutil::Handle< T, Handle< U, V > >

Specialization template for Handle-derived Handle types.

This specialized Handle is used as a template for Handle-derived handle types.

See also:
Handle, Handle<T, NullType>

Member Function Documentation

Handle< T, Handle< U, V > > * clone ( ) const [inline]

Returns a copy of this Handle.

Returns:
The function returns a pointer to the Handle that was instantiated as a deep-copy of this Handle.
Use this function if you want to instantiate a real clone of this Handle.

The documentation for this class was generated from the following file:
  • Handle.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

Handle< T, Handle< U, V > > Member List

This is the complete list of members for Handle< T, Handle< U, V > >, including all inherited members.
clone() const | Handle< T, Handle< U, V > > | [inline]
ObjectType typedef (defined in Handle< T, Handle< U, V > >) | Handle< T, Handle< U, V > > |
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


TemplateHandle< T, NullType > class Reference

Handle< T, NullType > Class Template Reference

Specialized stand-alone Handle. More...

#include <Handle.h>

Inheritance diagram for Handle< T, NullType >:

[legend]
Collaboration diagram for Handle< T, NullType >:

[legend]
List of all members.

Public Types

typedef T | ObjectType

Public Member Functions

Handle * | clone () const
Returns a copy of this Handle.

T * | beginEdit ()
Provides write access to the handle object.

void | endEdit ()
Releases write access to the handle object.

const T * | beginRead ()
Provides read-only access to the handle object.

void | endRead ()
Releases read-only access to the handle object.

Detailed Description

template<typename T>
class nvutil::Handle< T, NullType >

Specialized stand-alone Handle.

This specialized Handle is used as a template for stand-alone Handle types. Stand-alone Handle types are types that do not inherit from other types.

See also:
Handle

Member Function Documentation

Handle< T, NullType > * clone ( ) const [inline]

Returns a copy of this Handle.

Returns:
The function returns a pointer to the Handle that was instantiated as a deep-copy of this Handle.
Use this function if you want to instantiate a real clone of this Handle.

T * beginEdit ( ) [inline]

Provides write access to the handle object.

Returns:
The function returns a pointer to the handled object, through which the user can access the objects interface.
If NVSG-runtime was configured to run in a multithreaded environment, the function locks the handled object for exclusive write access, before returning a pointer to that object.

The object remains locked until the write-lock will be released through endEdit.

Attempts to further use the returned pointer after the write-lock was released is an error and results in undefined runtime behavior.

void endEdit ( ) [inline]

Releases write access to the handle object.

The function releases the write access to the handled object that was previously obtained through beginEdit.

const T * beginRead ( ) [inline]

Provides read-only access to the handle object.

Returns:
The function returns a pointer to the handled object, through which the user can access the objects const, thus read only interface.
If NVSG-runtime was configured to run in a multithreaded environment, the function locks the handled object for shared read-only access, before returning a pointer to that const object.

The object remains locked until the read-lock will be released through endRead.

Attempts to further use the returned pointer after the read-lock was released is an error and results in undefined runtime behavior.

void endRead ( ) [inline]

Releases read-only access to the handle object.

The function releases the read-only access to the handled object that was previously obtained through beginRead.

Note:
Attempts to write-lock an object that already was read-locked by the same thread dead-locks your application!

The documentation for this class was generated from the following file:
  • Handle.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

Handle< T, NullType > Member List

This is the complete list of members for Handle< T, NullType >, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
beginEdit() | Handle< T, NullType > | [inline]
beginRead() | Handle< T, NullType > | [inline]
clone() const | Handle< T, NullType > | [inline]
endEdit() | Handle< T, NullType > | [inline]
endRead() | Handle< T, NullType > | [inline]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
ObjectType typedef (defined in Handle< T, NullType >) | Handle< T, NullType > |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


HighlightBox Class Reference

A HighlightObject that realizes a bounding box around a Drawable. More...

#include <HighlightBox.h>

Inheritance diagram for HighlightBox:

[legend]
Collaboration diagram for HighlightBox:

[legend]
List of all members.

Public Member Functions

NVSG_API | HighlightBox ()
Default-constructs a HighlightBox.

NVSG_API | HighlightBox (const HighlightObject &rhs)
Constructs a HighlightBox from a HighlightObject.

NVSG_API | HighlightBox (const HighlightBox &rhs)
Constructs a HighlightBox from another HighlightBox.

virtual NVSG_API bool | validateIncarnation () const
Validate the incarnation of this HighlightBox.

NVSG_API const nvmath::Vec3f * | getVertices () const
Get the vertices of the HighlightBox.

NVSG_API const nvmath::Vec3f & | getColor () const
Get the color for drawing the box.

NVSG_API void | setColor (const nvmath::Vec3f &color)
Set the color for drawing the box.

NVSG_API float | getLineWidth () const
Get the line width for drawing the box.

NVSG_API void | setLineWidth (float width)
Set the line width for drawing the box.

NVSG_API HighlightBox & | operator= (const HighlightBox &rhs)
Assignment operator.

Protected Member Functions

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Calculates the bounding box of this HighlightBox.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this HighlightBox.

Detailed Description

A HighlightObject that realizes a bounding box around a Drawable.

Namespace: nvsg
Remarks:
A HighlightBox draws a wireframe box around a Drawable.
See also:
Drawable, HighlightObject

Constructor & Destructor Documentation

NVSG_API HighlightBox ( )

Default-constructs a HighlightBox.

Remarks:
The HighlightBox has a default line width of 2.0 and a default line color of red (1.0,0.0,0.0).

NVSG_API HighlightBox ( const HighlightObject & rhs ) [explicit]

Constructs a HighlightBox from a HighlightObject.

Remarks:
The HighlightBox has a default line width of 2.0 and a default line color of red (1.0,0.0,0.0).

NVSG_API HighlightBox ( const HighlightBox & rhs )

Constructs a HighlightBox from another HighlightBox.

Member Function Documentation

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the incarnation of this HighlightBox.

Remarks:
If the Incarnation is not valid, it is validated, and the box geometry is calculated.
See also:
Drawable, HighlightObject

Reimplemented from Object.

const nvmath::Vec3f * getVertices ( ) const [inline]

Get the vertices of the HighlightBox.

Returns:
A pointer to the constant vertices of the HighlightBox.

const nvmath::Vec3f & getColor ( ) const [inline]

Get the color for drawing the box.

Returns:
A reference to the constant color.
Remarks:
The default color is red (1.0,0.0,0.0).

void setColor ( const nvmath::Vec3f & color ) [inline]

Set the color for drawing the box.

Parameters:
color The line color.
Remarks:
The default color is red (1.0,0.0,0.0).

float getLineWidth ( ) const [inline]

Get the line width for drawing the box.

Returns:
The width of the lines in pixels.
Remarks:
The default line width is 2.0.

void setLineWidth ( float width ) [inline]

Set the line width for drawing the box.

Parameters:
width The line width.
Remarks:
The default line width is 2.0.

NVSG_API HighlightBox& operator= ( const HighlightBox & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant HighlightBox to copy from.
Returns:
A reference to the assigned HighlightBox.
Remarks:
The assignment operator calls the assignment operator of HighlightObject and copies the vertices, the line width and the line color.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Calculates the bounding box of this HighlightBox.

Returns:
The axis-aligned bounding box of this HighlightBox.

Implements HighlightObject.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this HighlightBox.

Returns:
A nvmath::Sphere3f that contains the complete HighlightBox.
Remarks:
This function is called by the framework to determine a sphere that completely contains the HighlightBox.

Implements HighlightObject.

The documentation for this class was generated from the following file:
  • HighlightBox.h
Generated on Tue Jan 15 10:29:05 2008 for NVSGSDK by NVIDIA


Member List

HighlightBox Member List

This is the complete list of members for HighlightBox, including all inherited members.
calculateBoundingBox() const | HighlightBox | [protected, virtual]
calculateBoundingSphere() const | HighlightBox | [protected, virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | HighlightObject |
getBoundingSphere() const | HighlightObject |
getColor() const | HighlightBox | [inline]
getDataID() const | Object | [virtual]
getDrawable() const | HighlightObject | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLineWidth() const | HighlightBox | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
getUserData() const | Object | [inline]
getVertices() const | HighlightBox | [inline]
HighlightBox() | HighlightBox |
HighlightBox(const HighlightObject &rhs) | HighlightBox | [explicit]
HighlightBox(const HighlightBox &rhs) | HighlightBox |
HighlightObject() | HighlightObject | [protected]
HighlightObject(const HighlightObject &rhs) | HighlightObject | [protected]
invalidateBoundingVolumes() | HighlightObject |
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const HighlightBox &rhs) | HighlightBox |
nvsg::HighlightObject::operator=(const HighlightObject &rhs) | HighlightObject | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
setAnnotation(const std::string &anno) | Object |
setColor(const nvmath::Vec3f &color) | HighlightBox | [inline]
setDrawable(DrawableHandle *drawable) | HighlightObject | [inline]
setLineWidth(float width) | HighlightBox | [inline]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | HighlightBox | [virtual]
~HighlightObject() | HighlightObject | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:05 2008 for NVSGSDK by NVIDIA


HighlightEdges Class Reference

A HighlightObject that realizes a wireframe drawing of the highlighted PrimitiveSet. More...

#include <HighlightEdges.h>

Inheritance diagram for HighlightEdges:

[legend]
Collaboration diagram for HighlightEdges:

[legend]
List of all members.

Public Member Functions

NVSG_API | HighlightEdges ()
Default-constructs a HighlightEdges.

NVSG_API | HighlightEdges (const HighlightObject &rhs)
Constructs a HighlightEdges from a HighlighObject.

NVSG_API | HighlightEdges (const HighlightEdges &rhs)
Constructs a HighlightEdges as a copy from another HighlighEdges.

virtual NVSG_API | ~HighlightEdges ()
Destructs a HighlightEdges.

NVSG_API const nvmath::Vec3f & | getColor () const
Get the color for drawing the box.

NVSG_API void | setColor (const nvmath::Vec3f &color)
Set the color for drawing the box.

NVSG_API float | getLineWidth () const
Get the line width for drawing the box.

NVSG_API void | setLineWidth (float width)
Set the line width for drawing the box.

NVSG_API HighlightEdges & | operator= (const HighlightEdges &rhs)
Assignment operator.

Protected Member Functions

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Calculates the bounding box of this HighlightEdges.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this HighlightEdges.

Detailed Description

A HighlightObject that realizes a wireframe drawing of the highlighted PrimitiveSet.

Namespace: nvsg
Remarks:
A HighlightEdges draws a wireframe version on top of a PrimitiveSet.
See also:
HighlightObject, PrimitiveSet

Constructor & Destructor Documentation

NVSG_API HighlightEdges ( )

Default-constructs a HighlightEdges.

NVSG_API HighlightEdges ( const HighlightObject & rhs )

Constructs a HighlightEdges from a HighlighObject.

Parameters:
rhs HighlightObject to Construct the HighlightEdges from.

NVSG_API HighlightEdges ( const HighlightEdges & rhs )

Constructs a HighlightEdges as a copy from another HighlighEdges.

Parameters:
rhs HighlightEdges to copy from.

virtual NVSG_API ~HighlightEdges ( ) [virtual]

Destructs a HighlightEdges.

Member Function Documentation

const nvmath::Vec3f & getColor ( ) const [inline]

Get the color for drawing the box.

Returns:
A reference to the constant color.
Remarks:
The default color is red (1.0,0.0,0.0).

void setColor ( const nvmath::Vec3f & color ) [inline]

Set the color for drawing the box.

Parameters:
color The line color.
Remarks:
The default color is red (1.0,0.0,0.0).

float getLineWidth ( ) const [inline]

Get the line width for drawing the box.

Returns:
The width of the lines in pixels.
Remarks:
The default line width is 2.0.

void setLineWidth ( float width ) [inline]

Set the line width for drawing the box.

Parameters:
width The line width.
Remarks:
The default line width is 2.0.

NVSG_API HighlightEdges& operator= ( const HighlightEdges & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant HighlightEdges to copy from.
Returns:
A reference to the assigned HighlightEdges.
Remarks:
The assignment operator calls the assignment operator of HighlightObject and copies the PrimitiveSet, the line width and the line color.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Calculates the bounding box of this HighlightEdges.

Returns:
The axis-aligned bounding box of this HighlightEdges.

Implements HighlightObject.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this HighlightEdges.

Returns:
A nvmath::Sphere3f that contains the complete HighlightEdges.
Remarks:
This function is called by the framework to determine a sphere that completely contains the HighlightEdges.

Implements HighlightObject.

The documentation for this class was generated from the following file:
  • HighlightEdges.h
Generated on Tue Jan 15 10:29:05 2008 for NVSGSDK by NVIDIA


Member List

HighlightEdges Member List

This is the complete list of members for HighlightEdges, including all inherited members.
calculateBoundingBox() const | HighlightEdges | [protected, virtual]
calculateBoundingSphere() const | HighlightEdges | [protected, virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | HighlightObject |
getBoundingSphere() const | HighlightObject |
getColor() const | HighlightEdges | [inline]
getDataID() const | Object | [virtual]
getDrawable() const | HighlightObject | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLineWidth() const | HighlightEdges | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
getUserData() const | Object | [inline]
HighlightEdges() | HighlightEdges |
HighlightEdges(const HighlightObject &rhs) | HighlightEdges |
HighlightEdges(const HighlightEdges &rhs) | HighlightEdges |
HighlightObject() | HighlightObject | [protected]
HighlightObject(const HighlightObject &rhs) | HighlightObject | [protected]
invalidateBoundingVolumes() | HighlightObject |
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const HighlightEdges &rhs) | HighlightEdges |
nvsg::HighlightObject::operator=(const HighlightObject &rhs) | HighlightObject | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
setAnnotation(const std::string &anno) | Object |
setColor(const nvmath::Vec3f &color) | HighlightEdges | [inline]
setDrawable(DrawableHandle *drawable) | HighlightObject | [inline]
setLineWidth(float width) | HighlightEdges | [inline]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~HighlightEdges() | HighlightEdges | [virtual]
~HighlightObject() | HighlightObject | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:05 2008 for NVSGSDK by NVIDIA


HighlightElement Class Reference

Helper class to hold highlight information used in the render lists. More...

#include <HighLightElement.h>

Inheritance diagram for HighlightElement:

[legend]
Collaboration diagram for HighlightElement:

[legend]
List of all members.

Public Member Functions

NVSG_API | HighlightElement (ClipPlanesElement *cpe, TransformElement *te)
Default constructor.

NVSG_API | ~HighlightElement ()
Default destructor.

NVSG_API void | addHighlightObject (nvsg::PrimitiveSetHandle *psh)
Add a PrimitiveSet as a highlight object.

NVSG_API ClipPlanesElement * | getClipPlanes ()
Get the associated ClipPlanesElement.

NVSG_API nvsg::PrimitiveSetHandle * | getHighlightObject (unsigned int index)
Get the index's highlight object.

NVSG_API unsigned int | getNumberOfHighlightObjects ()
Get the number of stored highlight objects.

NVSG_API TransformElement * | getTransform ()
Get the associated TransformElement.

Detailed Description

Helper class to hold highlight information used in the render lists.

Remarks:
This class holds a number of PrimitiveSets representing the highlight objects, together with the current ClipPlanesElement and TransformElement.
See also:
BaseRenderElement

Constructor & Destructor Documentation

HighlightElement | ( | ClipPlanesElement * | cpe,
 |  | TransformElement * | te
 | ) | [inline]

Default constructor.

Parameters:
cpe | A pointer to the ClipPlanesElement to use.
te | A pointer to the TransformElement to use.
Remarks:
The default constructor increases the reference count of the construction arguments cpe and te.

~HighlightElement ( ) [inline]

Default destructor.

Remarks:
The default destructor decreases the reference count of the associated ClipPlanesElement and TransformElement, as well as of each used PrimitiveSet.
See also:
addHighlightObject

Member Function Documentation

void addHighlightObject ( nvsg::PrimitiveSetHandle * psh ) [inline]

Add a PrimitiveSet as a highlight object.

Parameters:
psh A pointer to the PrimitiveSetHandle representing a highlight object.
Remarks:
The PrimitiveSetHandle psh is stored and its reference count in incremented.
See also:
getHighlightObject, getNumberOfHighlightObjects

ClipPlanesElement * getClipPlanes ( ) [inline]

Get the associated ClipPlanesElement.

Returns:
The pointer to the ClipPlanesElement, this HighlightElement was created with.
See also:
getTransform

nvsg::PrimitiveSetHandle * getHighlightObject ( unsigned int index ) [inline]

Get the index's highlight object.

Parameters:
index The index of the highlight object to get.
Returns:
A pointer to the PrimitiveSetHandle representing the index's highlight object.
Remarks:
Note:
The behavior is undefined if index is larger or equal to the number of highlight objects stored in this HighlightElement.
See also:
getNumberOfHighlightObjects

unsigned int getNumberOfHighlightObjects ( ) [inline]

Get the number of stored highlight objects.

Returns:
The number of stored highlight objects.
See also:
addHighlightObject, getHighlightObject

TransformElement * getTransform ( ) [inline]

Get the associated TransformElement.

Returns:
A pointer to the TransformElement, this HighlightElement was created with.
See also:
getClipPlanes

The documentation for this class was generated from the following file:
  • HighLightElement.h
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


Member List

HighlightElement Member List

This is the complete list of members for HighlightElement, including all inherited members.
addHighlightObject(nvsg::PrimitiveSetHandle *psh) | HighlightElement | [inline]
addRef() | BaseRenderElement | [inline]
BaseRenderElement() | BaseRenderElement | [inline, protected]
BaseRenderElement(const BaseRenderElement &rhs) | BaseRenderElement | [inline, protected]
getClipPlanes() | HighlightElement | [inline]
getHighlightObject(unsigned int index) | HighlightElement | [inline]
getNumberOfHighlightObjects() | HighlightElement | [inline]
getRefCnt() const | BaseRenderElement | [inline]
getTransform() | HighlightElement | [inline]
HighlightElement(ClipPlanesElement *cpe, TransformElement *te) | HighlightElement | [inline]
removeRef() | BaseRenderElement | [inline]
~BaseRenderElement() | BaseRenderElement | [inline, protected, virtual]
~HighlightElement() | HighlightElement | [inline]
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


HighlightObject Class Reference

Abstract base class for highlighting objects. More...

#include <HighlightObject.h>

Inheritance diagram for HighlightObject:

[legend]
Collaboration diagram for HighlightObject:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~HighlightObject ()
Destructs a HighlightObject.

NVSG_API DrawableHandle * | getDrawable () const
Returns the Drawable to which this HighlightObject is attached.

NVSG_API void | setDrawable (DrawableHandle *drawable)
Assign the Drawable.

NVSG_API const nvmath::Box3f & | getBoundingBox () const
Returns the bounding box of this HighlightObject.

NVSG_API const nvmath::Sphere3f & | getBoundingSphere () const
Get the bounding sphere of this .

NVSG_API void | invalidateBoundingVolumes ()
Invalidates the bounding volumes of this HighlightObject.

Protected Member Functions

NVSG_API | HighlightObject ()
Protected constructor to prevent explicit creation.

NVSG_API | HighlightObject (const HighlightObject &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const=0
Interface for calculating the bounding box of this HighlightObject.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const=0
Interface for calculating the bounding sphere of this HighlightObject.

NVSG_API HighlightObject & | operator= (const HighlightObject &rhs)
Assignment operator.

Detailed Description

Abstract base class for highlighting objects.

Namespace: nvsg
Remarks:
A HighlightObject draws some highlighting on top of a Drawable.
See also:
Object

Constructor & Destructor Documentation

virtual NVSG_API ~HighlightObject ( ) [virtual]

Destructs a HighlightObject.

NVSG_API HighlightObject ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
The newly created HighlightObject is marked as invalid.
Note:
A HighlightObject will not be instantiated directly, but by instantiating a derived object like HighlightBox or HighlightEdges, for example.

NVSG_API HighlightObject ( const HighlightObject & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant HighlightObject to copy from.
Note:
A HighlightObject will not be instantiated directly, but by instantiating a derived object like HighlightBox or HighlightEdges, for example.

Member Function Documentation

DrawableHandle * getDrawable ( ) const [inline]

Returns the Drawable to which this HighlightObject is attached.

Returns:
A pointer to the handle to the Drawable.

void setDrawable ( DrawableHandle * drawable ) [inline]

Assign the Drawable.

Parameters:
drawable Specifies the Drawable to which this HighlightObject was attached.
See also:
getDrawable

NVSG_API const nvmath::Box3f& getBoundingBox ( ) const

Returns the bounding box of this HighlightObject.

Returns:
The function returns the axis-aligned bounding box of this HighlightObject.

NVSG_API const nvmath::Sphere3f& getBoundingSphere ( ) const

Get the bounding sphere of this .

Returns:
A nvmath::Sphere3f that bounds the complete HighlightObject.
Remarks:
If the bounding sphere currently is marked as invalid, calculateBoundingSphere() is used to calculate it and it is marked as valid.
See also:
calculateBoundingSphere, invalidateBoundingVolumes

NVSG_API void invalidateBoundingVolumes ( )

Invalidates the bounding volumes of this HighlightObject.

Remarks:
This forces the re-calculation of the bounding volumes with the very next query.
See also:
calculateBoundingSphere, getBoundingSphere

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, pure virtual]

Interface for calculating the bounding box of this HighlightObject.

Returns:
The function returns the axis-aligned bounding box of this HighlightObject.
Remarks:
This function is called by the framework to re-calculate the bounding box.

Implemented in HighlightBox, and HighlightEdges.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, pure virtual]

Interface for calculating the bounding sphere of this HighlightObject.

Returns:
A nvmath::Sphere3f that contains the complete HighlightEdges.
Remarks:
This function is called by the framework to determine a sphere that completely contains the HighlightObject.

Implemented in HighlightBox, and HighlightEdges.

NVSG_API HighlightObject& operator= ( const HighlightObject & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant HighlightObject to copy from.
Returns:
A reference to the assigned HighlightObject.
Remarks:
The assignment operator calls the assignment operator of Object and copies the valid flag and the bounding sphere.

The documentation for this class was generated from the following file:
  • HighlightObject.h
Generated on Tue Jan 15 10:29:05 2008 for NVSGSDK by NVIDIA


Member List

HighlightObject Member List

This is the complete list of members for HighlightObject, including all inherited members.
calculateBoundingBox() const=0 | HighlightObject | [protected, pure virtual]
calculateBoundingSphere() const=0 | HighlightObject | [protected, pure virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | HighlightObject |
getBoundingSphere() const | HighlightObject |
getDataID() const | Object | [virtual]
getDrawable() const | HighlightObject | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getObjectCode() const | Object | [inline]
getUserData() const | Object | [inline]
HighlightObject() | HighlightObject | [protected]
HighlightObject(const HighlightObject &rhs) | HighlightObject | [protected]
invalidateBoundingVolumes() | HighlightObject |
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const HighlightObject &rhs) | HighlightObject | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
setAnnotation(const std::string &anno) | Object |
setDrawable(DrawableHandle *drawable) | HighlightObject | [inline]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~HighlightObject() | HighlightObject | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:05 2008 for NVSGSDK by NVIDIA


IAllocator Class Reference

An allocator interface. More...

#include <Allocator.h>

Inheritance diagram for IAllocator:

[legend]
List of all members.

Public Types

typedef Singleton< Allocator > | theAllocator
Convenient typedef.

Public Member Functions

IAllocator ()
Default constructor.

virtual | ~IAllocator ()
Destructor.

NVSG_API void * | operator new (size_t size)
Operator new overload.

NVSG_API void * | operator new (size_t size, const char *src, unsigned int ln)
Operator new overload.

NVSG_API void * | operator new (size_t size, void *p)
Placement operator new overload.

NVSG_API void | operator delete (void *p, size_t size)
Operator delete overload.

Detailed Description

An allocator interface.

The IAllocator interface provides overloads of the new and delete operators for heap allocation. This overloads make use of a specialized memory manager, that is highly optimized for small object allocation. For large objects, i.e. objects greater than 128 bytes, the IAllocator interface utilizes the default memory manager.

Note:
Typically a user defined class utilizes this interface through public inheritance.

Member Typedef Documentation

typedef Singleton<Allocator> theAllocator

Convenient typedef.

Constructor & Destructor Documentation

IAllocator ( ) [inline]

Default constructor.

Default constructs an IAllocator object.

virtual ~IAllocator ( ) [inline, virtual]

Destructor.

Member Function Documentation

void * operator new ( size_t size ) [inline]

Operator new overload.

Allocates a memory block of size bytes from heap. Returns start address of allocated memory block.

void * operator new | ( | size_t | size,
 |  | const char * | src,
 |  | unsigned int | ln
 | ) | [inline]

Operator new overload.

Allocates a memory block of size bytes from heap. In addition it supports memory leak detection in debug mode. Returns start address of allocated memory block.

void * operator new | ( | size_t | size,
 |  | void * | p
 | ) | [inline]

Placement operator new overload.

Provides object creation at a specified memory address.

p must point to a valid block of memory, large enough to hold an object of size bytes.

Return start address of the specified memory block.

void operator delete | ( | void * | p,
 |  | size_t | size
 | ) | [inline]

Operator delete overload.

Frees size bytes of memory at address p.

The documentation for this class was generated from the following file:
  • Allocator.h
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


Member List

IAllocator Member List

This is the complete list of members for IAllocator, including all inherited members.
IAllocator() | IAllocator | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


IdentityResult Class Reference

AnalyzeResult indicating identity transformations. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for IdentityResult:

[legend]
Collaboration diagram for IdentityResult:

[legend]
List of all members.

Public Member Functions

virtual | ~IdentityResult ()
Virtual Destructor.

Public Attributes

unsigned int | identityCount
The number of identity Transforms.

Detailed Description

AnalyzeResult indicating identity transformations.

Namespace: nvsg
Remarks:
All Transform objects in the tree that are in fact identity transforms are reported with an IdentityResult.
See also:
AnalyzeResult, AnalyzeTraverser

Constructor & Destructor Documentation

virtual ~IdentityResult ( ) [inline, virtual]

Virtual Destructor.

Member Data Documentation

unsigned int identityCount

The number of identity Transforms.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


Member List

IdentityResult Member List

This is the complete list of members for IdentityResult, including all inherited members.
identityCount | IdentityResult |
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~IdentityResult() | IdentityResult | [inline, virtual]
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


IdentityToGroupTraverser Class Reference

Traverser that replaces identity transforms by groups. More...

#include <IdentityToGroupTraverser.h>

Inheritance diagram for IdentityToGroupTraverser:

[legend]
Collaboration diagram for IdentityToGroupTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | IdentityToGroupTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~IdentityToGroupTraverser (void)
Protected destructor to prevent instantiation of an IdentityToGroupTraverser on stack.

virtual NVSG_API void | postApply (nvsg::NodeHandle *root)
If the root node is an identity Transform, it is replaced by a Group.

virtual NVSG_API void | handleAnimatedTransform (nvsg::AnimatedTransform *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleBillboard (nvsg::Billboard *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleGroup (nvsg::Group *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleLOD (nvsg::LOD *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleSwitch (nvsg::Switch *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleTransform (nvsg::Transform *p)
Replace any identity Transform of it's children to a Group.

Detailed Description

Traverser that replaces identity transforms by groups.

Constructor & Destructor Documentation

NVSG_API IdentityToGroupTraverser ( void )

Constructor.

virtual NVSG_API ~IdentityToGroupTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of an IdentityToGroupTraverser on stack.

Member Function Documentation

virtual NVSG_API void postApply ( nvsg::NodeHandle * root ) [protected, virtual]

If the root node is an identity Transform, it is replaced by a Group.

Reimplemented from Traverser.

virtual NVSG_API void handleAnimatedTransform ( nvsg::AnimatedTransform * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

An AnimatedTransform is handled as a Transform.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleBillboard ( nvsg::Billboard * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGroup ( nvsg::Group * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLOD ( nvsg::LOD * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleSwitch ( nvsg::Switch * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTransform ( nvsg::Transform * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • IdentityToGroupTraverser.h
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


Member List

IdentityToGroupTraverser Member List

This is the complete list of members for IdentityToGroupTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | OptimizeTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *p) | IdentityToGroupTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *p) | IdentityToGroupTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | ExclusiveTraverser | [protected, virtual]
handleGroup(nvsg::Group *p) | IdentityToGroupTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *p) | IdentityToGroupTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *p) | IdentityToGroupTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *p) | IdentityToGroupTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
IdentityToGroupTraverser(void) | IdentityToGroupTraverser |
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(nvsg::NodeHandle *root) | IdentityToGroupTraverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setIgnoreNames(bool ignore) | OptimizeTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IdentityToGroupTraverser(void) | IdentityToGroupTraverser | [protected, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


ILTexLoader Class Reference

A Texture Loader that encapsulates DevIL so it can be used with the NVSG PlugIn mechanism. More...

#include <ILTexLoader.h>

Inheritance diagram for ILTexLoader:

[legend]
Collaboration diagram for ILTexLoader:

[legend]
List of all members.

Public Member Functions

void | deleteThis (void)
Realization of the pure virtual interface function of a PlugIn.

Protected Member Functions

virtual | ~ILTexLoader ()
Protected virtual destructor.

bool | onLoad (const std::string &filename, nvsg::TextureImage *texImg, const std::vector< std::string > &searchPaths)
Pure virtual interface called on loading a TextureImage file.

Static Protected Attributes

ILTexLoader * m_instance
Single instance of this class.

unsigned int | m_refCount
Reference count of the single instance of this class.

Friends

bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

Detailed Description

A Texture Loader that encapsulates DevIL so it can be used with the NVSG PlugIn mechanism.

Constructor & Destructor Documentation

virtual ~ILTexLoader ( ) [protected, virtual]

Protected virtual destructor.

Prohibits ordinary client code from

  • creating a TextureLoader derived object on stack and
  • calling delete on a pointer to TextureLoader.

Member Function Documentation

void deleteThis ( void ) [inline, virtual]

Realization of the pure virtual interface function of a PlugIn.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

bool onLoad | ( | const std::string & | filename,
 |  | nvsg::TextureImage * | texImg,
 |  | const std::vector< std::string > & | searchPaths
 | ) | [protected, virtual]

Pure virtual interface called on loading a TextureImage file.

Parameters:
filename | The name of the texture file to load.
texImg | A pointer to the TextureImage to load the data into.
searchPaths | A set of search paths used for files referenced within the texture file.
Returns:
true, if the TextureImage was successfully loaded, otherwise false.
Remarks:
Loads a TextureImage from the file specified by filename. The PlugIn must create the image(s) in the OpenGL compatible orientation, that has its image origin in the lower left. TextureImage offers mirrorX() and mirrorY() routines that a Loader PlugIn can use to achieve this orientation.
See also:
load, reload

Implements TextureLoader.

Friends And Related Function Documentation

bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) | [friend]

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a OBJSAVER. If the PlugIn ID piid equals PIID_NVSG_SCENE_SAVER, a OBJSAVER is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

Member Data Documentation

ILTexLoader* m_instance [static, protected]

Single instance of this class.

Remarks:
To reduce the overhead due to the large number of supported extensions, we only instantiate this class once.

unsigned int m_refCount [static, protected]

Reference count of the single instance of this class.

The documentation for this class was generated from the following file:
  • ILTexLoader.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

ILTexLoader Member List

This is the complete list of members for ILTexLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
createTextureImageHandle() | TextureLoader | [protected, virtual]
deleteThis(void) | ILTexLoader | [inline, virtual]
getPlugInterface(const nvutil::UPIID &piid, nvutil::PlugIn *&pi) | ILTexLoader | [friend]
ILTexLoader() (defined in ILTexLoader) | ILTexLoader |
load(const std::string &filename, const std::vector< std::string > &searchPaths=std::vector< std::string >(), const unsigned int &creationFlags=0) | TextureLoader |
m_instance | ILTexLoader | [protected, static]
m_refCount | ILTexLoader | [protected, static]
onLoad(const std::string &filename, nvsg::TextureImage *texImg, const std::vector< std::string > &searchPaths) | ILTexLoader | [protected, virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
reload(TextureImageHandle *tih, const std::vector< std::string > &searchPaths=std::vector< std::string >()) | TextureLoader |
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~ILTexLoader() | ILTexLoader | [protected, virtual]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~TextureLoader() | TextureLoader | [protected, virtual]
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


ILTexSaver Class Reference

A Texture Saver that encapsulates DevIL so it can be used with the NVSG PlugIn mechanism. More...

#include <ILTexSaver.h>

Inheritance diagram for ILTexSaver:

[legend]
Collaboration diagram for ILTexSaver:

[legend]
List of all members.

Public Member Functions

void | deleteThis (void)
Plug-in deletion.

bool | save (nvsg::TextureImageHandle *image, const std::string &fileName)
Pure virtual interface function to save a TextureImage.

Friends

bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

Detailed Description

A Texture Saver that encapsulates DevIL so it can be used with the NVSG PlugIn mechanism.

Member Function Documentation

void deleteThis ( void ) [inline, virtual]

Plug-in deletion.

Every plug-in must provide this function. It assures that, when deleting the plug-in object, always the right heap manager is called to free the associated memory.

Note:
Ordinary client code is not allowed to call deleteThis on a plug-in object. Client code needs to utilize the PlugInServer interface for plug-in managment for this purposes.

Implements PlugIn.

bool save | ( | nvsg::TextureImageHandle * | image,
 |  | const std::string & | fileName
 | ) | [virtual]

Pure virtual interface function to save a TextureImage.

Saves the texture image image to the file given by filename.

Returns:
true, if the TextureImage was saved successfully, otherwise false.

Implements TextureSaver.

Friends And Related Function Documentation

bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) | [friend]

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a OBJSAVER. If the PlugIn ID piid equals PIID_NVSG_SCENE_SAVER, a OBJSAVER is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

The documentation for this class was generated from the following file:
  • ILTexSaver.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

ILTexSaver Member List

This is the complete list of members for ILTexSaver, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | ILTexSaver | [inline, virtual]
getPlugInterface(const nvutil::UPIID &piid, nvutil::PlugIn *&pi) | ILTexSaver | [friend]
ILTexSaver() (defined in ILTexSaver) | ILTexSaver |
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(nvsg::TextureImageHandle *image, const std::string &fileName) | ILTexSaver | [virtual]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~ILTexSaver() (defined in ILTexSaver) | ILTexSaver | [protected, virtual]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~TextureSaver() | TextureSaver | [protected, virtual]
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Image Struct Reference

Helper structure to hold the data of an image. More...

#include <TextureImage.h>

List of all members.

Public Types

enum PixelFormat {
IMG_UNKNOWN_FORMAT = -1, IMG_COLOR_INDEX = 0, IMG_RGB, IMG_RGBA,
IMG_BGR, IMG_BGRA, IMG_LUMINANCE, IMG_LUMINANCE_ALPHA,
IMG_ALPHA, IMG_DEPTH_COMPONENT, IMG_DEPTH_STENCIL, IMG_INTEGER_ALPHA,
IMG_INTEGER_LUMINANCE, IMG_INTEGER_LUMINANCE_ALPHA, IMG_INTEGER_RGB, IMG_INTEGER_BGR,
IMG_INTEGER_RGBA, IMG_INTEGER_BGRA, IMG_COMPRESSED_LUMINANCE_LATC1, IMG_COMPRESSED_SIGNED_LUMINANCE_LATC1,
IMG_COMPRESSED_LUMINANCE_ALPHA_LATC2, IMG_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2, IMG_COMPRESSED_RED_RGTC1, IMG_COMPRESSED_SIGNED_RED_RGTC1,
IMG_COMPRESSED_RG_RGTC2, IMG_COMPRESSED_SIGNED_RG_RGTC2, IMG_COMPRESSED_RGB_DXT1, IMG_COMPRESSED_RGBA_DXT1,
IMG_COMPRESSED_RGBA_DXT3, IMG_COMPRESSED_RGBA_DXT5, IMG_COMPRESSED_SRGB_DXT1, IMG_COMPRESSED_SRGBA_DXT1,
IMG_COMPRESSED_SRGBA_DXT3, IMG_COMPRESSED_SRGBA_DXT5, IMG_NUM_FORMATS
}
enum PixelDataType {
IMG_UNKNOWN_TYPE = -1, IMG_BYTE = 0, IMG_UNSIGNED_BYTE, IMG_SHORT,
IMG_UNSIGNED_SHORT, IMG_INT, IMG_UNSIGNED_INT, IMG_FLOAT32,
IMG_FLOAT16, IMG_UNSIGNED_INT_2_10_10_10, IMG_UNSIGNED_INT_5_9_9_9, IMG_UNSIGNED_INT_10F_11F_11F,
IMG_UNSIGNED_INT_24_8, IMG_NUM_TYPES, IMG_FLOAT = IMG_FLOAT32, IMG_HALF = IMG_FLOAT16
}
Enumeration type to describe the data type of pixel data. More...

Public Member Functions

NVSG_API | Image ()
Default constructor of Image.

NVSG_API | Image (unsigned int width, unsigned int height, unsigned int depth, PixelFormat format, PixelDataType type)
Constructor of an Image structure.

Public Attributes

unsigned int | m_width
width of the texture in pixels

unsigned int | m_height
height of the texture in pixels

unsigned int | m_depth
depth of the texture in pixels

PixelFormat m_format
specifies format of pixel data

PixelDataType m_type
specifies type of pixel data

unsigned int | m_bpp
bytes per pixel

unsigned int | m_bpl
bytes per scanline

unsigned int | m_bps
bytes per slice (plane)

unsigned int | m_nob
number of bytes (complete image)

unsigned char * | m_pixels
raw image data (we use unsigned char as internal format)

Detailed Description

Helper structure to hold the data of an image.

Namespace: nvsg
See also:
insert, rescale

Member Enumeration Documentation

enum PixelFormat

Enumeration type to describe a pixel data format Essentially the "Format" parameter to TexImage

Enumeration values:
IMG_UNKNOWN_FORMAT | unknown pixel format
IMG_COLOR_INDEX | color index format
IMG_RGB | RGB format.
IMG_RGBA | RGBA format.
IMG_BGR | BGR format.
IMG_BGRA | BGRA format.
IMG_LUMINANCE | luminance format
IMG_LUMINANCE_ALPHA | luminance alpha format
IMG_ALPHA | Alpha only format.
IMG_DEPTH_COMPONENT | Depth only ( ARB_depth_texture ).
IMG_DEPTH_STENCIL | Depth + stencil - EXT_packed_depth_stencil.
IMG_NUM_FORMATS | specifies number of valid format descriptors

enum PixelDataType

Enumeration type to describe the data type of pixel data.

Enumeration values:
IMG_UNKNOWN_TYPE | unknown data type
IMG_BYTE | signed byte type (8-bit)
IMG_UNSIGNED_BYTE | unsigned byte type (8-bit)
IMG_SHORT | signed short type (16-bit)
IMG_UNSIGNED_SHORT | unsigned short type (16-bit)
IMG_INT | signed integer type (32-bit)
IMG_UNSIGNED_INT | unsigned integer type (32-bit)
IMG_FLOAT32 | single-precision floating point (32-bit)
IMG_FLOAT16 | half-precision floating point (16-bit)
IMG_UNSIGNED_INT_2_10_10_10 | 2 Bits A, 10 bits RGB (RGB10/10A2)
IMG_UNSIGNED_INT_5_9_9_9 | 5 bits exponent 9 bits RGB mantissa
IMG_UNSIGNED_INT_10F_11F_11F | 5 bits exp + 5,6,6 bits RGB mantissa
IMG_UNSIGNED_INT_24_8 | 24 bits depth, 8 bits stencil
IMG_NUM_TYPES | specifies number of valid type descriptors

Constructor & Destructor Documentation

NVSG_API Image ( )

Default constructor of Image.

Remarks:
Initializes an empty Image with no data.

NVSG_API Image | ( | unsigned int | width,
 |  | unsigned int | height,
 |  | unsigned int | depth,
 |  | PixelFormat | format,
 |  | PixelDataType | type
 | ) |

Constructor of an Image structure.

Parameters:
width | The width of the Image.
height | The height of the Image.
depth | The depth of the Image.
format | The PixelFormat of the Image.
type | The PixelDataType of the Image.
Remarks:
This constructor allocates no memory for the pixel data, it just initialized the structure Image to hold the information for it.
Note:
The bytes per pixel can be determined out of format (giving number of components) and type (giving size of components).

Member Data Documentation

unsigned int m_width

width of the texture in pixels

unsigned int m_height

height of the texture in pixels

unsigned int m_depth

depth of the texture in pixels

PixelFormat m_format

specifies format of pixel data

PixelDataType m_type

specifies type of pixel data

unsigned int m_bpp

bytes per pixel

unsigned int m_bpl

bytes per scanline

unsigned int m_bps

bytes per slice (plane)

unsigned int m_nob

number of bytes (complete image)

unsigned char* m_pixels

raw image data (we use unsigned char as internal format)

The documentation for this struct was generated from the following file:
  • TextureImage.h
Generated on Tue Jan 15 10:29:20 2008 for NVSGSDK by NVIDIA


Member List

Image Member List

This is the complete list of members for Image, including all inherited members.
Image() | Image
Image(unsigned int width, unsigned int height, unsigned int depth, PixelFormat format, PixelDataType type) | Image
IMG_ALPHA enum value | Image
IMG_BGR enum value | Image
IMG_BGRA enum value | Image
IMG_BYTE enum value | Image
IMG_COLOR_INDEX enum value | Image
IMG_COMPRESSED_LUMINANCE_ALPHA_LATC2 enum value (defined in Image) | Image
IMG_COMPRESSED_LUMINANCE_LATC1 enum value (defined in Image) | Image
IMG_COMPRESSED_RED_RGTC1 enum value (defined in Image) | Image
IMG_COMPRESSED_RG_RGTC2 enum value (defined in Image) | Image
IMG_COMPRESSED_RGB_DXT1 enum value (defined in Image) | Image
IMG_COMPRESSED_RGBA_DXT1 enum value (defined in Image) | Image
IMG_COMPRESSED_RGBA_DXT3 enum value (defined in Image) | Image
IMG_COMPRESSED_RGBA_DXT5 enum value (defined in Image) | Image
IMG_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 enum value (defined in Image) | Image
IMG_COMPRESSED_SIGNED_LUMINANCE_LATC1 enum value (defined in Image) | Image
IMG_COMPRESSED_SIGNED_RED_RGTC1 enum value (defined in Image) | Image
IMG_COMPRESSED_SIGNED_RG_RGTC2 enum value (defined in Image) | Image
IMG_COMPRESSED_SRGB_DXT1 enum value (defined in Image) | Image
IMG_COMPRESSED_SRGBA_DXT1 enum value (defined in Image) | Image
IMG_COMPRESSED_SRGBA_DXT3 enum value (defined in Image) | Image
IMG_COMPRESSED_SRGBA_DXT5 enum value (defined in Image) | Image
IMG_DEPTH_COMPONENT enum value | Image
IMG_DEPTH_STENCIL enum value | Image
IMG_FLOAT enum value (defined in Image) | Image
IMG_FLOAT16 enum value | Image
IMG_FLOAT32 enum value | Image
IMG_HALF enum value (defined in Image) | Image
IMG_INT enum value | Image
IMG_INTEGER_ALPHA enum value (defined in Image) | Image
IMG_INTEGER_BGR enum value (defined in Image) | Image
IMG_INTEGER_BGRA enum value (defined in Image) | Image
IMG_INTEGER_LUMINANCE enum value (defined in Image) | Image
IMG_INTEGER_LUMINANCE_ALPHA enum value (defined in Image) | Image
IMG_INTEGER_RGB enum value (defined in Image) | Image
IMG_INTEGER_RGBA enum value (defined in Image) | Image
IMG_LUMINANCE enum value | Image
IMG_LUMINANCE_ALPHA enum value | Image
IMG_NUM_FORMATS enum value | Image
IMG_NUM_TYPES enum value | Image
IMG_RGB enum value | Image
IMG_RGBA enum value | Image
IMG_SHORT enum value | Image
IMG_UNKNOWN_FORMAT enum value | Image
IMG_UNKNOWN_TYPE enum value | Image
IMG_UNSIGNED_BYTE enum value | Image
IMG_UNSIGNED_INT enum value | Image
IMG_UNSIGNED_INT_10F_11F_11F enum value | Image
IMG_UNSIGNED_INT_24_8 enum value | Image
IMG_UNSIGNED_INT_2_10_10_10 enum value | Image
IMG_UNSIGNED_INT_5_9_9_9 enum value | Image
IMG_UNSIGNED_SHORT enum value | Image
m_bpl | Image
m_bpp | Image
m_bps | Image
m_depth | Image
m_format | Image
m_height | Image
m_nob | Image
m_pixels | Image
m_type | Image
m_width | Image
PixelDataType enum name | Image
PixelFormat enum name | Image
Generated on Tue Jan 15 10:29:20 2008 for NVSGSDK by NVIDIA


Incarnation Class Reference

This class abstracts an incarnation count. More...

#include <Incarnation.h>

List of all members.

Public Member Functions

NVSG_API | Incarnation ()
Default constructor.

NVSG_API bool | operator== (const Incarnation &rhs) const
Comparison operator.

NVSG_API bool | operator!= (const Incarnation &rhs) const
Comparison operator.

NVSG_API Incarnation & | operator++ ()
Pre-increment operator.

NVSG_API const Incarnation | operator++ (int)
Post-increment operator.

NVSG_API Incarnation | operator+ (int i) const
Addition operator.

Detailed Description

This class abstracts an incarnation count.

The main feature is that the embedded counter will always be initialized to a defined value. This class also provides convenient assignment, comparison and incrementation of the embedded counter.

Constructor & Destructor Documentation

NVSG_API Incarnation ( )

Default constructor.

The embedded counter will be initialized to some random number.

Member Function Documentation

bool operator== ( const Incarnation & rhs ) const [inline]

Comparison operator.

Returns:
true if the embedded counter of the Incarnation object referenced by rhs is equal to this object's embedded counter, false otherwise.

bool operator!= ( const Incarnation & rhs ) const [inline]

Comparison operator.

Returns:
true if the embedded counter of the Incarnation object referenced by rhs is not equal to this object's embedded counter, false otherwise.

Incarnation & operator++ ( ) [inline]

Pre-increment operator.

Increments the embedded counter by one.

Returns:
This object as a l-value object.

const Incarnation operator++ ( int ) [inline]

Post-increment operator.

Increments the embedded counter by one.

Returns:
A const Incarnation object of which the embedded counter's value is equal to the value, the embedded counter of this object had immediately prior to the call to this operator.

Incarnation operator+ ( int i ) const [inline]

Addition operator.

The documentation for this class was generated from the following file:
  • Incarnation.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

Incarnation Member List

This is the complete list of members for Incarnation, including all inherited members.
Incarnation() | Incarnation |
operator!=(const Incarnation &rhs) const | Incarnation | [inline]
operator+(int i) const | Incarnation | [inline]
operator++() | Incarnation | [inline]
operator++(int) | Incarnation | [inline]
operator==(const Incarnation &rhs) const | Incarnation | [inline]
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


IndependentPrimitiveSet Class Reference

Abstract base class for PrimitiveSet objects with independent primitives. More...

#include <IndependentPrimitiveSet.h>

Inheritance diagram for IndependentPrimitiveSet:

[legend]
Collaboration diagram for IndependentPrimitiveSet:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~IndependentPrimitiveSet ()
Destructs a IndependentPrimitiveSet.

virtual NVSG_API bool | isDataShared () const
Query if the data of this IndependentPrimitiveSet is shared.

virtual NVSG_API DataID | getDataID () const
Get the DataID, which uniquely identifies the sharable object data.

NVSG_API bool | hasIndices () const
Query if this IndependentPrimitiveSet has indices.

NVSG_API unsigned int | getNumberOfIndices () const
Get the number of indices.

NVSG_API const unsigned int * | getIndices () const
Get a pointer to the indices.

NVSG_API void | setIndices (const unsigned int *indices, unsigned int numIndices)
Set the indices of this IndependentPrimitiveSet.

NVSG_API void | setIndices (unsigned int pos, const unsigned int *indices, unsigned int numIndices)
Set a subset of indices of this IndependentPrimitiveSet.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other IndependentPrimitiveSet.

Protected Member Functions

NVSG_API | IndependentPrimitiveSet ()
Protected constructor to prevent explicit creation.

NVSG_API | IndependentPrimitiveSet (const PrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | IndependentPrimitiveSet (const IndependentPrimitiveSet &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Calculates the bounding box of this IndependentPrimitiveSet.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this IndependentPrimitiveSet.

NVSG_API IndependentPrimitiveSet & | operator= (const IndependentPrimitiveSet &rhs)
Assignment operator.

Detailed Description

Abstract base class for PrimitiveSet objects with independent primitives.

Namespace: nvsg
Remarks:
An IndependentPrimitiveSet is, for example, a Lines, a Quads, or a Triangles object. It holds a vector of indices, where each set of consecutive indices describe one primitive. The size of such a set depends on the primitive type - for example, 3 for Triangles or 4 for Quads.
See also:
Lines, PrimitiveSet, Quads, Triangles

Constructor & Destructor Documentation

virtual NVSG_API ~IndependentPrimitiveSet ( ) [virtual]

Destructs a IndependentPrimitiveSet.

NVSG_API IndependentPrimitiveSet ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
The newly created IndependentPrimitiveSet has no indices.
Note:
An IndependentPrimitiveSet will not be instantiated directly, but through instantiating a derived object like Quads or Triangles for example.

NVSG_API IndependentPrimitiveSet ( const PrimitiveSet & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to a constant PrimitiveSet.
Remarks:
The PrimitiveSet part of the newly created IndependentPrimitiveSet is copied from rhs; the IndependentPrimitiveSet specific data is initialized as if the default constructor had been called.
Note:
An IndependentPrimitiveSet will not be instantiated directly, but by instantiating a derived object like Quads or Triangles, for example.

NVSG_API IndependentPrimitiveSet ( const IndependentPrimitiveSet & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to copy from.
Remarks:
The newly created IndependentPrimitiveSet is copied from rhs.
Note:
An IndependentPrimitiveSet will not be instantiated directly, but by instantiating a derived object like Quads or Triangles, for example.

Member Function Documentation

virtual NVSG_API bool isDataShared ( ) const [virtual]

Query if the data of this IndependentPrimitiveSet is shared.

Returns:
true if the data is shared, otherwise false.
See also:
getDataID

Reimplemented from Object.

Reimplemented in SkinnedTriangles.

virtual NVSG_API DataID getDataID ( ) const [virtual]

Get the DataID, which uniquely identifies the sharable object data.

Returns:
The unique DataID, which identifies the object data.
See also:
isDataShared

Reimplemented from Object.

Reimplemented in SkinnedTriangles.

bool hasIndices ( ) const [inline]

Query if this IndependentPrimitiveSet has indices.

Returns:
true, if this IndependentPrimitiveSet has indices, otherwise false.
See also:
getNumberOfIndices, getIndices, setIndices

unsigned int getNumberOfIndices ( ) const [inline]

Get the number of indices.

Returns:
The number of indices of this IndependentPrimitiveSet
See also:
hasIndices, getIndices, setIndices

const unsigned int * getIndices ( ) const [inline]

Get a pointer to the indices.

Returns:
A pointer to the constant indices of this IndependentPrimitiveSet
See also:
hasIndices, getNumberOfIndices, setIndices

NVSG_API void setIndices | ( | const unsigned int * | indices,
 |  | unsigned int | numIndices
 | ) |

Set the indices of this IndependentPrimitiveSet.

Parameters:
indices | A pointer to the constant indices to use.
numIndices | The number of indices.
Remarks:
Copies numIndices indices from indices into this IndependentPrimitiveSet.
Note:
The behavior is undefined if there are less than numIndices values of type unsigned int located at indices.
See also:
hasIndices, getNumberOfIndices, getIndices

NVSG_API void setIndices | ( | unsigned int | pos,
 |  | const unsigned int * | indices,
 |  | unsigned int | numIndices
 | ) |

Set a subset of indices of this IndependentPrimitiveSet.

Parameters:
pos | The start position inside the range of pre-existing indices
indices | A pointer to the constant indices to use
numIndices | The number of indices
Remarks:
Copies numIndices indices from indices into this IndependentPrimitiveSet, starting at position pos inside the range of pre-existing indices.
Pre-existing indices in the range [pos, pos + numIndices) will be replaced. Pre-existing indices outside this range remain untouched.
If you specifiy (-1) for pos or pos specifies the number of indices currently stored, the indices pointed to by indices will be appended to the pre-existing indices.
Note:
The behavior is undefined if pos is neither a valid position inside the range of pre-existing indices, nor the number of indices currently stored, nor (-1).

The behavior is undefined if there are less than numIndices values of type unsigned int located at indices.

See also:
hasIndices, getNumberOfIndices, getIndices

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other IndependentPrimitiveSet.

Parameters:
p | A reference to the constant IndependentPrimitiveSet with which to to test for equivalence.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparison; default is false.
Returns:
true if the IndependentPrimitiveSet p is equivalent to this, otherwise false.
Remarks:
Two IndependentPrimitiveSet objects are equivalent if they are equivalent as PrimitiveSet and all their indices are pairwise equal.
Note:
The behavior is undefined if p is not an IndependentPrimitiveSet nor derived from one.
See also:
PrimitiveSet

Reimplemented from PrimitiveSet.

Reimplemented in SkinnedTriangles.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Calculates the bounding box of this IndependentPrimitiveSet.

Returns:
The axis-aligned bounding box of this IndependentPrimitiveSet.
Remarks:
This function is called by the framework when re-calculation of the bounding box is required for this IndependentPrimitiveSet.

Implements Drawable.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this IndependentPrimitiveSet.

Returns:
A nvmath::Sphere3f that contains the complete IndependentPrimitiveSet.
Remarks:
This function is called by the framework to determine a sphere that completely contains the IndependentPrimitiveSet.

Implements Drawable.

NVSG_API IndependentPrimitiveSet& operator= ( const IndependentPrimitiveSet & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to copy from.
Returns:
A reference to the assigned IndependentPrimitiveSet.
Remarks:
The assignment operator calls the assignment operator of PrimitiveSet and copies the indices.

The documentation for this class was generated from the following file:
  • IndependentPrimitiveSet.h
Generated on Tue Jan 15 10:29:06 2008 for NVSGSDK by NVIDIA


Member List

IndependentPrimitiveSet Member List

This is the complete list of members for IndependentPrimitiveSet, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | IndependentPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getName() const | Object |
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setIndices(const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setIndices(unsigned int pos, const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
Generated on Tue Jan 15 10:29:06 2008 for NVSGSDK by NVIDIA


IndexMesh Class Reference

IndexSet specialization used with a MeshedPrimitiveSet. More...

#include <MeshedPrimitiveSet.h>

List of all members.

Public Member Functions

IndexMesh (unsigned int width, unsigned int height)
unsigned int | getWidth (void) const
unsigned int | getHeight (void) const
void | setDimensions (unsigned int width, unsigned int height)

Detailed Description

IndexSet specialization used with a MeshedPrimitiveSet.

Namespace: nvsg
See also:
IndexSet

The documentation for this class was generated from the following file:
  • MeshedPrimitiveSet.h
Generated on Tue Jan 15 10:29:10 2008 for NVSGSDK by NVIDIA


Member List

IndexMesh Member List

This is the complete list of members for IndexMesh, including all inherited members.
getHeight(void) const (defined in IndexMesh) | IndexMesh | [inline]
getWidth(void) const (defined in IndexMesh) | IndexMesh | [inline]
IndexMesh(void) (defined in IndexMesh) | IndexMesh | [inline]
IndexMesh(unsigned int width, unsigned int height) (defined in IndexMesh) | IndexMesh | [inline]
setDimensions(unsigned int width, unsigned int height) (defined in IndexMesh) | IndexMesh | [inline]
Generated on Tue Jan 15 10:29:10 2008 for NVSGSDK by NVIDIA


indexSet_t Struct Reference

The indexSet_t structure specifies how an index set is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t numIndices
Specifies the number of indices in the actual index set.

uint_t indices

Detailed Description

The indexSet_t structure specifies how an index set is stored in a .NBF file.

Index sets, in this context, need to be considered in conjunction with NBFStrippedPrimitiveSet objects.

Member Data Documentation

uint_t numIndices

Specifies the number of indices in the actual index set.

uint_t indices

Specifies the file offset to the indices. As specified by the NBF format, < a index is a 32-bit unsigned integer value.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

indexSet_t Member List

This is the complete list of members for indexSet_t, including all inherited members.
indices | indexSet_t
numIndices | indexSet_t
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Intersection Class Reference

Intersection class. More...

#include <RayIntersectTraverser.h>

Collaboration diagram for Intersection:

[legend]
List of all members.

Public Member Functions

Intersection (void)
Default constructor.

NVSG_API | Intersection (const nvsg::Path *pPath, nvsg::DrawableHandle *pDrawable, const nvmath::Vec3f &isp, float dist, unsigned int primitiveIndex, const std::vector< unsigned int > &vertexIndices)
Constructor.

NVSG_API | Intersection (const Intersection &rhs)
Copy constructor.

virtual NVSG_API | ~Intersection (void)
Default destructor.

NVSG_API Intersection & | operator= (const Intersection &rhs)
Assignment operator.

NVSG_API const nvsg::Path * | getPath () const
Get the Path to the intersected drawable.

NVSG_API nvsg::DrawableHandle * | getDrawable () const
Get the intersected drawable.

NVSG_API const nvmath::Vec3f & | getIsp () const
Get the intersection point on the intersected drawable.

NVSG_API float | getDist () const
Get the distance from the ray origin to the intersection point.

NVSG_API unsigned int | getPrimitiveIndex () const
Get the index of the intersected primitive.

NVSG_API const std::vector<
unsigned int > & 		getVertexIndices () const
Get the indices if the intersected face, line or point.

Protected Member Functions

NVSG_API void | clone (const Intersection &rhs)
Clone the whole object.

Protected Attributes

nvsg::DrawableHandle * m_pDrawable
Intersected drawable.

const nvsg::Path * | m_pPath
Path to the intersected drawable.

nvmath::Vec3f m_isp
Intersection point on the intersected drawable.

float | m_dist
Distance from the ray origin to the intersection point.

unsigned int | m_primitiveIndex
Index of the intersected primitive in the Drawable.

std::vector< unsigned int > | m_vertexIndices
Indices of the vertices of the intersected primitive.

Detailed Description

Intersection class.

This class is used to store intersection results generated by the RayIntersectTraverser. It should only be used with classes derived from RayIntersectTraveser because some information like the distance makes sense only when knowing the ray data.

Note:
Needs a valid ViewState. Call setViewState prior to apply().

Constructor & Destructor Documentation

Intersection ( void ) [inline]

Default constructor.

Intersection | ( | const nvsg::Path * | pPath,
 |  | nvsg::DrawableHandle * | pDrawable,
 |  | const nvmath::Vec3f & | isp,
 |  | float | dist,
 |  | unsigned int | primitiveIndex,
 |  | const std::vector< unsigned int > & | vertexIndices
 | ) | [inline]

Constructor.

This contructor creates an intersection object from the given data. It also performs an addRef() on the given path and drawable.

Parameters:
pPath | Path to the intersected drawable.
pDrawable | Intersected drawable.
isp | Intersection point on the drawable.
dist | Distance from the ray origin to the drawable.
primitiveIndex | Index of the intersected primitive in the Drawable.
vertexIndices | Indices of the vertices of the intersected primitive.

Intersection ( const Intersection & rhs ) [inline]

Copy constructor.

Creates a new Intersection object from the given one.

Parameters:
rhs Intersection object to copy from.

~Intersection ( void ) [inline, virtual]

Default destructor.

Member Function Documentation

Intersection & operator= ( const Intersection & rhs ) [inline]

Assignment operator.

const nvsg::Path * getPath ( ) const [inline]

Get the Path to the intersected drawable.

Returns:
Path to the drawable.

nvsg::DrawableHandle * getDrawable ( ) const [inline]

Get the intersected drawable.

Returns:
Intersected drawable.

const nvmath::Vec3f & getIsp ( ) const [inline]

Get the intersection point on the intersected drawable.

Returns:
Intersection Point.

float getDist ( ) const [inline]

Get the distance from the ray origin to the intersection point.

Returns:
Distance from ray origin to intersection point.

unsigned int getPrimitiveIndex ( ) const [inline]

Get the index of the intersected primitive.

Returns:
An index to the intersected primitive.
Remarks:
This function returns the index of the intersected primitive. e.g. the i-th strip in a TriangleStrip or the i-th triangle in Triangles. With this index you have the abilitiy to access the primitive and modify it.

const std::vector< unsigned int > & getVertexIndices ( ) const [inline]

Get the indices if the intersected face, line or point.

Returns:
Indices to the vertex data of the intersected line, face or point.
Remarks:
The vertices that are returned can be used to access the vertices of the intersected object. The size of this vector determines the primitive category. E.g. If the size of this vector is 3 then the intersected face is a triangle. (4 is a Quad, 2 is a line, 1 a point...)
  // How to access the vertices and normals of the intersected triangle in a triangle strip
  const Vec3f * vertices = intersection->getDrawable()->getVertexAttributeSet()->getVertices();
  const Vec3f * normals = intersection->getDrawable()->getVertexAttributeSet()->getNormals();
  const IndexSet & strip = intersection->getDrawable()->getStrips()[intersection->getPrimitiveIndex()];
  const std::vector<unsigned int> & vertIndices = intersection->getVertexIndices();

  const Vec3f & v0 = vertices[strip[vertIndices[0]]];
  const Vec3f & v1 = vertices[strip[vertIndices[1]]];
  const Vec3f & v2 = vertices[strip[vertIndices[2]]];

  const Vec3f & n0 = normals[strip[vertIndices[0]]];
  const Vec3f & n1 = normals[strip[vertIndices[1]]];
  const Vec3f & n2 = normals[strip[vertIndices[2]]];

void clone ( const Intersection & rhs ) [inline, protected]

Clone the whole object.

Use this, for example, for the copy constructor.

Parameters:
rhs Object to clone.

Member Data Documentation

nvsg::DrawableHandle* m_pDrawable [protected]

Intersected drawable.

const nvsg::Path* m_pPath [protected]

Path to the intersected drawable.

nvmath::Vec3f m_isp [protected]

Intersection point on the intersected drawable.

float m_dist [protected]

Distance from the ray origin to the intersection point.

unsigned int m_primitiveIndex [protected]

Index of the intersected primitive in the Drawable.

std::vector<unsigned int> m_vertexIndices [protected]

Indices of the vertices of the intersected primitive.

The documentation for this class was generated from the following file:
  • RayIntersectTraverser.h
Generated on Tue Jan 15 10:29:33 2008 for NVSGSDK by NVIDIA


Member List

Intersection Member List

This is the complete list of members for Intersection, including all inherited members.
clone(const Intersection &rhs) | Intersection | [inline, protected]
getDist() const | Intersection | [inline]
getDrawable() const | Intersection | [inline]
getIsp() const | Intersection | [inline]
getPath() const | Intersection | [inline]
getPrimitiveIndex() const | Intersection | [inline]
getVertexIndices() const | Intersection | [inline]
Intersection(void) | Intersection | [inline]
Intersection(const nvsg::Path *pPath, nvsg::DrawableHandle *pDrawable, const nvmath::Vec3f &isp, float dist, unsigned int primitiveIndex, const std::vector< unsigned int > &vertexIndices) | Intersection | [inline]
Intersection(const Intersection &rhs) | Intersection | [inline]
m_dist | Intersection | [protected]
m_isp | Intersection | [protected]
m_pDrawable | Intersection | [protected]
m_pPath | Intersection | [protected]
m_primitiveIndex | Intersection | [protected]
m_vertexIndices | Intersection | [protected]
operator=(const Intersection &rhs) | Intersection | [inline]
~Intersection(void) | Intersection | [inline, virtual]
Generated on Tue Jan 15 10:29:33 2008 for NVSGSDK by NVIDIA


TemplateKeyFramedAnimation class Reference

KeyFramedAnimation Class Template Reference

Abstract base class for key-framed Animations of type T. More...

#include <KeyFramedAnimation.h>

Inheritance diagram for KeyFramedAnimation:

[legend]
Collaboration diagram for KeyFramedAnimation:

[legend]
List of all members.

Public Member Functions

virtual | ~KeyFramedAnimation (void)
Destructs a KeyFramedAnimation.

void | addKey (unsigned int step, const T &value)
Add a single key frame to the end of the Animation.

void | addKeys (unsigned int numberOfKeys, const unsigned int *steps, const T *values)
Add a number of key frames to the end of the Animation.

void | insertKey (unsigned int key, unsigned int step, const T &value)
Insert a key frame defining a step with a value.

unsigned int | getKeyStep (unsigned int key) const
Get the step index corresponding to the key key.

const unsigned int * | getKeySteps () const
Get a pointer to the key frame indices.

const T & | getKeyValue (unsigned int key) const
Get the value of type T corresponding to the key key.

const T * | getKeyValues () const
Get a pointer to the animation key frame values.

unsigned int | getNumberOfKeys (void) const
Get the number of keys in this KeyFramedAnimation.

virtual const T & | getCurrentValue () const
Get the current value of this Animation.

virtual T | getStepValue (unsigned int step) const
Get the value of a KeyFramedAnimation at the specified step.

void | replaceKey (unsigned int key, unsigned int step, const T &value)
Replace step and value of a specified key frame.

void | replaceKeys (unsigned int key, unsigned int numberOfKeys, const unsigned int *steps, const T *values)
Replace steps and values of a number of consecutive key frames.

void | removeKey (unsigned int key)
Remove a single key frame from the Animation.

void | removeKeys (unsigned int key, unsigned int numberOfKeys)
Remove a number of consecutive keys frames.

void | reserveKeys (unsigned int numberOfKeys)
Reserve space for a specified number of key frames.

virtual void | replaceStep (unsigned int step, const T &value)
Replace the value at the specified animation step.

virtual void | removeStep (unsigned int step)
Remove the current frame.

virtual bool | isCompatible (const Animation< T > *p) const
Test for compatibility with an other Animation.

virtual bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another KeyFramedAnimation of type T.

Protected Member Functions

KeyFramedAnimation (void)
Protected constructor to prevent explicit creation.

KeyFramedAnimation (const KeyFramedAnimation &rhs)
Protected copy constructor to prevent explicit creation.

unsigned int | getKey (unsigned int frame) const
Get the key above or equal to frame frame.

KeyFramedAnimation< T > & | operator= (const KeyFramedAnimation< T > &rhs)
Protected assignment operator.

Detailed Description

template<typename T>
class nvsg::KeyFramedAnimation< T >

Abstract base class for key-framed Animations of type T.

Namespace: nvsg
Remarks:
A KeyFramedAnimation holds the information for a key-frame based animation. For each key, it holds the frame corresponding to that key, and a value of type T that is to be interpolated between the frames of successive keys. It provides the interface needed for an interpolated animation, but does not perform any interpolations. Interpolations must be performed by a derived class such as LinearInterpolatedAnimation.
See also:
Animation, LinearInterpolatedAnimation

Constructor & Destructor Documentation

~KeyFramedAnimation ( void ) [inline, virtual]

Destructs a KeyFramedAnimation.

KeyFramedAnimation ( void ) [inline, protected]

Protected constructor to prevent explicit creation.

Remarks:
The current frame is set to be invalid, and there are no keys or values.
Note:
Because KeyFramedAnimation is an abstract class, its constructor is never used explicitly, but in the constructor of derived classes.

KeyFramedAnimation ( const KeyFramedAnimation< T > & rhs ) [inline, protected]

Protected copy constructor to prevent explicit creation.

Remarks:
Keys and values, as well as the current frame are copied from rhs.
Note:
Because KeyFramedAnimation is an abstract class, its constructor is never used explicitly, but in the constructor of derived classes.

Member Function Documentation

void addKey | ( | unsigned int | step,
 |  | const T & | value
 | ) | [inline]

Add a single key frame to the end of the Animation.

Parameters:
step | The frame index of the key frame.
value | The value of the key frame.
Note:
The behavior is undefined if this KeysFramedAnimation already holds at least one key frame and step is less or equal to the step of the current last key frame.
See also:
addKeys, reserveKeys

void addKeys | ( | unsigned int | numberOfKeys,
 |  | const unsigned int * | steps,
 |  | const T * | values
 | ) | [inline]

Add a number of key frames to the end of the Animation.

Parameters:
numberOfKeys | The number of key frames to add as the last key frames.
steps | A pointer to the frame indices of the key frames.
values | A pointer to the values of the key frames.
Note:
The behavior is undefined if the steps in steps are not strictly increasing, or this KeyFramedAnimation already holds at least one key frame and the first step in steps is less or equal to the step of the current last key frame.
See also:
addKey, reserveKeys

void insertKey | ( | unsigned int | key,
 |  | unsigned int | step,
 |  | const T & | value
 | ) | [inline]

Insert a key frame defining a step with a value.

Parameters:
key | Index of the key to insert.
step | Step of the new key frame.
value | Value of the new key frame.
Remarks:
If the key frame at index key already specifies animation step step, the value of that key frame is replaced by value. Otherwise a new key frame at index key with the given step and value is inserted.
Note:
The behavior is undefined if step is not greater than the step value of the key frame before key, or if step is not smaller than the step value of the key frame after key.

unsigned int getKeyStep ( unsigned int key ) const [inline]

Get the step index corresponding to the key key.

Parameters:
key The key index from which to get the corresponding step.
Returns:
The step index corresponding to the key key
Note:
The behavior is undefined if key is greater than or equal to the number of keys.
See also:
getNumberOfKeys, getKeyValue

const unsigned int * getKeySteps ( ) const [inline]

Get a pointer to the key frame indices.

Returns:
A constant pointer to the key frame indices.
See also:
getKeyStep, getKeyValue, getKeyValues

const T & getKeyValue ( unsigned int key ) const [inline]

Get the value of type T corresponding to the key key.

Parameters:
key The key index to get the corresponding value of type T of.
Returns:
The value of type T corresponding to the key key.
Note:
The behavior is undefined if key is greater than or equal to the number of keys.
See also:
getKeyStep, getNumberOfKeys

const T * getKeyValues ( ) const [inline]

Get a pointer to the animation key frame values.

Returns:
A constant pointer to the animation key frame values.
See also:
getKeyValue, getKeySteps

unsigned int getNumberOfKeys ( void ) const [inline]

Get the number of keys in this KeyFramedAnimation.

Returns:
The number of keys
Remarks:
A key frame is defined by the step corresponding to a key, and a value of type T.
See also:
getKeyStep, getKeyValue

const T & getCurrentValue ( ) const [inline, virtual]

Get the current value of this Animation.

Returns:
The current value of this Animation.
Remarks:
The current value is used in the current animation step.
See also:
getCurrentStep

Implements Animation.

Reimplemented in LinearInterpolatedAnimation.

T getStepValue ( unsigned int step ) const [inline, virtual]

Get the value of a KeyFramedAnimation at the specified step.

Parameters:
step Index of the step to get the value at.
Returns:
The value at the specified step.
Remarks:
For a KeyFramedAnimation, the value at the specified step equals the value at the key frame just before step.
Note:
The behavior is undefined if step is larger than or equal to the current number of steps.
See also:
getNumberOfStep, getStepValues

Implements Animation.

Reimplemented in LinearInterpolatedAnimation.

void replaceKey | ( | unsigned int | key,
 |  | unsigned int | step,
 |  | const T & | value
 | ) | [inline]

Replace step and value of a specified key frame.

Parameters:
key | The key frame to replace step and value.
step | The step index to use for key frame key.
value | The value to use for key frame key.
Note:
The behavior is undefined if step is less or equal to the step of the key frame key - 1, if that exists, or if step is greater or equal to the step of the key frame key + 1, if that exists.
See also:
replaceKeys

void replaceKeys | ( | unsigned int | key,
 |  | unsigned int | numberOfKeys,
 |  | const unsigned int * | steps,
 |  | const T * | values
 | ) | [inline]

Replace steps and values of a number of consecutive key frames.

Parameters:
key | The first key frame to change step and value of.
numberOfKeys | The number of key frames to change.
steps | A constant pointer to the step indices to use.
values | A constant pointer to the values to use.
Note:
The behavior is undefined if the steps in steps are not strictly increasing, or the first step in steps is less or equal to the step of key frame key - 1, if that exists, or the last step in steps is greater or equal to the step of key frame key + numberOfKeys + 1, if that exists.
See also:
replaceKey

void removeKey ( unsigned int key ) [inline]

Remove a single key frame from the Animation.

Parameters:
key The key frame to remove from the Animation.
Note:
The behavior is undefined if key is larger than or equal to the current number of keys.
See also:
removeKeys, getNumberOfKeys

void removeKeys | ( | unsigned int | key,
 |  | unsigned int | numberOfKeys
 | ) | [inline]

Remove a number of consecutive keys frames.

Parameters:
key | The first key frame to remove.
numberOfKeys | The number of key frames to remove.
Note:
The behavior is undefined if key + numberOfKeys is larger than or equal to the current number of steps.
See also:
removeKey, getNumberOfKeys

void reserveKeys ( unsigned int numberOfKeys ) [inline]

Reserve space for a specified number of key frames.

Parameters:
numberOfKeys Reserve space for that number of key frames.
See also:
addKey, addKeys

void replaceStep | ( | unsigned int | step,
 |  | const T & | value
 | ) | [inline, virtual]

Replace the value at the specified animation step.

Parameters:
step | The step index of the animation to replace.
value | The value to use for the specified step.
Remarks:
The animation step step is replaced by inserting a key frame at the specified animation step.
See also:
insertKey

Implements Animation.

void removeStep ( unsigned int step ) [inline, virtual]

Remove the current frame.

Parameters:
step The step index to remove.
Remarks:
The animation step step is removed by inserting two key frames to the left and right of the animation step step and decrementing the step index of each key frame after the animation step to remove by one. If there is a key frame defined at the animation step step, it is removed.
See also:
insertKey, removeKey

bool isCompatible ( const Animation< T > * p ) const [inline, virtual]

Test for compatibility with an other Animation.

Parameters:
p A pointer to the other Animation.
Returns:
true if this and p are compatible, otherwise false.
Remarks:
A KeyFramedAnimation is compatible with an other, when their Animation parts are equivalent, and their key values are equal.
See also:
isEquivalent

Implements Animation.

bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [inline, virtual]

Test for equivalence with another KeyFramedAnimation of type T.

Parameters:
p | A reference to the constant KeyFramedAnimation of type T to test for equivalence with
ignoreNames | Optional parameter to ignore the names of the objects; default is true
deepCompare | Optional parameter to perform a deep comparsion; default is false
Returns:
true if the KeyFramedAnimation p of type T is equivalent to this, otherwise false.
Remarks:
Two KeyFramedAnimation objects of type T are equivalent if they are equivalent as Animation of type T, and all of their keys and values are pair-wise equal.
Note:
The behavior is undefined if p is not an KeyFramedAnimation of type T nor derived from one.
See also:
Animation

Reimplemented from Animation.

unsigned int getKey ( unsigned int frame ) const [inline, protected]

Get the key above or equal to frame frame.

Parameters:
frame The frame index for which to get the corresponding (or above) key index
Returns:
The key index corresponding to the frame frame, or the key index above.
Remarks:
Note:
The behavior is undefined if frame is greater than or equal to the number of frames.
See also:

KeyFramedAnimation< T > & operator= ( const KeyFramedAnimation< T > & rhs ) [protected]

Protected assignment operator.

Parameters:
rhs Reference of the constant KeyFramedAnimation of type T to copy from
Returns:
A reference to the assigned KeyFramedAnimation of type T
Remarks:
The assignment operator calls the assignment operator of Animation of type T and copies the keys and values, as well as the current frame information.
See also:
Animation

The documentation for this class was generated from the following file:
  • KeyFramedAnimation.h
Generated on Tue Jan 15 10:29:06 2008 for NVSGSDK by NVIDIA


Member List

KeyFramedAnimation Member List

This is the complete list of members for KeyFramedAnimation, including all inherited members.
addKey(unsigned int step, const T &value) | KeyFramedAnimation | [inline]
addKeys(unsigned int numberOfKeys, const unsigned int *steps, const T *values) | KeyFramedAnimation | [inline]
Animation(void) | Animation | [inline, protected]
getCurrentValue() const | KeyFramedAnimation | [inline, virtual]
getFrameValue(unsigned int frame) const | Animation | [inline]
getKey(unsigned int frame) const | KeyFramedAnimation | [inline, protected]
getKeyStep(unsigned int key) const | KeyFramedAnimation | [inline]
getKeySteps() const | KeyFramedAnimation | [inline]
getKeyValue(unsigned int key) const | KeyFramedAnimation | [inline]
getKeyValues() const | KeyFramedAnimation | [inline]
getNumberOfKeys(void) const | KeyFramedAnimation | [inline]
getStepValue(unsigned int step) const | KeyFramedAnimation | [inline, virtual]
insertKey(unsigned int key, unsigned int step, const T &value) | KeyFramedAnimation | [inline]
isCompatible(const Animation< T > *p) const | KeyFramedAnimation | [inline, virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | KeyFramedAnimation | [inline, virtual]
KeyFramedAnimation(void) | KeyFramedAnimation | [inline, protected]
KeyFramedAnimation(const KeyFramedAnimation &rhs) | KeyFramedAnimation | [inline, protected]
operator=(const KeyFramedAnimation< T > &rhs) | KeyFramedAnimation | [protected]
nvsg::Animation::operator=(const Animation< T > &rhs) | Animation | [inline, protected]
removeKey(unsigned int key) | KeyFramedAnimation | [inline]
removeKeys(unsigned int key, unsigned int numberOfKeys) | KeyFramedAnimation | [inline]
removeStep(unsigned int step) | KeyFramedAnimation | [inline, virtual]
replaceKey(unsigned int key, unsigned int step, const T &value) | KeyFramedAnimation | [inline]
replaceKeys(unsigned int key, unsigned int numberOfKeys, const unsigned int *steps, const T *values) | KeyFramedAnimation | [inline]
replaceStep(unsigned int step, const T &value) | KeyFramedAnimation | [inline, virtual]
reserveKeys(unsigned int numberOfKeys) | KeyFramedAnimation | [inline]
~Animation() | Animation | [inline, virtual]
~KeyFramedAnimation(void) | KeyFramedAnimation | [inline, virtual]
Generated on Tue Jan 15 10:29:06 2008 for NVSGSDK by NVIDIA


KeyInput Class Reference

Keyboard input helper class to store keyboard press and release events. More...

#include <KeyInput.h>

List of all members.

Public Member Functions

NVSG_API | KeyInput (void)
Default constructor.

virtual NVSG_API | ~KeyInput (void)
Default destructor.

UINT | getKeyState (void) const
Determine the current keyboard state.

void | resetKeyState (void)
Reset the current keyboard state.

NVSG_API void | keyDown (UINT key)
Handle key press events.

NVSG_API void | keyUp (UINT key)
Handle key release events.

NVSG_API KeyInput & | operator= (const KeyInput &rhs)
Assignment operator.

NVSG_API bool | operator== (const KeyInput &rhs) const
Equality operator.

NVSG_API bool | operator!= (const KeyInput &rhs) const
Inequality operator.

Protected Attributes

UINT | m_keyState
Current key state mask containing the concatenation of key codes.

Detailed Description

Keyboard input helper class to store keyboard press and release events.

Namespace: nvui
Remarks:
This class can be used to help managing simple keyboard press and release events. It a simple container that can be used inside of a Manipulator class, for example, that uses keyboard events to control its functionality.
Whenever a key is pressed, the Manipulator stores the code for this key in this container and removes the code when the key is released. So the key state represents the concatenation of the key codes of the currently pressed keys on the keyboard.
A simple enum defines the key codes, so it makes sense to choose the codes to allow combinations of different keys at the same time.
  enum
  { _NO_KEY       = 0x0000
  , _CONTROL_KEY  = 0x0001
  , _W_KEY        = 0x0002
  , _S_KEY        = 0x0004
  };

Refer to the ManipSampleViewer tutorial on how to use this class.

Constructor & Destructor Documentation

NVSG_API KeyInput ( void )

Default constructor.

Remarks:
The constructor simply resets the key state.
See also:
resetKeyState

virtual NVSG_API ~KeyInput ( void ) [virtual]

Default destructor.

Member Function Documentation

UINT getKeyState ( void ) const [inline]

Determine the current keyboard state.

Returns:
The concatenation of the current key codes.
Remarks:
This function can be used to get information on the currently pressed keys.
Example
Extract the key codes:
  UINT WALK_FORWARD = _CONTROL_KEY | _W_KEY;
  [...]
  switch (m_keyInput.getKeyState())
  {
    case WALK_FORWARD:
      [...]
      break;
    [...]
  }
See also:
keyDown, keyUp

void resetKeyState ( void ) [inline]

Reset the current keyboard state.

Remarks:
This function resets all the information on currently pressed keys.

NVSG_API void keyDown ( UINT key )

Handle key press events.

Parameters:
key The key code of the pressed key.
Remarks:
The application or manipulator can use this function to inform the KeyInput object about pressed keys by providing the key code of the newly pressed key.
The key code is defined by the application or Manipulator. See the description of KeyInput for key codes.
See also:
keyUp, getKeyState, KeyInput

NVSG_API void keyUp ( UINT key )

Handle key release events.

Parameters:
key The key value of the released key.
Remarks:
The application or manipulator can use this function to inform the KeyInput object about released keys by providing the key code of the newly released key.
The key code is defined by the application or Manipulator. See the description of KeyInput for key codes.
See also:
keyDown, getKeyState, KeyInput

NVSG_API KeyInput& operator= ( const KeyInput & rhs )

Assignment operator.

Parameters:
rhs Reference to an KeyInput object.
Returns:
Reference to an KeyInput object.
Remarks:
Use the assignment operator to easily assign one KeyInput object to another one.

NVSG_API bool operator== ( const KeyInput & rhs ) const

Equality operator.

Parameters:
rhs Reference to an KeyInput object - object to compare with.
Returns:
When the data of both objects are equal, the return value is true.
Remarks:
Compare the two objects for equality. Internally only, the key state mask containing the concatenated key codes is compared.
See also:
operator!=()

NVSG_API bool operator!= ( const KeyInput & rhs ) const

Inequality operator.

Parameters:
rhs Reference to an KeyInput object - object to compare with.
Returns:
When the data of both objects are not equal, the return value is true.
Remarks:
Compare the two objects on inequality. Internally only, the key state mask containing the concatenated key codes is compared.

Member Data Documentation

UINT m_keyState [protected]

Current key state mask containing the concatenation of key codes.

The documentation for this class was generated from the following file:
  • KeyInput.h
Generated on Tue Jan 15 10:29:41 2008 for NVSGSDK by NVIDIA


Member List

KeyInput Member List

This is the complete list of members for KeyInput, including all inherited members.
getKeyState(void) const | KeyInput | [inline]
keyDown(UINT key) | KeyInput |
KeyInput(void) | KeyInput |
keyUp(UINT key) | KeyInput |
m_keyState | KeyInput | [protected]
operator!=(const KeyInput &rhs) const | KeyInput |
operator=(const KeyInput &rhs) | KeyInput |
operator==(const KeyInput &rhs) const | KeyInput |
resetKeyState(void) | KeyInput | [inline]
~KeyInput(void) | KeyInput | [virtual]
Generated on Tue Jan 15 10:29:41 2008 for NVSGSDK by NVIDIA


keyVariant_t Struct Reference

The keyVariant_t structure specifies how a pair of a VariantKey and a StateVariant is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t key
Specifies the key of this pair.

uint_t variant
Specifies the offset to an NBFStateVariant in the .NBF file.

Detailed Description

The keyVariant_t structure specifies how a pair of a VariantKey and a StateVariant is stored in a .NBF file.

Member Data Documentation

uint_t key

Specifies the key of this pair.

uint_t variant

Specifies the offset to an NBFStateVariant in the .NBF file.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

keyVariant_t Member List

This is the complete list of members for keyVariant_t, including all inherited members.
key | keyVariant_t
variant | keyVariant_t
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Lanczos3Filter Class Reference

ScaleFilter functor providing lanczos3 filter functionality. More...

#include <TextureImage.h>

Inheritance diagram for Lanczos3Filter:

[legend]
Collaboration diagram for Lanczos3Filter:

[legend]
List of all members.

Public Member Functions

NVSG_API float | getSupportWidth (void) const
Get the support width of the Lanczos3Filter.

NVSG_API float | operator() (float t) const
Weight calculation operator.

Detailed Description

ScaleFilter functor providing lanczos3 filter functionality.

A Lanczos3Filter has a support width of 3.0. For distances t between source and destination texel in the half open interval [0.0,3.0), the weight is ( sinc(x) * sinc(x/3.0) ), with x = t * PI, otherwise 0.0.

Member Function Documentation

float getSupportWidth ( void ) const [inline, virtual]

Get the support width of the Lanczos3Filter.

Returns:
the support width of the Lanczos3Filter is 3.0.

Implements ScaleFilter.

float operator() ( float t ) const [inline, virtual]

Weight calculation operator.

Returns:
( sinc(x) * sinc(x/3.0) ), with x=t * PI, if t is in the interval [0.0,3.0), otherwise 0.0.

Implements ScaleFilter.

The documentation for this class was generated from the following file:
  • TextureImage.h
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Member List

Lanczos3Filter Member List

This is the complete list of members for Lanczos3Filter, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
getSupportWidth(void) const | Lanczos3Filter | [inline, virtual]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator()(float t) const | Lanczos3Filter | [inline, virtual]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


LightingAttribute Class Reference

StateAttribute indicating whether lighting should be disabled. More...

#include <LightingAttribute.h>

Inheritance diagram for LightingAttribute:

[legend]
Collaboration diagram for LightingAttribute:

[legend]
List of all members.

Public Member Functions

NVSG_API | LightingAttribute ()
Default-constructs a LightingAttribute.

NVSG_API | LightingAttribute (const StateAttribute &rhs)
Constructs a LightingAttribute from a StateAttribute.

NVSG_API | LightingAttribute (const LightingAttribute &rhs)
Constructs a LightingAttribute as a copy from another LightingAttribute.

virtual NVSG_API | ~LightingAttribute ()
Destructs a LightingAttribute.

NVSG_API void | setEnabled (bool state)
Set the enabled state.

NVSG_API bool | getEnabled () const
Get the enabled state.

virtual NVSG_API bool | isTransparent () const
Query the transparency status of this LightingAttribute.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another LightingAttribute.

NVSG_API LightingAttribute & | operator= (const LightingAttribute &rhs)
Assignment operator.

Detailed Description

StateAttribute indicating whether lighting should be disabled.

Namespace: nvsg
Remarks:
NVSG's default mode is to render all geometry with lighting enabled. This state attribute provides a means to force lighting off for a set of geometry. Since the default mode is to render with lighting enabled, it is NOT NECESSARY to add this state attribute to all StateSets with geometry that should be affected by lighting. Therefore, adding this state attribute and setting the value to "enabled" is essentially a NO-OP.
See also:
StateAttribute,

Constructor & Destructor Documentation

NVSG_API LightingAttribute ( )

Default-constructs a LightingAttribute.

Remarks:
A default-constructed LightingAttribute is initialized with its state set to DISABLED

NVSG_API LightingAttribute ( const StateAttribute & rhs ) [explicit]

Constructs a LightingAttribute from a StateAttribute.

Parameters:
rhs StateAttribute to construct the LightingAttribute from.
Remarks:
A LightingAttribute constructed from a StateAttribute is initialized to a DISABLED state.

NVSG_API LightingAttribute ( const LightingAttribute & rhs )

Constructs a LightingAttribute as a copy from another LightingAttribute.

Parameters:
rhs Source LightingAttribute.

virtual NVSG_API ~LightingAttribute ( ) [virtual]

Destructs a LightingAttribute.

Member Function Documentation

NVSG_API void setEnabled ( bool state )

Set the enabled state.

Parameters:
state the enabled or disabled state of the attribute.
See also:
getEnabled

bool getEnabled ( ) const [inline]

Get the enabled state.

Returns:
bool indicating the current state
See also:
setEnabled

virtual NVSG_API bool isTransparent ( ) const [virtual]

Query the transparency status of this LightingAttribute.

Returns:
false, the LightingAttribute always returns false.
Remarks:
An LightingAttribute always returns false so that it is not sorted with the rest of the scene, as this is not necessary for AlphaFunc.
See also:
StateAttribute::isTransparent

Reimplemented from StateAttribute.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another LightingAttribute.

Parameters:
p | Pointer to the constant LightingAttribute to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true
deepCompare | Optional parameter to perform a deep comparsion; default is false
Returns:
true if the LightingAttribute p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as StateAttribute, they are considered to be equivalent if they have the same state value.
Note:
The behaviour is undefined if p is not a LightingAttribute nor derived from one.
See also:
StateAttribute, getAlphaFunction

Reimplemented from Object.

NVSG_API LightingAttribute& operator= ( const LightingAttribute & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant LightingAttribute to copy from
Returns:
A reference to the assigned LightingAttribute
Remarks:
The assignment operator calls the assignment operator of StateAttribute and copies the LightingAttribute specific data then.
See also:
PrimitiveAttribute

The documentation for this class was generated from the following file:
  • LightingAttribute.h
Generated on Tue Jan 15 10:29:06 2008 for NVSGSDK by NVIDIA


Member List

LightingAttribute Member List

This is the complete list of members for LightingAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getEnabled() const | LightingAttribute | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LightingAttribute | [virtual]
isTransparent() const | LightingAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
LightingAttribute() | LightingAttribute |
LightingAttribute(const StateAttribute &rhs) | LightingAttribute | [explicit]
LightingAttribute(const LightingAttribute &rhs) | LightingAttribute |
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const LightingAttribute &rhs) | LightingAttribute |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setEnabled(bool state) | LightingAttribute |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~LightingAttribute() | LightingAttribute | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:06 2008 for NVSGSDK by NVIDIA


LightsElement Class Reference

Helper class to hold the vector of lights that are active while traversing the tree. More...

#include <LightsElement.h>

Inheritance diagram for LightsElement:

[legend]
Collaboration diagram for LightsElement:

[legend]
List of all members.

Public Member Functions

NVSG_API | LightsElement ()
Default constructor.

NVSG_API | LightsElement (nvsg::GroupHandle *group, const LightsElement &rhs)
Constructor of a LightsElement.

NVSG_API | ~LightsElement ()
Destructor of a LightsElement.

NVSG_API void | addLight (nvsg::LightSourceHandle *lsh, const nvmath::Mat44f &modelToWorld, const nvmath::Mat44f &worldToModel)
Add a light to this LightsElement.

NVSG_API nvsg::GroupHandle * | getGroup () const
Get the Group associated with this LightsElement.

NVSG_API nvsg::LightSourceHandle * | getLight (unsigned int i) const
Get the light source with index i.

NVSG_API const nvmath::Mat44f & | getModelToWorld (unsigned int i) const
Get the model-to-world transformation with index i.

NVSG_API unsigned int | getNumberOfLights () const
Get the number of lights in this LightsElement.

NVSG_API const nvmath::Mat44f & | getWorldToModel (unsigned int i) const
Get the world-to-model transformation with index i.

Detailed Description

Helper class to hold the vector of lights that are active while traversing the tree.

Remarks:
This class holds the vector of lights that are active while traversing the tree, the corresponding modelToWorld and worldToModel transformations, and the GroupHandle that activated the latest light(s) in this LightsElement.
See also:
BaseRenderElement

Constructor & Destructor Documentation

LightsElement ( ) [inline]

Default constructor.

Remarks:
The default constructor sets the owning group to NULL. The vector of lights and the vectors transformation matrices are empty

LightsElement | ( | nvsg::GroupHandle * | group,
 |  | const LightsElement & | rhs
 | ) | [inline]

Constructor of a LightsElement.

Parameters:
group | The handle of the Group that is going to add one or more light sources.
rhs | A reference to the constant current LightsElement valid up to now.
Remarks:
The constructor increments the reference counter of the Group group and all light sources in rhs. All light sources and the corresponding modelToWorld and worldToModel matrices are copied over to this new LightsElement.

~LightsElement ( ) [inline]

Destructor of a LightsElement.

Remarks:
If there is a non-zero Group registered for this LightsElement, it's reference is removed. For each LightSource in this LightsElement, their reference is removed.

Member Function Documentation

void addLight | ( | nvsg::LightSourceHandle * | lsh,
 |  | const nvmath::Mat44f & | modelToWorld,
 |  | const nvmath::Mat44f & | worldToModel
 | ) | [inline]

Add a light to this LightsElement.

Parameters:
lsh | A pointer to the LightsSourceHandle to add.
modelToWorld | A constant reference to the corresponding model to world transformation.
worldToModel | A constant reference to the corresponding world to model transformation.
Remarks:
This function stores the LightsSourceHandle lsh and the corresponding transformations matrices, and increases the reference count of lsh.
See also:
getNumberOfLights, getLight, getModelToWorld, getWorldToModel

nvsg::GroupHandle * getGroup ( ) const [inline]

Get the Group associated with this LightsElement.

Returns:
A pointer to the GroupHandle that did add the last one or more light sources to this LightsElement.
Remarks:
On traversal, this information is used to determine if the top element of the stack of LightsElement has to be popped.

nvsg::LightSourceHandle * getLight ( unsigned int i ) const [inline]

Get the light source with index i.

Parameters:
i Index of the light source to get.
Returns:
A pointer to the LightSourceHandle that was stored as the i-th light source.
Note:
The behavior is undefined if i is greater or equal to the number of stored light sources.
See also:
getNumberOfLights, getModelToWorld, getWorldToModel, addLight

const nvmath::Mat44f & getModelToWorld ( unsigned int i ) const [inline]

Get the model-to-world transformation with index i.

Parameters:
i Index of the model-to-world transformation to get.
Returns:
A constant reference to the model-to-world transformation at index i.
Note:
The behavior is undefined if i is greater or equal to the number of stored light sources.
See also:
getNumberOfLights, getLight, getWorldToModel, addLight

unsigned int getNumberOfLights ( ) const [inline]

Get the number of lights in this LightsElement.

Returns:
The number of LightSourceHandles, with corresponding transformations, stored.
See also:
addLight, getLight, getModelToWorld, getWorldToModel

const nvmath::Mat44f & getWorldToModel ( unsigned int i ) const [inline]

Get the world-to-model transformation with index i.

Parameters:
i Index of the world-to-model transformation to get.
Returns:
A constant reference to the world-to-model transformation at index i.
Note:
The behavior is undefined if i is greater or equal to the number of stored light sources.
See also:
getNumberOfLights, getLight, getModelToWorld, addLight

The documentation for this class was generated from the following file:
  • LightsElement.h
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


Member List

LightsElement Member List

This is the complete list of members for LightsElement, including all inherited members.
addLight(nvsg::LightSourceHandle *lsh, const nvmath::Mat44f &modelToWorld, const nvmath::Mat44f &worldToModel) | LightsElement | [inline]
addRef() | BaseRenderElement | [inline]
BaseRenderElement() | BaseRenderElement | [inline, protected]
BaseRenderElement(const BaseRenderElement &rhs) | BaseRenderElement | [inline, protected]
getGroup() const | LightsElement | [inline]
getLight(unsigned int i) const | LightsElement | [inline]
getModelToWorld(unsigned int i) const | LightsElement | [inline]
getNumberOfLights() const | LightsElement | [inline]
getRefCnt() const | BaseRenderElement | [inline]
getWorldToModel(unsigned int i) const | LightsElement | [inline]
LightsElement() | LightsElement | [inline]
LightsElement(nvsg::GroupHandle *group, const LightsElement &rhs) | LightsElement | [inline]
removeRef() | BaseRenderElement | [inline]
~BaseRenderElement() | BaseRenderElement | [inline, protected, virtual]
~LightsElement() | LightsElement | [inline]
Generated on Tue Jan 15 10:29:31 2008 for NVSGSDK by NVIDIA


LightSource Class Reference

Abstract base class for all light sources. More...

#include <LightSource.h>

Inheritance diagram for LightSource:

[legend]
Collaboration diagram for LightSource:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~LightSource ()
Destructs a LightSource. If the LightSource holds an Animation, its reference count is decremented.

NVSG_API const nvmath::Vec3f & | getAmbientColor () const
Get the ambient color of this LightSource.

NVSG_API void | setAmbientColor (const nvmath::Vec3f &color)
Set the ambient color of this LightSource.

NVSG_API const nvmath::Vec3f & | getDiffuseColor () const
Get the diffuse color of this LightSource.

NVSG_API void | setDiffuseColor (const nvmath::Vec3f &color)
Set the diffuse color of this LightSource.

NVSG_API const nvmath::Vec3f & | getSpecularColor () const
Get the specular color of this LightSource.

NVSG_API void | setSpecularColor (const nvmath::Vec3f &color)
Set the specular color of this LightSource.

NVSG_API float | getIntensity () const
Get the intensity of this LightSource.

NVSG_API void | setIntensity (float intensity)
Set the intensity of this LightSource.

NVSG_API bool | isEnabled () const
Query if this LightSource is enabled.

NVSG_API bool | isShadowCasting () const
Query if this LightSource casts shadows.

NVSG_API void | setEnabled (bool enable)
Set the enabled state of this LightSource.

NVSG_API void | setShadowCasting (bool cast)
Set the shadow casting state of this LightSource.

NVSG_API TrafoAnimationHandle * | getAnimation () const
Get the Animation of this LightSource.

NVSG_API void | setAnimation (TrafoAnimationHandle *animation)
Set the Animation of this LightSource.

NVSG_API nvmath::Mat44f | getTransformationMatrix () const
Get the current transformation.

NVSG_API nvmath::Mat44f | getInverse () const
Get the inverse of the transformation.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another LightSource.

virtual NVSG_API bool | validateIncarnation () const
Validate the nvutil::Incarnation.

NVSG_API void | invalidateAnimationContainment ()
Invalidate the Animation containment of every owner of this LightSource.

Protected Member Functions

NVSG_API | LightSource ()
Protected default constructor to prevent explicit creation.

NVSG_API | LightSource (const LightSource &rhs)
Protected copy constructor to prevent explicit creation.

NVSG_API LightSource & | operator= (const LightSource &rhs)
Assignment operator.

Protected Attributes

nvmath::Trafo m_trafo
Trafo used by every kind of light source.

Detailed Description

Abstract base class for all light sources.

Namespace: nvsg
Remarks:
A LightSource contains data and functionality common to all light sources (DirectedLight, SpotLight, ...).
Note:
A LightSource has no method to turn light sources on or off. This functionality is located in the Group holding the LightSource objects.

LightSource objects only influence objects beneath the Group the LightSource is part of.

See also:
DirectedLight, PointLight, SpotLight, Switch

Constructor & Destructor Documentation

virtual NVSG_API ~LightSource ( ) [virtual]

Destructs a LightSource. If the LightSource holds an Animation, its reference count is decremented.

See also:
addRef, removeRef

NVSG_API LightSource ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
The default values of the newly created LightSource are as follows:
  • ambient color is black (0.0,0.0,0.0)
  • animation is none (NULL)
  • diffuse color is white (1.0,1.0,1.0)
  • intensity is one (1.0)
  • shadow casting is on
  • specular color is white (1.0,1.0,1.0)
  • transform is the identity
Note:
A LightSource will not be instantiated directly, but by instantiating a derived object like DirectedLight or PointLight, for example.

NVSG_API LightSource ( const LightSource & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant LightSource to copy from.
Remarks:
The newly created LightSource is copied from rhs.
Note:
A LightSource will not be instantiated directly, but by instantiating a derived object like Quads or Triangles for example.

Member Function Documentation

const nvmath::Vec3f & getAmbientColor ( ) const [inline]

Get the ambient color of this LightSource.

Returns:
A reference to the constant ambient color.
Remarks:
The ambient color of a LightSource simply contributes to the global ambient term. It is not dependent on any other lighting factors such as vertex normals, light direction, light position, range, or attenuation. The default is black (0.0,0.0,0.0).
See also:
getDiffuseColor, getSpecularColor, setAmbientColor

void setAmbientColor ( const nvmath::Vec3f & color ) [inline]

Set the ambient color of this LightSource.

Parameters:
color A reference to the constant ambient color to set.
Remarks:
The ambient color of a LightSource simply contributes to the global ambient term. It is not dependent on any other lighting factors such as vertex normals, light direction, light position, range, or attenuation. The default is black (0.0,0.0,0.0).
See also:
getAmbientColor, setDiffuseColor, setSpecularColor

const nvmath::Vec3f & getDiffuseColor ( ) const [inline]

Get the diffuse color of this LightSource.

Returns:
A reference to the constant diffuse color.
Remarks:
The diffuse color of a light is used to calculate lighting contributions that might depend on vertex normals, light direction, light position, range, or attenuation, depending on the type of light source. The default is white (1.0,1.0,1.0).
See also:
getAmbientColor, getSpecularColor, setDiffuseColor

void setDiffuseColor ( const nvmath::Vec3f & color ) [inline]

Set the diffuse color of this LightSource.

Parameters:
color A reference to the constant diffuse color to set.
Remarks:
The diffuse color of a light is used to calculate lighting contributions that might depend on vertex normals, light direction, light position, range, or attenuation, depending on the type of light source. The default is white (1.0,1.0,1.0).
See also:
getDiffuseColor, setAmbientColor, setSpecularColor

const nvmath::Vec3f & getSpecularColor ( ) const [inline]

Get the specular color of this LightSource.

Returns:
A reference to the constant specular color.
Remarks:
The specular color of a light is used to calculate any lighting contributions from vertex normals, vertex position, light direction, light position, range, or attenuation, depending on the type of light source. The default is white (1.0,1.0,1.0).
See also:
getAmbientColor, getDiffuseColor, setSpecularColor,

void setSpecularColor ( const nvmath::Vec3f & color ) [inline]

Set the specular color of this LightSource.

Parameters:
color A reference to the constant specular color to set.
Remarks:
The specular color of a light is used to calculate any lighting contributions from vertex normals, vertex position, light direction, light position, range, or attenuation, depending on the type of light source. The default is white (1.0,1.0,1.0).
See also:
getSpecularColor, setAmbientColor, setDiffuseColor

float getIntensity ( ) const [inline]

Get the intensity of this LightSource.

Returns:
The intensity.
Remarks:
The intensity of a LightSource is a multiplier for all three color types of this LightSource.
See also:
getAmbientColor, getDiffuseColor, getSpecularColor, setIntensity

void setIntensity ( float intensity ) [inline]

Set the intensity of this LightSource.

Parameters:
intensity The intensity to set.
Remarks:
The intensity of a LightSource is a multiplier for all three color types of this LightSource.
See also:
getIntensity, setAmbientColor, setDiffuseColor, setSpecularColor

bool isEnabled ( ) const [inline]

Query if this LightSource is enabled.

Returns:
true, if this LightSource is enabled, otherwise false.
See also:
setEnabled

bool isShadowCasting ( ) const [inline]

Query if this LightSource casts shadows.

Returns:
true, if this LightSource casts shadows, otherwise false.
Remarks:
A LightSource might be excluded from the shadow casters by this flag. The default value is true.
See also:
setShadowCasting

void setEnabled ( bool enable ) [inline]

Set the enabled state of this LightSource.

Parameters:
enable true, to switch the LightSource on, false to switch it off.
See also:
isEnabled

void setShadowCasting ( bool cast ) [inline]

Set the shadow casting state of this LightSource.

Parameters:
cast true, to switch shadow casting on, false to switch it off.
Remarks:
A LightSource might be excluded from the shadow casters by this flag. The default value is true.
See also:
isShadowCasting

TrafoAnimationHandle * getAnimation ( ) const [inline]

Get the Animation of this LightSource.

Returns:
A pointer to the constant Animation of type Trafo, or NULL if there is no Animation in this LightSource.
Remarks:
The position and orientation of a LightSource can be animated by an Animation of Trafo.
See also:
Animation, nvmath::Trafo, setAnimation

NVSG_API void setAnimation ( TrafoAnimationHandle * animation )

Set the Animation of this LightSource.

Parameters:
animation A pointer to the constant Animation to use.
Remarks:
The position and orientation of a LightSource can be animated by an Animation of Trafo.
See also:
Animation, nvmath::Trafo, getAnimation

nvmath::Mat44f getTransformationMatrix ( ) const [inline]

Get the current transformation.

Returns:
The transformation that determines position and orientation of this LightSource.
See also:
getInverse

nvmath::Mat44f getInverse ( ) const [inline]

Get the inverse of the transformation.

Returns:
The inverse of the transformation that determines position and orientation of this LightSource.
See also:
getTransformationMatrix

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another LightSource.

Parameters:
p | A pointer to the LightSource to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the LightSource p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Node, their Animation objects are tested for equivalence. If deepCompare is true, and there is an Animation object in both this and p, a full equivalence test on them is performed, otherwise they are considered to be equivalent if they are the same pointers. All the other LightSource data are tested for equality.
Note:
The behavior is undefined if p is not a LightSource nor derived from one.
See also:
DirectedLight, Node, PointLight, SpotLight

Reimplemented from Object.

Reimplemented in PointLight, and SpotLight.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this LightSource is requested but marked as invalid. Then its validated and the nvutil::Incarnation of an attached Animation object is requested to continue the validation down the tree hierarchy.
See also:
Animation, Node, nvutil::Incarnation, invalidateIncarnation

Reimplemented from Object.

NVSG_API void invalidateAnimationContainment ( )

Invalidate the Animation containment of every owner of this LightSource.

NVSG_API LightSource& operator= ( const LightSource & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant LightSource to copy from.
Returns:
A reference to the assigned LightSource.
Remarks:
The assignment operator calls the assignment operator of Node. The reference count of any currently attached Animation is decremented, all data specific to a LightSource is copied, and any Animation attached to rhs is cloned.

Member Data Documentation

nvmath::Trafo m_trafo [protected]

Trafo used by every kind of light source.

The documentation for this class was generated from the following file:
  • LightSource.h
Generated on Tue Jan 15 10:29:07 2008 for NVSGSDK by NVIDIA


Member List

LightSource Member List

This is the complete list of members for LightSource, including all inherited members.
addOwner(typename GroupHandle::ObjectType *obj) | OwnedObject< GroupHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< GroupHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAmbientColor() const | LightSource | [inline]
getAnimation() const | LightSource | [inline]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getDiffuseColor() const | LightSource | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIntensity() const | LightSource | [inline]
getInverse() const | LightSource | [inline]
getName() const | Object |
getNumberOfOwners() const | OwnedObject< GroupHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< GroupHandle > |
getSpecularColor() const | LightSource | [inline]
getTransformationMatrix() const | LightSource | [inline]
getUserData() const | Object | [inline]
invalidateAnimationContainment() | LightSource |
invalidateIncarnation() | OwnedObject< GroupHandle > | [virtual]
isDataShared() const | Object | [virtual]
isEnabled() const | LightSource | [inline]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LightSource | [virtual]
isShadowCasting() const | LightSource | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
LightSource() | LightSource | [protected]
LightSource(const LightSource &rhs) | LightSource | [protected]
m_objectCode | Object | [protected]
m_trafo | LightSource | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const LightSource &rhs) | LightSource | [protected]
nvsg::OwnedObject< GroupHandle >::operator=(const OwnedObject< GroupHandle > &rhs) | OwnedObject< GroupHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< GroupHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< GroupHandle > | [protected]
OwnedObject(const OwnedObject< GroupHandle > &rhs) | OwnedObject< GroupHandle > | [protected]
OwnerIterator typedef | OwnedObject< GroupHandle > | [protected]
ownersBegin() const | OwnedObject< GroupHandle > | [inline, protected]
ownersBegin() | OwnedObject< GroupHandle > | [inline, protected]
ownersEnd() const | OwnedObject< GroupHandle > | [inline, protected]
ownersEnd() | OwnedObject< GroupHandle > | [inline, protected]
removeOwner(typename GroupHandle::ObjectType *obj) | OwnedObject< GroupHandle > | [protected]
setAmbientColor(const nvmath::Vec3f &color) | LightSource | [inline]
setAnimation(TrafoAnimationHandle *animation) | LightSource |
setAnnotation(const std::string &anno) | Object |
setDiffuseColor(const nvmath::Vec3f &color) | LightSource | [inline]
setEnabled(bool enable) | LightSource | [inline]
setIntensity(float intensity) | LightSource | [inline]
setName(const std::string &name) | Object |
setShadowCasting(bool cast) | LightSource | [inline]
setSpecularColor(const nvmath::Vec3f &color) | LightSource | [inline]
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | LightSource | [virtual]
~LightSource() | LightSource | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< GroupHandle > | [protected]
Generated on Tue Jan 15 10:29:07 2008 for NVSGSDK by NVIDIA


TemplateLinearInterpolatedAnimation class Reference

LinearInterpolatedAnimation Class Template Reference

An KeyFramedAnimation class that performs linear interpolation. More...

#include <LinearInterpolatedAnimation.h>

Inheritance diagram for LinearInterpolatedAnimation:

[legend]
Collaboration diagram for LinearInterpolatedAnimation:

[legend]
List of all members.

Public Member Functions

LinearInterpolatedAnimation ()
Default-constructs a LinearInterpolatedAnimation<T>.

LinearInterpolatedAnimation (const KeyFramedAnimation< T > &rhs)
Constructs a LinearInterpolatedAnimation<T> from a KeyFramedAnimation<T>.

LinearInterpolatedAnimation (const LinearInterpolatedAnimation &rhs)
Copy-constructs a LinearInterpolatedAnimation<T>.

virtual | ~LinearInterpolatedAnimation ()
Destructs a LinearInterpolatedAnimation<T>.

virtual const T & | getCurrentValue () const
Get the current value of this Animation.

virtual T | getStepValue (unsigned int step) const
Get the potentially interpolated value at the specified step.

LinearInterpolatedAnimation<
T > & 		operator= (const LinearInterpolatedAnimation< T > &rhs)
Assignment operator.

Protected Member Functions

virtual void | setCurrentStep (unsigned int step)
Set the specified step as the current one.

Detailed Description

template<typename T>
class nvsg::LinearInterpolatedAnimation< T >

An KeyFramedAnimation class that performs linear interpolation.

Namespace: nvsg
Remarks:
The LinearInterpolatedAnimation of type T essentially is an KeyFramedAnimation with the constant random access operator being overloaded.
Note:
Currently the only supported types for LinearInterpolatedAnimation are nvmath::Trafo and VertexAttribute
See also:
KeyFramedAnimation, nvmath::Trafo, VertexAttribute

Constructor & Destructor Documentation

LinearInterpolatedAnimation ( ) [inline]

Default-constructs a LinearInterpolatedAnimation<T>.

LinearInterpolatedAnimation ( const KeyFramedAnimation< T > & rhs ) [inline, explicit]

Constructs a LinearInterpolatedAnimation<T> from a KeyFramedAnimation<T>.

Parameters:
rhs Source KeyFramedAnimation<T>.

LinearInterpolatedAnimation ( const LinearInterpolatedAnimation< T > & rhs ) [inline]

Copy-constructs a LinearInterpolatedAnimation<T>.

Parameters:
rhs Source LinearInterpolatedAnimation<T>.

~LinearInterpolatedAnimation ( ) [inline, virtual]

Destructs a LinearInterpolatedAnimation<T>.

Member Function Documentation

const T & getCurrentValue ( ) const [inline, virtual]

Get the current value of this Animation.

Returns:
The current value of this Animation.
Remarks:
The current value is used in the current animation step.
See also:
getCurrentStep

Reimplemented from KeyFramedAnimation.

T getStepValue ( unsigned int step ) const [inline, virtual]

Get the potentially interpolated value at the specified step.

Parameters:
step Index of the Animation to get the value at.
Returns:
The value at the specified step.
Remarks:
If step is defined by a key frame of this LinearInterpolatedAnimation, its value is returned. Otherwise, the linear interpolation between the two neighboring key frames is calculated and returned.

Reimplemented from KeyFramedAnimation.

LinearInterpolatedAnimation< T > & operator= ( const LinearInterpolatedAnimation< T > & rhs ) [inline]

Assignment operator.

Parameters:
rhs A reference to the constant LinearInterpolatedAnimation of type T to copy from.
Returns:
A reference to the assigned LinearInterpolatedAnimation of type T.
Remarks:
The assignment operator just calls the assignment operator of the KeyFramedAnimation of type T.

void setCurrentStep ( unsigned int step ) [inline, protected, virtual]

Set the specified step as the current one.

Parameters:
step The step index to set as the current one.
Remarks:
The current value is calculated and the base class implementation is called.

The documentation for this class was generated from the following file:
  • LinearInterpolatedAnimation.h
Generated on Tue Jan 15 10:29:07 2008 for NVSGSDK by NVIDIA


Member List

LinearInterpolatedAnimation Member List

This is the complete list of members for LinearInterpolatedAnimation, including all inherited members.
addKey(unsigned int step, const T &value) | KeyFramedAnimation | [inline]
addKeys(unsigned int numberOfKeys, const unsigned int *steps, const T *values) | KeyFramedAnimation | [inline]
Animation(void) | Animation | [inline, protected]
getCurrentValue() const | LinearInterpolatedAnimation | [inline, virtual]
getFrameValue(unsigned int frame) const | Animation | [inline]
getKey(unsigned int frame) const | KeyFramedAnimation | [inline, protected]
getKeyStep(unsigned int key) const | KeyFramedAnimation | [inline]
getKeySteps() const | KeyFramedAnimation | [inline]
getKeyValue(unsigned int key) const | KeyFramedAnimation | [inline]
getKeyValues() const | KeyFramedAnimation | [inline]
getNumberOfKeys(void) const | KeyFramedAnimation | [inline]
getStepValue(unsigned int step) const | LinearInterpolatedAnimation | [inline, virtual]
insertKey(unsigned int key, unsigned int step, const T &value) | KeyFramedAnimation | [inline]
isCompatible(const Animation< T > *p) const | KeyFramedAnimation | [inline, virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | KeyFramedAnimation | [inline, virtual]
KeyFramedAnimation(void) | KeyFramedAnimation | [inline, protected]
KeyFramedAnimation(const KeyFramedAnimation &rhs) | KeyFramedAnimation | [inline, protected]
LinearInterpolatedAnimation() | LinearInterpolatedAnimation | [inline]
LinearInterpolatedAnimation(const KeyFramedAnimation< T > &rhs) | LinearInterpolatedAnimation | [inline, explicit]
LinearInterpolatedAnimation(const LinearInterpolatedAnimation &rhs) | LinearInterpolatedAnimation | [inline]
operator=(const LinearInterpolatedAnimation< T > &rhs) | LinearInterpolatedAnimation | [inline]
nvsg::KeyFramedAnimation::operator=(const KeyFramedAnimation< T > &rhs) | KeyFramedAnimation | [protected]
nvsg::Animation::operator=(const Animation< T > &rhs) | Animation | [inline, protected]
removeKey(unsigned int key) | KeyFramedAnimation | [inline]
removeKeys(unsigned int key, unsigned int numberOfKeys) | KeyFramedAnimation | [inline]
removeStep(unsigned int step) | KeyFramedAnimation | [inline, virtual]
replaceKey(unsigned int key, unsigned int step, const T &value) | KeyFramedAnimation | [inline]
replaceKeys(unsigned int key, unsigned int numberOfKeys, const unsigned int *steps, const T *values) | KeyFramedAnimation | [inline]
replaceStep(unsigned int step, const T &value) | KeyFramedAnimation | [inline, virtual]
reserveKeys(unsigned int numberOfKeys) | KeyFramedAnimation | [inline]
setCurrentStep(unsigned int step) | LinearInterpolatedAnimation | [inline, protected, virtual]
~Animation() | Animation | [inline, virtual]
~KeyFramedAnimation(void) | KeyFramedAnimation | [inline, virtual]
~LinearInterpolatedAnimation() | LinearInterpolatedAnimation | [inline, virtual]
Generated on Tue Jan 15 10:29:07 2008 for NVSGSDK by NVIDIA


LineAttribute Class Reference

PrimitiveAttribute specific for Drawables with lines, like Lines or LineStrips. More...

#include <LineAttribute.h>

Inheritance diagram for LineAttribute:

[legend]
Collaboration diagram for LineAttribute:

[legend]
List of all members.

Public Member Functions

NVSG_API | LineAttribute ()
Default-constructs a LineAttribute.

NVSG_API | LineAttribute (const PrimitiveAttribute &rhs)
Constructs a LineAttribute from a PrimitiveAttribute.

NVSG_API | LineAttribute (const LineAttribute &rhs)
Constructs a LineAttribute as a copy from another LineAttribute.

virtual NVSG_API | ~LineAttribute ()
Destructs a LineAttribute.

NVSG_API unsigned short | getStipplePattern () const
Get the stipple pattern.

NVSG_API void | setStipplePattern (unsigned short pattern)
Set the stipple pattern.

NVSG_API unsigned short | getStippleFactor () const
Get the stipple factor.

NVSG_API void | setStippleFactor (unsigned short factor)
Set the stipple factor.

NVSG_API float | getWidth () const
Get the line width.

NVSG_API void | setWidth (float width)
Set the line width.

NVSG_API bool | isAntiAliased () const
Get the line anti-aliasing state.

NVSG_API void | setAntiAliasing (bool aa)
Set the line anti-aliasing state.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other LineAttribute.

NVSG_API LineAttribute & | operator= (const LineAttribute &rhs)
Assignment operator.

Detailed Description

PrimitiveAttribute specific for Drawables with lines, like Lines or LineStrips.

Namespace: nvsg
Remarks:
A LineAttribute holds the line-specific attributes of a StatePass.
Note:
Faces and points are not affected by a LineAttribute.
See also:
FaceAttribute, PointAttribute, PrimitiveAttribute, StatePass

Constructor & Destructor Documentation

NVSG_API LineAttribute ( )

Default-constructs a LineAttribute.

Remarks:
A default-constructed LineAttribute initially has anti-aliasing off, has has a stipple factor of 1, a stipple pattern of 0xFFFF, and a line with of 1.0.

NVSG_API LineAttribute ( const PrimitiveAttribute & rhs ) [explicit]

Constructs a LineAttribute from a PrimitiveAttribute.

Parameters:
rhs Source PrimitiveAttribute
Remarks:
The LineAttribute initially has anti-aliasing off, has has a stipple factor of 1, a stipple pattern of 0xFFFF, and a line with of 1.0.

NVSG_API LineAttribute ( const LineAttribute & rhs )

Constructs a LineAttribute as a copy from another LineAttribute.

virtual NVSG_API ~LineAttribute ( ) [virtual]

Destructs a LineAttribute.

Member Function Documentation

unsigned short getStipplePattern ( ) const [inline]

Get the stipple pattern.

Returns:
The 16-bit stipple pattern
Remarks:
The stipple pattern is a 16-bit series of 0s and 1s, and is repeated as necessary to stipple a given line. A 1 indicates that drawing occurs, and a 0 indicates that it does not, on a pixel-by-pixel basis, beginning with the low-order bit of the pattern. The pattern can be stretched out by using the stipple factor. The default stipple pattern is 0xFFFF, resulting in a non-stippled line.
See also:
getStippleFactor, setStipplePattern

void setStipplePattern ( unsigned short pattern ) [inline]

Set the stipple pattern.

Parameters:
pattern The 16-bit stipple pattern to use
Remarks:
The stipple pattern is a 16-bit series of 0s and 1s, and is repeated as necessary to stipple a given line. A 1 indicates that drawing occurs, and a 0 indicates that it does not, on a pixel-by-pixel basis, beginning with the low-order bit of the pattern. The pattern can be stretched out by using the stipple factor. The default stipple pattern is 0xFFFF, resulting in a non-stippled line.
See also:
getStipplePattern, setStippleFactor

unsigned short getStippleFactor ( ) const [inline]

Get the stipple factor.

Returns:
The stipple factor.
Remarks:
The stipple factor can be used to stretch out the stipple pattern. It multiplies each sub-series of consecutive 1s and 0s. Thus, if three consecutive 1s appear in the pattern, they're stretched to six if the stipple factor is 2. The stipple factor is clamped to lie between 1 and 255, with the default being 1.
See also:
getStipplePattern, setStippleFactor

void setStippleFactor ( unsigned short factor ) [inline]

Set the stipple factor.

Parameters:
factor The stipple factor.
Remarks:
The stipple factor can be used to stretch out the stipple pattern. It multiplies each sub-series of consecutive 1s and 0s. Thus, if three consecutive 1s appear in the pattern, they're stretched to six if the stipple factor is 2. The stipple factor is clamped to lie between 1 and 255, with the default being 1.
See also:
getStippleFactor, setStipplePattern

float getWidth ( ) const [inline]

Get the line width.

Returns:
The line width.
Remarks:
The line width is the width for rendered lines in pixels. It is greater than 0.0 and defaults to 1.0.
See also:
setWidth

void setWidth ( float width ) [inline]

Set the line width.

Parameters:
width The line width to set.
Remarks:
The line width is the width for rendered lines in pixels. It has to be greater than 0.0 and defaults to 1.0.
See also:
getWidth

bool isAntiAliased ( ) const [inline]

Get the line anti-aliasing state.

Returns:
true, if anti-aliasing for lines is on, otherwise false.
See also:
setAntiAliasing

void setAntiAliasing ( bool aa ) [inline]

Set the line anti-aliasing state.

Parameters:
aa true, if line anti-aliasing is to switch on, otherwise false.
See also:
isAntiAliased

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other LineAttribute.

Parameters:
p | A reference to the constant LineAttribute to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the LineAttribute p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as PrimitiveAttribute, they are equivalent if they have the same anti-aliasing state, stipple factor, stipple pattern, and width.
See also:
PrimitiveAttribute

Reimplemented from Object.

NVSG_API LineAttribute& operator= ( const LineAttribute & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant LineAttribute to copy from
Returns:
A reference to the assigned LineAttribute
Remarks:
The assignment operator calls the assignment operator of PrimitiveAttribute and copies the LineAttribute specific data then.
See also:
PrimitiveAttribute

The documentation for this class was generated from the following file:
  • LineAttribute.h
Generated on Tue Jan 15 10:29:07 2008 for NVSGSDK by NVIDIA


Member List

LineAttribute Member List

This is the complete list of members for LineAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getStippleFactor() const | LineAttribute | [inline]
getStipplePattern() const | LineAttribute | [inline]
getUserData() const | Object | [inline]
getWidth() const | LineAttribute | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isAntiAliased() const | LineAttribute | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LineAttribute | [virtual]
isTransparent(void) const | StateAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
LineAttribute() | LineAttribute |
LineAttribute(const PrimitiveAttribute &rhs) | LineAttribute | [explicit]
LineAttribute(const LineAttribute &rhs) | LineAttribute |
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const LineAttribute &rhs) | LineAttribute |
nvsg::PrimitiveAttribute::operator=(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
PrimitiveAttribute() | PrimitiveAttribute | [protected]
PrimitiveAttribute(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setAntiAliasing(bool aa) | LineAttribute | [inline]
setName(const std::string &name) | Object |
setStippleFactor(unsigned short factor) | LineAttribute | [inline]
setStipplePattern(unsigned short pattern) | LineAttribute | [inline]
setUserData(const void *userData) | Object | [inline]
setWidth(float width) | LineAttribute | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~LineAttribute() | LineAttribute | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~PrimitiveAttribute() | PrimitiveAttribute | [virtual]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:07 2008 for NVSGSDK by NVIDIA


Lines Class Reference

IndependentPrimitiveSet for lines. More...

#include <Lines.h>

Inheritance diagram for Lines:

[legend]
Collaboration diagram for Lines:

[legend]
List of all members.

Public Member Functions

NVSG_API | Lines ()
Default-constructs a Lines.

NVSG_API | Lines (const IndependentPrimitiveSet &rhs)
Constructs a Lines from an IndependentPrimitiveSet.

NVSG_API | Lines (const PrimitiveSet &rhs)
Constructs a Lines from a PrimitiveSet.

NVSG_API | Lines (const Lines &rhs)
Constructs a Lines as a copy from another Lines.

virtual NVSG_API | ~Lines ()
Destructs a Lines.

NVSG_API bool | hasSegments () const
Query if this Lines has segments.

NVSG_API unsigned int | getNumberOfSegments () const
Get the number of line segments.

NVSG_API const Segment * | getSegments () const
Get a pointer to the segments.

NVSG_API void | setSegments (const Segment *segments, unsigned int numSegments)
Set the segments of this Lines.

NVSG_API void | setSegments (unsigned int pos, const Segment *segments, unsigned int numSegments)
Set a subset of segments of this Lines.

NVSG_API Lines & | operator= (const Lines &rhs)
Assignment operator.

Detailed Description

IndependentPrimitiveSet for lines.

Namespace: nvsg
Remarks:
A Lines is an IndependentPrimitiveSet that holds an array of index-pairs. Each of these pairs describe a line with the indices referencing into the array of vertices. All vertex attributes (like normal, texture,...) are indexed with the same index.
See also:
IndependentPrimitiveSet, Points, Quads, Triangles

Constructor & Destructor Documentation

NVSG_API Lines ( )

Default-constructs a Lines.

NVSG_API Lines ( const IndependentPrimitiveSet & rhs ) [explicit]

Constructs a Lines from an IndependentPrimitiveSet.

NVSG_API Lines ( const PrimitiveSet & rhs ) [explicit]

Constructs a Lines from a PrimitiveSet.

NVSG_API Lines ( const Lines & rhs )

Constructs a Lines as a copy from another Lines.

virtual NVSG_API ~Lines ( ) [virtual]

Destructs a Lines.

Member Function Documentation

bool hasSegments ( ) const [inline]

Query if this Lines has segments.

Returns:
true, if this Lines has at least two indices, otherwise false.
Remarks:
Each pair of successive indices represent one line segment.
See also:
getNumberOfSegments, getSegments, hasIndices, setSegments

unsigned int getNumberOfSegments ( ) const [inline]

Get the number of line segments.

Returns:
The number of indices of this Lines divided by two.
Remarks:
Each pair of successive indices represent one line segment.
See also:
hasSegments, getSegments, setSegments

const Segment * getSegments ( ) const [inline]

Get a pointer to the segments.

Returns:
A pointer to the constant indices of this IndependentPrimitiveSet.
Remarks:
Each pair of successive indices represent one line segment.
See also:
hasSegments, getNumberOfSegments, setSegments

void setSegments | ( | const Segment * | segments,
 |  | unsigned int | numSegments
 | ) | [inline]

Set the segments of this Lines.

Parameters:
segments | A pointer to the constant segments to use.
numSegments | The number of segments, with two indices per segment.
Remarks:
Copies 2x numSegments indices from segments into this Lines by just calling the appropriate setIndices.
Note:
The behavior is undefined if there are less than numSegments values of type Segment located at segments.
See also:
hasIndices, getNumberOfIndices, getIndices

void setSegments | ( | unsigned int | pos,
 |  | const Segment * | segments,
 |  | unsigned int | numSegments
 | ) | [inline]

Set a subset of segments of this Lines.

Parameters:
pos | The start position inside the range of pre-existing segments.
segments | A pointer to the constant segments to use.
numSegments | The number of segments.
Remarks:
Copies 2x numSegments indices from segments into this Lines, starting at position 2x pos inside the range of pre-existing indices.
Pre-existing indices in the range [2*pos, 2*(pos + numSegments)) will be replaced. Pre-existing indices outside this range remain untouched.
If you specifiy (-1) for pos or pos specifies the number of segments currently stored, the segments pointed to by segments will be appended to the pre-existing segments.
Note:
The behavior is undefined if pos is neither a valid position inside the range of pre-existing segments, nor the number of segments currently stored, nor (-1).

The behavior is undefined if there are less than numSegments values of type Segment located at segments.

See also:
hasSegments, getNumberOfSegments, getSegments

Lines & operator= ( const Lines & rhs ) [inline]

Assignment operator.

Parameters:
rhs A reference to the constant Lines to copy from.
Returns:
A reference to the assigned Lines.
Remarks:
The assignment operator calls the assignment operator of IndependentPrimitiveSet.

The documentation for this class was generated from the following file:
  • Lines.h
Generated on Tue Jan 15 10:29:07 2008 for NVSGSDK by NVIDIA


Member List

Lines Member List

This is the complete list of members for Lines, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | IndependentPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getName() const | Object |
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfSegments() const | Lines | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSegments() const | Lines | [inline]
getSkin() const | PrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
hasSegments() const | Lines | [inline]
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
Lines() | Lines |
Lines(const IndependentPrimitiveSet &rhs) | Lines | [explicit]
Lines(const PrimitiveSet &rhs) | Lines | [explicit]
Lines(const Lines &rhs) | Lines |
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Lines &rhs) | Lines | [inline]
nvsg::IndependentPrimitiveSet::operator=(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setIndices(const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setIndices(unsigned int pos, const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setSegments(const Segment *segments, unsigned int numSegments) | Lines | [inline]
setSegments(unsigned int pos, const Segment *segments, unsigned int numSegments) | Lines | [inline]
setSkin(SkinHandle *skin) | PrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [virtual]
~Lines() | Lines | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
Generated on Tue Jan 15 10:29:07 2008 for NVSGSDK by NVIDIA


LineStrips Class Reference

StrippedPrimitiveSet for line strips. More...

#include <LineStrips.h>

Inheritance diagram for LineStrips:

[legend]
Collaboration diagram for LineStrips:

[legend]
List of all members.

Public Member Functions

NVSG_API | LineStrips ()
Default-constructs a LineStrips.

NVSG_API | LineStrips (const StrippedPrimitiveSet &rhs)
Constructs a LineStrips from a StrippedPrimitiveSet.

NVSG_API | LineStrips (const LineStrips &rhs)
Constructs a LineStrips as a copy from another LineStrips.

virtual NVSG_API | ~LineStrips ()
Destructs a LineStrips.

NVSG_API LineStrips & | operator= (const LineStrips &rhs)
Assignment operator.

Detailed Description

StrippedPrimitiveSet for line strips.

Namespace: nvsg
Remarks:
A LineStrips is a StrippedPrimitiveSet that holds an array of arrays of indices. Each of the arrays of indices describe one series of connected line segments. All vertex attributes (like normal, texture,...) are indexed with the same index.
See also:
Lines, StrippedPrimitiveSet, TriangleStrips

Constructor & Destructor Documentation

NVSG_API LineStrips ( )

Default-constructs a LineStrips.

NVSG_API LineStrips ( const StrippedPrimitiveSet & rhs ) [explicit]

Constructs a LineStrips from a StrippedPrimitiveSet.

NVSG_API LineStrips ( const LineStrips & rhs ) [explicit]

Constructs a LineStrips as a copy from another LineStrips.

virtual NVSG_API ~LineStrips ( ) [virtual]

Destructs a LineStrips.

Member Function Documentation

NVSG_API LineStrips& operator= ( const LineStrips & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant LineStrips to copy from.
Returns:
A reference to the assigned LineStrips.
Remarks:
The assignment operator calls the assignment operator of StrippedPrimitiveSet.

The documentation for this class was generated from the following file:
  • LineStrips.h
Generated on Tue Jan 15 10:29:08 2008 for NVSGSDK by NVIDIA


Member List

LineStrips Member List

This is the complete list of members for LineStrips, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | StrippedPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | StrippedPrimitiveSet | [protected, virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
LineStrips() | LineStrips |
LineStrips(const StrippedPrimitiveSet &rhs) | LineStrips | [explicit]
LineStrips(const LineStrips &rhs) | LineStrips | [explicit]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const LineStrips &rhs) | LineStrips |
nvsg::StrippedPrimitiveSet::operator=(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setStrips(const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setStrips(unsigned int pos, const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~LineStrips() | LineStrips | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [virtual]
Generated on Tue Jan 15 10:29:08 2008 for NVSGSDK by NVIDIA


LOD Class Reference

Distance-based level of detail class. More...

#include <LOD.h>

Inheritance diagram for LOD:

[legend]
Collaboration diagram for LOD:

[legend]
List of all members.

Public Member Functions

NVSG_API | LOD (void)
Default-constructs a LOD.

NVSG_API | LOD (const Group &rhs)
Constructs a LOD from a Group.

NVSG_API | LOD (const LOD &rhs)
Constructs a LOD as a copy of another LOD.

virtual NVSG_API | ~LOD (void)
Destructs a LOD.

NVSG_API void | setRanges (const float *ranges, unsigned int count)
Define the different ranges where the LOD should switch the representation.

NVSG_API const float * | getRanges () const
Get the ranges of the LOD.

NVSG_API unsigned int | getNumberOfRanges () const
Get the number of ranges.

NVSG_API void | setCenter (const nvmath::Vec3f &center)
Set the center of the LOD object.

NVSG_API const nvmath::Vec3f & | getCenter () const
Get the center point of the LOD object.

virtual NVSG_API unsigned int | getLODToUse (const nvmath::Mat44f &modelViewMatrix, float scaleFactor) const
Calculate the LOD level to use.

NVSG_API void | setRangeLock (bool on, unsigned int rangeNumber)
Lock the range selection to a specific LOD level.

NVSG_API unsigned int | getRangeLock () const
Get the range lock number.

NVSG_API bool | isRangeLockEnabled () const
Check if the LOD is forced to use a specific range.

NVSG_API LOD & | operator= (const LOD &rhs)
Copy operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other LOD.

Protected Member Functions

virtual NVSG_API bool | determineLODContainment () const
Overrides Node::determineLODContainment.

Detailed Description

Distance-based level of detail class.

Namespace: nvsg
Remarks:
This class is a special kind of a group containing different representations of the same object as well as some range information. The representations include different levels of detail, meaning that the first child is the best and most precise representation of the object, the second child is of lower resolution, and so on. The current implementation determines the distance between the camera and the given center point of the object (dist). The distance is compared against the ranges and the corresponding range defines the LOD representation to use.

It works like this:
  IF (dist < ranges[0])                    THEN activeChild = 0
  ELSE IF (ranges[i-1] < dist < ranges[i]) THEN activeChild = i
  ELSE IF (dist > ranges[LASTRANGE])       THEN activeChild = LASTRANGE+1

You should provide n ranges and n+1 children. If you specify too few ranges, the extra children will never be used. If you instead provide too few children, the last child will be used for all the extra ranges.

In some cases you do not want to draw something on the last (infinite) level. In this case, simply add an empty Group node at the lowest resolution level. The same applies to the highest resolution level if you want geometry that is too near to the camera to disappear.

Constructor & Destructor Documentation

NVSG_API LOD ( void )

Default-constructs a LOD.

NVSG_API LOD ( const Group & rhs ) [explicit]

Constructs a LOD from a Group.

Parameters:
rhs Group to construct the LOD from.
Remarks:
This is kind of a partial copy constructor only copying the Group part from the source object.

NVSG_API LOD ( const LOD & rhs )

Constructs a LOD as a copy of another LOD.

virtual NVSG_API ~LOD ( void ) [virtual]

Destructs a LOD.

Member Function Documentation

NVSG_API void setRanges | ( | const float * | ranges,
 |  | unsigned int | count
 | ) |

Define the different ranges where the LOD should switch the representation.

Parameters:
ranges | A vector of range values representing the world-space distances. Pass in NULL to clear the range data.
count | Number of ranges in the given vector.
Remarks:
This function can be used to set the different ranges for switching between the different representations. You need to provide n ranges for n+1 children.
Example
  float ranges[3];
  range[0] = 10;
  range[1] = 20;
  range[2] = 30;
  LOD * pNCLOD = beginEdit(pLOD);
    pNCLOD->setRanges( &ranges[0], 3 );
  endEdit(pNCLOD);
See also:
getRanges

NVSG_API const float* getRanges ( ) const

Get the ranges of the LOD.

Returns:
A pointer to a constant vector of ranges. If there are no ranges defined, the return value is NULL.
Remarks:
You need to call nvsg::getNumberOfRanges to determine the number of ranges. The ranges represent the world-space distances where the LOD switches to the next representation.
See also:
getNumberOfRanges

NVSG_API unsigned int getNumberOfRanges ( ) const

Get the number of ranges.

Returns:
The number of ranges in the LOD.
See also:
setRanges

NVSG_API void setCenter ( const nvmath::Vec3f & center )

Set the center of the LOD object.

Parameters:
center Center point of the LOD object in world-space coordinates.
Remarks:
The center is the point used for calculating the exact level of detail to use. By calculating the distance between this center point and the camera position in the LOD, can decide which representation to choose.
A good center point is, for example, the center of the bounding sphere of the object in the highest representation.
See also:
getCenter

NVSG_API const nvmath::Vec3f& getCenter ( ) const

Get the center point of the LOD object.

Returns:
The center point in world-space coordinates.
Remarks:
See nvsg::setCenter for a detailed description on the center point.
See also:
setCenter

virtual NVSG_API unsigned int getLODToUse | ( | const nvmath::Mat44f & | modelViewMatrix,
 |  | float | scaleFactor
 | ) | const [virtual]

Calculate the LOD level to use.

Parameters:
modelViewMatrix | currentWorldMatrix * currentViewingMatrix
scaleFactor | This factor is used to scale the ranges of the LOD node. Default is 1.f. See ViewState::getLODRangeScale for further details.
Returns:
The index of the LOD level that this node will use. 0xffffffff will be returned when there is no LOD level available.
Remarks:
This method is called by the ModelViewTraverser. It calculates the distance between the center point and the camera.
We calculate the distance by transforming the center into object space, and because the camera is located at the origin in object space, the calculation is trivial.
The scale factor can be used to globally scale the ranges without changing the LOD node ranges directly. This can be used, for example, for scenes that were initially created for use on small monitors. You can use this scaling to fine-tune these scenes for large projection walls by scaling the LOD levels to switch later to a lower resolution representation.
See also:
ViewState::getLODRangeScale

NVSG_API void setRangeLock | ( | bool | on,
 |  | unsigned int | rangeNumber
 | ) |

Lock the range selection to a specific LOD level.

Parameters:
on | true to turn on the range lock.
rangeNumber | The range that should be used for all the rendering.
Remarks:
This feature prevents the distance calculation and forces the LOD to use a specific representation.
If the provided range number is larger than the available ranges, the LOD always uses the representation of the last range - lowest resolution.
Example
The following sample code demonstrates how to lock all LOD node of a scene to a specified range.
  void LODDlg::lockLODRange(bool on, unsigned int level)
  {
    const Scene * pScene = m_pRA->getScene();
    if (pScene)
    {
      pScene->addRef();

      SearchTraverser * st = new SearchTraverser;
      st->addRef();
      st->setClassName( "class nvsg::LOD" );
      st->setBaseClassSearch( true );
      st->apply( pScene );
      const vector<const Path *> &vp = st->getPaths();
      for ( unsigned int i=0 ; i<vp.size() ; i++ )
      {
        LOD * pLOD = dynamic_cast<LOD*>(beginEdit(vp[i]->getTail()));
          pLOD->setRangeLock(on, level);
        endEdit(pLOD);
      }

      pScene->removeRef();
      st->removeRef();
    }
  }
See also:
getRangeLock

NVSG_API unsigned int getRangeLock ( ) const

Get the range lock number.

Returns:
The range number this LOD is forced to use.
Remarks:
The returned value is only valid if LOD::isRangeLockedEnabled returns true.
See also:
setRangeLock, isRangeLockEnabled

NVSG_API bool isRangeLockEnabled ( ) const

Check if the LOD is forced to use a specific range.

Returns:
This function returns true when the range lock is turned on.
See also:
setRangeLock

NVSG_API LOD& operator= ( const LOD & rhs )

Copy operator.

Parameters:
rhs A reference to the constant LOD to copy from
Returns:
A reference to the copied LOD
Remarks:
The copy operator calls the copy-operator of Group and then copies the Group-specific data.
See also:
Group

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other LOD.

Parameters:
p | A pointer to the LOD to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the LOD p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as LOD, they are equivalent if they have the same center, ranges, and range lock settings.
Note:
The behavior is undefined if p is not an LOD or derived from one.

Reimplemented from Group.

virtual NVSG_API bool determineLODContainment ( ) const [protected, virtual]

Overrides Node::determineLODContainment.

Returns:
The function returns true if this LOD contain more than one selectable level. If the LOD object is range-locked, or if it holds only a single range, the function returns false.

Reimplemented from Group.

The documentation for this class was generated from the following file:
  • LOD.h
Generated on Tue Jan 15 10:29:08 2008 for NVSGSDK by NVIDIA


Member List

LOD Member List

This is the complete list of members for LOD, including all inherited members.
activateClipPlane(unsigned int index) | Group |
addChild(NodeHandle *child, unsigned int position=~0) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addLightSource(LightSourceHandle *lsHdl) | Group |
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const | Group | [protected, virtual]
calculateBoundingSphere() const | Group | [protected, virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
deactivateClipPlane(unsigned int index) | Group |
determineAnimationContainment() const | Group | [protected, virtual]
determineCgFxContainment() const | Group | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineLightContainment() const | Group | [protected, virtual]
determineLODContainment() const | LOD | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
determineVolumeNodeContainment() const | Group | [protected, virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getCenter() const | LOD |
getChild(unsigned int position) const | Group | [inline]
getChildPositions(NodeHandle *node, std::vector< unsigned int > &positions) const | Group |
getClipPlane(unsigned int index) const | Group | [inline]
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getLightSource(unsigned int index) const | Group | [inline]
getLODToUse(const nvmath::Mat44f &modelViewMatrix, float scaleFactor) const | LOD | [virtual]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfLightSources() const | Group | [inline]
getNumberOfParents() const | Node | [inline]
getNumberOfRanges() const | LOD |
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getRangeLock() const | LOD |
getRanges() const | LOD |
getUserData() const | Object | [inline]
Group() | Group |
Group(const Node &rhs) | Group | [explicit]
Group(const Group &rhs) | Group |
hasChild(NodeHandle *node) const | Group | [inline]
hasLightSource(LightSourceHandle *lsHdl) const | Group | [inline]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCaches(NodeHandle *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isClipPlaneActive(unsigned int index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LOD | [virtual]
isRangeLockEnabled() const | LOD |
leaveCS() const (defined in Object) | Object | [inline, protected]
LOD(void) | LOD |
LOD(const Group &rhs) | LOD | [explicit]
LOD(const LOD &rhs) | LOD |
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const LOD &rhs) | LOD |
nvsg::Group::operator=(const Group &rhs) | Group |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
postAddChild(unsigned int position) | Group | [protected, virtual]
postRemoveChild(unsigned int position) | Group | [protected, virtual]
preAddChild(unsigned int position) | Group | [protected, virtual]
preRemoveChild(unsigned int position) | Group | [protected, virtual]
removeChild(NodeHandle *child) | Group |
removeChild(unsigned int position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeLightSource(unsigned int index) | Group |
replaceChild(NodeHandle *newChild, NodeHandle *oldChild) | Group |
replaceChild(NodeHandle *newChild, unsigned int position) | Group |
replaceLightSource(unsigned int index, LightSourceHandle *lsHdl) | Group |
replaceLightSource(LightSourceHandle *newHdl, LightSourceHandle *oldHdl) | Group |
setAnnotation(const std::string &anno) | Object |
setCenter(const nvmath::Vec3f &center) | LOD |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setRangeLock(bool on, unsigned int rangeNumber) | LOD |
setRanges(const float *ranges, unsigned int count) | LOD |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Group | [virtual]
~Group() | Group | [virtual]
~LOD(void) | LOD | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:08 2008 for NVSGSDK by NVIDIA


TemplateLog class Reference

Log Class Template Reference
[Logging a certain test results]

Logging test results. More...

#include <Log.h>

List of all members.

Public Member Functions

Log ()
Default constructor.

void | init (bool enable)
Initialization.

void | format (const char *fmt,...) const
Formatted output.

bool | isEnabled () const
Determine whether a certain test mode is enabled.

Detailed Description

template<TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
class nvutil::Log< TestMode, OutputFn >

Logging test results.

Provides output dependent on a specified TestMode using a certain output function of type LOG_OUTPUT_FUNCTION specified by OutputFn.

Constructor & Destructor Documentation

Log ( ) [inline]

Default constructor.

Constructs a Log object and disables output by default. Use init to enable output via OutputFn.

The documentation for this class was generated from the following file:
  • Log.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

Log Member List

This is the complete list of members for Log, including all inherited members.
format(const char *fmt,...) const | Log | [inline]
init(bool enable) | Log | [inline]
isEnabled() const | Log | [inline]
Log() | Log | [inline]
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Manipulator Class Reference

Base class for all kinds of manipulators. More...

#include <Manipulator.h>

Inheritance diagram for Manipulator:

[legend]
Collaboration diagram for Manipulator:

[legend]
List of all members.

Public Member Functions

NVSG_API | Manipulator ()
Default constructor.

virtual NVSG_API | ~Manipulator ()
Default destructor.

NVSG_API void | setRenderArea (nvui::RenderArea *renderArea)
Assign the current RenderArea to work with.

virtual NVSG_API bool | updateFrame ()=0
Apply changes for the next frame.

virtual NVSG_API bool | isActive ()=0
Give feedback of the activeness of the manipulator.

Protected Attributes

nvui::RenderArea * m_renderArea
The asssigned RenderArea containing ViewState etc.

Detailed Description

Base class for all kinds of manipulators.

Namespace: nvui
Remarks:
This purely virtual class serves as the base class for all kinds of manipulators for user interaction such as controlling the nvsg::Camera, nvsg::Transform, etc.
The Manipulator works closely with the RenderArea from where the manipulator code can retrieve the current nvsg::ViewState, nvsg::Camera etc.

If you use a Manipulator, your application must use a mechanism (such as using OnIdle() that calls updateFrame()). If updateFrame() returns true, you should call triggerRedraw of the render area so the updated frame will be drawn.
See the SimpleViewer tutorial source code for details on how to use a manipulator with MFC.
See the ConsoleViewer tutorial source code for details on how to use a manipulator.

The following code snippets show the Manipulator handling in the idle handler of an MFC based application.

The doIdleHandling is called from the OnIdle handler of the CWinApp derived class:
  BOOL ViewerApp::OnIdle(LONG lCount)
  {
    BOOL retval  = CWinApp::OnIdle(lCount);
    [...]
    if (pActiveView)
    {
      retval |= pActiveView->doIdleHandling();
    }
    return retval;
  }
See the Microsoft documentation of CWinApp::doIdle for the return value description.

The following code shows the basic steps that are needed to draw the scene:
  BOOL ViewerView::doIdleHandling()
  {
    if (m_pManip->updateFrame())
    {
      m_pRA->triggerRedraw();
    }
    return FALSE;  // Return FALSE, no continues redraw - we are done
                   // we only want to draw the next frame when there was mouse
                   // movement or such. Some Manipulators want to do continuous redraw
                   // like an AnimationManipulator. These manipulators should return TRUE,
                   // so OnIdle is called again.
  }

Deriving your own Manipulator class is straight forward. Camera manipulators should be derived from this base class. Manipulators working on nvsg::Transform nodes should be derived from the TransformManipulator class.
See the ManipSampleViewer tutorial source code on how to derive a new Manipulator.
See also:
TrackballCameraManipulator, WalkCameraManipulator, FlightCameraManipulator, AnimationManipulator, TransformManipulator, TrackballTransformManipulator

Constructor & Destructor Documentation

NVSG_API Manipulator ( )

Default constructor.

Remarks:
Initialize the Manipulator object.

virtual NVSG_API ~Manipulator ( ) [virtual]

Default destructor.

Member Function Documentation

void setRenderArea ( nvui::RenderArea * renderArea ) [inline]

Assign the current RenderArea to work with.

Parameters:
renderArea Pointer to the RenderArea object. NULL is a valid input.
Remarks:
The assigned RenderArea will be used to extract nvui::ViewState and nvsg::Camera information.

virtual NVSG_API bool updateFrame ( ) [pure virtual]

Apply changes for the next frame.

Returns:
If there is a change regarding the last frame this function returns true.
Remarks:
This function updates the objects which are manipulated by the Manipulator. If the return value is true, the application should trigger a redraw by calling triggerRedraw.
Example
See the sample code in the Manipulator class description.
See also:
RenderArea::TriggerRedraw

Implemented in AnimationManipulator, FlightCameraManipulator, TrackballCameraManipulator, TrackballTransformManipulator, and WalkCameraManipulator.

virtual NVSG_API bool isActive ( ) [pure virtual]

Give feedback of the activeness of the manipulator.

Returns:
This function returns true when the manipulator is in active mode.
Remarks:
All derived manipulators need to implement this method to reflect the manipulator state. The manipulator should return true if it is in a special mode such as rotate, pan, etc..

Implemented in AnimationManipulator, FlightCameraManipulator, TrackballCameraManipulator, TrackballTransformManipulator, and WalkCameraManipulator.

Member Data Documentation

nvui::RenderArea* m_renderArea [protected]

The asssigned RenderArea containing ViewState etc.

Remarks:
Member could contain a NULL pointer.

The documentation for this class was generated from the following file:
  • Manipulator.h
Generated on Tue Jan 15 10:29:42 2008 for NVSGSDK by NVIDIA


Member List

Manipulator Member List

This is the complete list of members for Manipulator, including all inherited members.
isActive()=0 | Manipulator | [pure virtual]
m_renderArea | Manipulator | [protected]
Manipulator() | Manipulator |
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
updateFrame()=0 | Manipulator | [pure virtual]
~Manipulator() | Manipulator | [virtual]
Generated on Tue Jan 15 10:29:42 2008 for NVSGSDK by NVIDIA


Map Class Reference

Abstract base class for Map objects. More...

#include <Map.h>

Inheritance diagram for Map:

[legend]
Collaboration diagram for Map:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~Map ()
Destructs a Map.

NVSG_API size_t | getWidth () const
Get the width of the Map in pixels.

NVSG_API size_t | getHeight () const
Get the height of the Map in pixels.

NVSG_API const unsigned char * | getData () const
Get a pointer to the constant data of the Map.

Protected Member Functions

NVSG_API | Map ()
Protected default constructor to prevent explicit creation.

NVSG_API | Map (const Map &rhs)
Protected copy constructor to prevent explicit creation.

NVSG_API void | setMapData (size_t width, size_t height, size_t bitsPerPixel, unsigned char *data)
Set the complete data of the Map.

Detailed Description

Abstract base class for Map objects.

Namespace: nvsg
Remarks:
A Map is a two dimensional image that can be used as some kind of overlay on top of the scene image. It's easy to use for on-screen menus or data display.
The map data is organized by rows, each one (width*bpp+7)/8 byte long, beginning at the bottom left corner of the map.
Note:
There is no default constructor available to prevent incompletely-defined Maps.
See also:
Bitmap, Object

Constructor & Destructor Documentation

virtual NVSG_API ~Map ( ) [virtual]

Destructs a Map.

NVSG_API Map ( ) [protected]

Protected default constructor to prevent explicit creation.

NVSG_API Map ( const Map & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Remarks:
The complete map data is copied over from rhs.

Member Function Documentation

size_t getWidth ( ) const [inline]

Get the width of the Map in pixels.

Returns:
The width of the Map in pixels.
See also:
getHeight

size_t getHeight ( ) const [inline]

Get the height of the Map in pixels.

Returns:
The height of the Map in pixels.
See also:
getWidth

const unsigned char * getData ( ) const [inline]

Get a pointer to the constant data of the Map.

Returns:
A pointer to the constant data of the Map.
Remarks:
The map data is organized by rows, each one (width*bpp+7)/8 byte long, beginning at the bottom left corner of the map.
See also:
getHeight, getWidth

NVSG_API void setMapData | ( | size_t | width,
 |  | size_t | height,
 |  | size_t | bitsPerPixel,
 |  | unsigned char * | data
 | ) | [protected]

Set the complete data of the Map.

Parameters:
width | The width of the Map in pixels.
height | The height of the Map in pixels.
bitsPerPixel | The number of bits used per pixel.
data | A pointer to the constant data of the Map.
Remarks:
This function allocates height*((width*bpp+7)/8) bytes to hold the map data and copies as many bytes from data.

The documentation for this class was generated from the following file:
  • Map.h
Generated on Tue Jan 15 10:29:08 2008 for NVSGSDK by NVIDIA


Member List

Map Member List

This is the complete list of members for Map, including all inherited members.
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getData() const | Map | [inline]
getDataID() const | Object | [virtual]
getHeight() const | Map | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getObjectCode() const | Object | [inline]
getUserData() const | Object | [inline]
getWidth() const | Map | [inline]
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Map() | Map | [protected]
Map(const Map &rhs) | Map | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Object &rhs) | Object | [protected]
setAnnotation(const std::string &anno) | Object |
setMapData(size_t width, size_t height, size_t bitsPerPixel, unsigned char *data) | Map | [protected]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~Map() | Map | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:08 2008 for NVSGSDK by NVIDIA


MapArray Class Reference

Class to hold an array of Map objects. More...

#include <MapArray.h>

Inheritance diagram for MapArray:

[legend]
Collaboration diagram for MapArray:

[legend]
List of all members.

Public Member Functions

NVSG_API | MapArray ()
Default-constructs a MapArray.

NVSG_API | MapArray (const MapArray &rhs)
Copy-constructs a MapArray from another MapArray.

virtual NVSG_API | ~MapArray ()
Destructs a MapArray.

NVSG_API MapAlignment | getAlignment () const
Get the alignment of the MapArray.

NVSG_API void | setAlignment (MapAlignment alignment)
Set the alignment of the MapArray.

NVSG_API MapOrientation | getOrientation () const
Get the orientation of the MapArray.

NVSG_API void | setOrientation (MapOrientation orientation)
Set the orientation of the MapArray.

NVSG_API unsigned int | getSpacing () const
Get the spacing between consecutive Map objects.

NVSG_API void | setSpacing (unsigned int spacing)
Set the spacing between consecutive Map objects.

NVSG_API MapTraversalDirection | getTraversalDirection () const
Get the traversal direction of the MapArray.

NVSG_API void | setTraversalDirection (MapTraversalDirection direction)
Set the traversal direction of the MapArray.

NVSG_API unsigned int | getNumberOfMaps () const
Get the number of Map objects in this MapArray.

NVSG_API TextureImageHandle * | getMap (unsigned int index) const
Get a pointer to the image at the specified index.

NVSG_API unsigned int | getIndexOfMap (TextureImageHandle *img) const
Get the index of a image in this MapArray.

NVSG_API void | addMap (TextureImageHandle *img)
Add an image to the end of the MapArray.

NVSG_API void | insertMap (unsigned int index, TextureImageHandle *img)
Insert an image in front of the specified index.

NVSG_API void | replaceMap (unsigned int index, TextureImageHandle *img)
Replace the image at the specified index.

NVSG_API void | removeMap (unsigned int index)
Remove the Map at the specified index.

NVSG_API void | clear (void)
Clear the MapArray.

NVSG_API void | getEntrySize (unsigned int &width, unsigned int &height) const
Get the maximal width and height of the Map objects.

virtual NVSG_API void | getSize (unsigned int &width, unsigned int &height) const
Get the overall size of the MapArray.

virtual NVSG_API TextureImageHandle * | pickMap (int x, int y) const
Get the image being at the specified raster position.

Detailed Description

Class to hold an array of Map objects.

Namespace: nvsg
Remarks:
This class is used to add an array of Map objects to a MapList. This array can be oriented horizontally or vertically. The Map objects can be aligned along a common base, center, or top line. The traversal direction can be from the lower to the higher index, or vice versa. A spacing can be determined to be between each of the Map objects.
See also:
Map, MapElement, MapList, MapMatrix

Constructor & Destructor Documentation

NVSG_API MapArray ( )

Default-constructs a MapArray.

Remarks:
The MapArray initially is aligned along the lower base line (MA_LOWER), is vertical oriented (MO_VERTICAL), has a spacing of 1 pixel, and will be traversed from low index to high index (MTD_LOW_TO_HIGH).

NVSG_API MapArray ( const MapArray & rhs )

Copy-constructs a MapArray from another MapArray.

virtual NVSG_API ~MapArray ( ) [virtual]

Destructs a MapArray.

Member Function Documentation

MapAlignment getAlignment ( ) const [inline]

Get the alignment of the MapArray.

Returns:
The MapAlignment of the MapArray.
Remarks:
If the Map objects of the MapArray have different sizes, they can be aligned along their lower (MA_LOWER), center (MA_CENTER), or upper (MA_UPPER) coordinate. The default is MA_LOWER.
Example
If the MapArray is horizontally oriented, and the Map objects have different heights, they can have a common base line (MA_LOWER), a common center line (MA_CENTER), or a common top line (MA_UPPER).
If the MapArray is vertically oriented, and the Map objects have different widths, they can have a common left margin (MA_LOWER), a common center line (MA_CENTER), or a common right margin (MA_UPPER).
See also:
getOrientation, setAlignment

void setAlignment ( MapAlignment alignment ) [inline]

Set the alignment of the MapArray.

Parameters:
alignment The MapAlignment of the MapArray.
Remarks:
If the Map objects of the MapArray have different sizes, they can be aligned along their lower (MA_LOWER), center (MA_CENTER), or upper (MA_UPPER) coordinate. The default is MA_LOWER.
Example
If the MapArray is horizontally oriented, and the Map objects have different heights, they can have a common base line (MA_LOWER), a common center line (MA_CENTER), or a common top line (MA_UPPER).
If the MapArray is vertically oriented, and the Map objects have different widths, they can have a common left margin (MA_LOWER), a common center line (MA_CENTER), or a common right margin (MA_UPPER).
See also:
getAlignment, setOrientation

MapOrientation getOrientation ( ) const [inline]

Get the orientation of the MapArray.

Returns:
The MapOrientation of the MapArray.
Remarks:
The Map objects of the MapArray can be oriented either horizontally (MO_HORIZONTAL) or vertically (MO_VERTICAL), thus resulting in either a row of Map objects or a column of Map objects. The default is MO_VERTICAL.
See also:
getAlignment, setOrientation

void setOrientation ( MapOrientation orientation ) [inline]

Set the orientation of the MapArray.

Parameters:
orientation The MapOrientation of the MapArray.
Remarks:
The Map objects of the MapArray can be oriented either horizontally (MO_HORIZONTAL) or vertically (MO_VERTICAL), thus resulting in either a row of Map objects or a column of Map objects. The default is MO_VERTICAL.
See also:
getOrientation, setAlignment

unsigned int getSpacing ( ) const [inline]

Get the spacing between consecutive Map objects.

Returns:
The spacing between consecutive Map objects.
Remarks:
Between each Map of the MapArray, there can be some open space remaining. The default is one.
See also:
setSpacing

void setSpacing ( unsigned int spacing ) [inline]

Set the spacing between consecutive Map objects.

Parameters:
spacing The spacing between consecutive Map objects.
Remarks:
Between each Map of the MapArray, there can be some open space remaining. The default is one.
See also:
getSpacing

MapTraversalDirection getTraversalDirection ( ) const [inline]

Get the traversal direction of the MapArray.

Returns:
The MapTraversalDirection of the MapArray.
Remarks:
The Map objects of the MapArray can be traversed either from lower to higher index (MTD_LOW_TO_HIGH) or from higher to lower index (MTD_HIGH_TO_LOW). The default is MTD_LOW_TO_HIGH.
Example
If the MapArray is vertically oriented, aligned to the lower base line, and the traversal direction is MTD_LOW_TO_HIGH, the Map with index 0 is drawn at the bottom base line, the Map with index 1 is drawn above, and so on.
See also:
getAlignment, getOrientation, setTraversalDirection

void setTraversalDirection ( MapTraversalDirection direction ) [inline]

Set the traversal direction of the MapArray.

Parameters:
direction The MapTraversalDirection of the MapArray.
Remarks:
The Map objects of the MapArray can be traversed either from lower to higher index (MTD_LOW_TO_HIGH) or from higher to lower index (MTD_HIGH_TO_LOW). The default is MTD_LOW_TO_HIGH.
Example
If the MapArray is vertically oriented, aligned to the lower base line, and the traversal direction is MTD_LOW_TO_HIGH, the Map with index 0 is drawn at the bottom base line, the Map with index 1 is drawn above, and so on.
See also:
getTraversalDirection, setAlignment, setOrientation

unsigned int getNumberOfMaps ( ) const [inline]

Get the number of Map objects in this MapArray.

Returns:
The number of Map objects in this MapArray.
See also:
addMap, getMap, insertMap, pickMap, removeMap, replaceMap

TextureImageHandle * getMap ( unsigned int index ) const [inline]

Get a pointer to the image at the specified index.

Parameters:
index Index of the image to get.
Returns:
A pointer to the image at the specified index in the MapArray.
Note:
The behavior is undefined, if index is larger than or equal to the number of images in this MapArray.
See also:
addMap, getNumberOfMaps, insertMap, removeMap, replaceMap

unsigned int getIndexOfMap ( TextureImageHandle * img ) const [inline]

Get the index of a image in this MapArray.

Parameters:
img A pointer to the image to get index for.
Returns:
The index of img in this MapArray, or (-1) if img is not part of this MapArray.
See also:
getMap, pickMap

void addMap ( TextureImageHandle * img ) [inline]

Add an image to the end of the MapArray.

Parameters:
img A pointer to the image to add.
Remarks:
The reference count of img is incremented.
See also:
getMap, getNumberOfMaps, insertMap, replaceMap, removeMap

void insertMap | ( | unsigned int | index,
 |  | TextureImageHandle * | img
 | ) | [inline]

Insert an image in front of the specified index.

Parameters:
index | Index to insert an image before.
img | A pointer to the image to insert.
Remarks:
The reference count of img is incremented.
Note:
The behavior is undefined if index is larger than or equal to the number of images in this MapArray.
See also:
addMap, getMap, getNumberOfMaps, replaceMap, removeMap

void replaceMap | ( | unsigned int | index,
 |  | TextureImageHandle * | img
 | ) | [inline]

Replace the image at the specified index.

Parameters:
index | Index to replace the image at.
img | A pointer to the image to replace with.
Remarks:
The reference count of img is incremented, and the reference count of the image previously at index index is decremented.
Note:
The behavior is undefined if index is larger than or equal to the number of Map objects in this MapArray.
See also:
addMap, getMap, getNumberOfMaps, insertMap, removeMap

void removeMap ( unsigned int index ) [inline]

Remove the Map at the specified index.

Parameters:
index Index to remove the Map at.
Remarks:
The reference count of the Map at index index is decremented.
Note:
The behavior is undefined if index is larger than or equal to the number of Map objects in this MapArray.
See also:
addMap, getMap, getNumberOfMaps, insertMap, replaceMap

NVSG_API void clear ( void )

Clear the MapArray.

Remarks:
The reference count of every Map in this MapArray is decremented, and the array is cleared.
See also:
addMap, getNumberOfMaps, removeMap

NVSG_API void getEntrySize | ( | unsigned int & | width,
 |  | unsigned int & | height
 | ) | const

Get the maximal width and height of the Map objects.

Parameters:
width | Reference to the maximal width, in pixels, to get.
height | Reference to the maximal height, in pixels, to get.
Remarks:
For a horizontally oriented MapArray, height is used as the overall height; for a vertically oriented MapArray, width is used as the overall width.
See also:
getOrientation, getSize

virtual NVSG_API void getSize | ( | unsigned int & | width,
 |  | unsigned int & | height
 | ) | const [virtual]

Get the overall size of the MapArray.

Parameters:
width | Reference to the overall width, in pixels, to get.
height | Reference to the overall height, in pixels, to get.
Remarks:
The overall size of a MapArray is the size, in pixels, that the complete MapArray has.
Example
For a horizontally oriented MapArray, height is the same as what you get with getEntrySize(), while width is the sum of the widths of every Map in the MapArray, plus the spacing in between them.
For a vertically oriented MapArray, width is the same as what you get with getEntrySize(), while height is the sum of the heights of every Map in the MapArray, plus the spacing in between them.
See also:
getEntrySize, getOrientation

Implements MapObject.

virtual NVSG_API TextureImageHandle* pickMap | ( | int | x,
 |  | int | y
 | ) | const [virtual]

Get the image being at the specified raster position.

Parameters:
x | Horizontal raster coordinate to get Map at.
y | Vertical raster coordinate to get Map at.
Returns:
A pointer to a TextureImageHandle specifying the image at the specified raster position, or NULL if no image was found at that position.
Remarks:
This function determines the image of this MapArray at the specified raster position (x, y), if any. It takes into account the position, alignment, direction, orientation, and spacing. For a horizontally oriented MapArray, the images are considered to be of equal height; for a vertically oriented MapArray, the images are considered to be of equal width. If the position is in the spacing between two images, or outside of the overall size of the MapArray, NULL is returned.
See also:
getEntrySize, getSize, getMap

Implements MapObject.

The documentation for this class was generated from the following file:
  • MapArray.h
Generated on Tue Jan 15 10:29:08 2008 for NVSGSDK by NVIDIA


Member List

MapArray Member List

This is the complete list of members for MapArray, including all inherited members.
addMap(TextureImageHandle *img) | MapArray | [inline]
clear(void) | MapArray |
enterCS() const | Object | [inline, protected]
getAlignment() const | MapArray | [inline]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getEntrySize(unsigned int &width, unsigned int &height) const | MapArray |
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIndexOfMap(TextureImageHandle *img) const | MapArray | [inline]
getLowerLeft(int &x, int &y) const | MapObject |
getMap(unsigned int index) const | MapArray | [inline]
getName() const | Object |
getNumberOfMaps() const | MapArray | [inline]
getObjectCode() const | Object | [inline]
getOrientation() const | MapArray | [inline]
getPosition(int &x, int &y) const | MapObject | [inline]
getRelation(void) const | MapObject | [inline]
getSize(unsigned int &width, unsigned int &height) const | MapArray | [virtual]
getSpacing() const | MapArray | [inline]
getTraversalDirection() const | MapArray | [inline]
getUserData() const | Object | [inline]
insertMap(unsigned int index, TextureImageHandle *img) | MapArray | [inline]
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
MapArray() | MapArray |
MapArray(const MapArray &rhs) | MapArray |
MapObject(void) | MapObject | [protected]
MapObject(const MapObject &rhs) | MapObject | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Object &rhs) | Object | [protected]
pickMap(int x, int y) const | MapArray | [virtual]
removeMap(unsigned int index) | MapArray | [inline]
replaceMap(unsigned int index, TextureImageHandle *img) | MapArray | [inline]
setAlignment(MapAlignment alignment) | MapArray | [inline]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setOrientation(MapOrientation orientation) | MapArray | [inline]
setPosition(int x, int y) | MapObject | [inline]
setRelation(MapRelation relation) | MapObject | [inline]
setSpacing(unsigned int spacing) | MapArray | [inline]
setTraversalDirection(MapTraversalDirection direction) | MapArray | [inline]
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~MapArray() | MapArray | [virtual]
~MapObject(void) | MapObject | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:08 2008 for NVSGSDK by NVIDIA


MapElement Class Reference

Class to hold a single Map. More...

#include <MapElement.h>

Inheritance diagram for MapElement:

[legend]
Collaboration diagram for MapElement:

[legend]
List of all members.

Public Member Functions

NVSG_API | MapElement ()
Default constructor of a MapElement.

NVSG_API | MapElement (const MapElement &rhs)
Copy-constructs a MapElement.

virtual NVSG_API | ~MapElement ()
Destructs a MapElement.

NVSG_API TextureImageHandle * | getMap () const
Get a pointer to the image.

virtual NVSG_API TextureImageHandle * | pickMap (int x, int y) const
Get the image being at the specified raster position.

NVSG_API void | setMap (TextureImageHandle *img)
Set the image of the MapElement.

virtual NVSG_API void | getSize (unsigned int &width, unsigned int &height) const
Get the overall size of the MapElement.

Detailed Description

Class to hold a single Map.

Namespace: nvsg
Remarks:
This class is used to add a single Map to a MapList.
See also:
Map, MapArray, MapList, MapMatrix

Constructor & Destructor Documentation

NVSG_API MapElement ( )

Default constructor of a MapElement.

Remarks:
The default constructor creates an empty MapElement without associated Map. To set the Map use setMap().

NVSG_API MapElement ( const MapElement & rhs )

Copy-constructs a MapElement.

Parameters:
rhs Source MapElement.

virtual NVSG_API ~MapElement ( ) [virtual]

Destructs a MapElement.

Member Function Documentation

TextureImageHandle * getMap ( ) const [inline]

Get a pointer to the image.

Returns:
A pointer to the image of this MapElement.
See also:
pickMap

virtual NVSG_API TextureImageHandle* pickMap | ( | int | x,
 |  | int | y
 | ) | const [virtual]

Get the image being at the specified raster position.

Parameters:
x | Horizontal raster coordinate to get the image at.
y | Vertical raster coordinate to get the image at.
Returns:
A pointer to the image specified for the specified raster position, or NULL if no image was found at that position.
Remarks:
This functions determines if the image of this MapElement is at the specified raster position (x, y). If it is, a pointer to the image is returned, otherwise NULL.
See also:
getMap

Implements MapObject.

NVSG_API void setMap ( TextureImageHandle * img )

Set the image of the MapElement.

Parameters:
img A pointer to a image to be used by this MapElement.

virtual NVSG_API void getSize | ( | unsigned int & | width,
 |  | unsigned int & | height
 | ) | const [virtual]

Get the overall size of the MapElement.

Parameters:
width | Reference to the overall width, in pixels, to get.
height | Reference to the overall height, in pixels, to get.
Remarks:
The overall size of the MapElement is the size, in pixels, of it's Map.

Implements MapObject.

The documentation for this class was generated from the following file:
  • MapElement.h
Generated on Tue Jan 15 10:29:09 2008 for NVSGSDK by NVIDIA


Member List

MapElement Member List

This is the complete list of members for MapElement, including all inherited members.
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLowerLeft(int &x, int &y) const | MapObject |
getMap() const | MapElement | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
getPosition(int &x, int &y) const | MapObject | [inline]
getRelation(void) const | MapObject | [inline]
getSize(unsigned int &width, unsigned int &height) const | MapElement | [virtual]
getUserData() const | Object | [inline]
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
MapElement() | MapElement |
MapElement(const MapElement &rhs) | MapElement |
MapObject(void) | MapObject | [protected]
MapObject(const MapObject &rhs) | MapObject | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Object &rhs) | Object | [protected]
pickMap(int x, int y) const | MapElement | [virtual]
setAnnotation(const std::string &anno) | Object |
setMap(TextureImageHandle *img) | MapElement |
setName(const std::string &name) | Object |
setPosition(int x, int y) | MapObject | [inline]
setRelation(MapRelation relation) | MapObject | [inline]
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~MapElement() | MapElement | [virtual]
~MapObject(void) | MapObject | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:09 2008 for NVSGSDK by NVIDIA


MapList Class Reference

Class to hold a list of two-dimensional maps. More...

#include <MapList.h>

Inheritance diagram for MapList:

[legend]
Collaboration diagram for MapList:

[legend]
List of all members.

Public Member Functions

NVSG_API | MapList ()
Constructs an empty MapList.

NVSG_API | MapList (const MapList &rhs)
Copy-Constructs a MapList from another MapList.

virtual NVSG_API | ~MapList (void)
Destructs a MapList.

NVSG_API unsigned int | getNumberOfMapObjects (void) const
Get the number of MapObject objects in this MapList.

NVSG_API MapObjectHandle * | getMapObject (unsigned int index) const
Get a pointer to the constant MapObject at the specified index.

NVSG_API void | addMapObject (MapObjectHandle *mo)
Add a MapObject to the end of the MapList.

NVSG_API void | insertMapObject (unsigned int index, MapObjectHandle *mo)
Insert a MapObject in front of the specified index.

NVSG_API void | replaceMapObject (unsigned int index, MapObjectHandle *mo)
Replace the MapObject at the specified index.

NVSG_API void | removeMapObject (unsigned int index)
Remove the MapObject at the specified index.

NVSG_API void | clear (void)
Clear the MapList.

NVSG_API TextureImageHandle * | pickMap (int x, int y, unsigned int *index=NULL) const
Get the image located at the specified raster position.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

Detailed Description

Class to hold a list of two-dimensional maps.

Namespace: nvsg
Remarks:
A MapList is used in a ViewState to hold a list of two-dimensional maps. These maps are displayed on top of the scene. They can be, for example, some information overlay or type of menus.
The MapList holds a list of MapObject objects. A MapObject can be a MapElement, holding a single Map; a MapArray, holding a row or column of Map objects; or a MapMatrix, holding a matrix of Map objects.
The MapObject objects are positioned in the viewport by raster coordinates.
See also:
Map, MapArray, MapElement, MapObject, MapMatrix

Constructor & Destructor Documentation

NVSG_API MapList ( )

Constructs an empty MapList.

NVSG_API MapList ( const MapList & rhs )

Copy-Constructs a MapList from another MapList.

virtual NVSG_API ~MapList ( void ) [virtual]

Destructs a MapList.

Member Function Documentation

unsigned int getNumberOfMapObjects ( void ) const [inline]

Get the number of MapObject objects in this MapList.

Returns:
The number of contained MapObject objects.
See also:
addMapObject, getMapObject

MapObjectHandle * getMapObject ( unsigned int index ) const [inline]

Get a pointer to the constant MapObject at the specified index.

Parameters:
index Index of the MapObject to get.
Returns:
A pointer to the constant MapObject at the specified index in the MapList.
Note:
The behavior is undefined if index is larger than or equal to the number of MapObject objects in this MapList.
See also:
addMapObject, getNumberOfMapObjects, pickMap

void addMapObject ( MapObjectHandle * mo ) [inline]

Add a MapObject to the end of the MapList.

Parameters:
mo A pointer to the constant MapObject to add
Remarks:
The reference count of mo is increased.
See also:
getMapObject, getNumberOfMapObjects, insertMapObject

void insertMapObject | ( | unsigned int | index,
 |  | MapObjectHandle * | mo
 | ) | [inline]

Insert a MapObject in front of the specified index.

Parameters:
index | Index to insert a MapObject before.
mo | A pointer to the constant MapObject to insert.
Remarks:
The reference count of mo is incremented.
Note:
The behavior is undefined if index is larger than or equal to the number of MapObject objects in this MapList.
See also:
addMapObject, getMapObject, getNumberOfMapObjects

void replaceMapObject | ( | unsigned int | index,
 |  | MapObjectHandle * | mo
 | ) | [inline]

Replace the MapObject at the specified index.

Parameters:
index | Index to determine where to replace the MapObject.
mo | A pointer to the constant MapObject to replace with.
Remarks:
The reference count of mo is incremented, and the reference count of the MapObject previously at index index is decremented.
Note:
The behavior is undefined if index is larger than or equal to the number of MapObject objects in this MapList.
See also:
addMapObject, getMapObject, getNumberOfMapObjects, removeMapObject

void removeMapObject ( unsigned int index ) [inline]

Remove the MapObject at the specified index.

Parameters:
index Index to determine where to remove the MapObjec.
Remarks:
The reference count of the MapObject at index index is decremented.
Note:
The behavior is undefined if index is larger than or equal to the number of MapObject objects in this MapList.
See also:
addMapObject, getMapObject, getNumberOfMapObjects, replaceMapObject

NVSG_API void clear ( void )

Clear the MapList.

Remarks:
The reference count of every MapObject in this MapList is decremented, and the list is cleared.
See also:
addMapObject, getNumberOfMapObjects, removeMapObject

NVSG_API TextureImageHandle* pickMap | ( | int | x,
 |  | int | y,
 |  | unsigned int * | index = NULL
 | ) | const

Get the image located at the specified raster position.

Parameters:
x | Horizontal raster coordinate to use for getting the image
y | Vertical raster coordinate to use for getting the image.
index | Optional pointer to get the index of the MapObject that holds the picked image.
Returns:
A pointer to the TextureImageHandle specifying the Map at the specified raster position, or NULL if no image was found at that position. If an image is picked and index is not NULL, it returns the index of the MapObject holding the picked image.
Remarks:
This function determines the image of this MapList at the specified raster position (x, y), if any. It asks each of its MapObjects if it has an image at the specified position, and if so, that image is returned. If index is not NULL, the index of the MapObject holding that image is returned there, too.
See also:
getMapObject, getNumberOfMapObjects

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and it is marked as invalid. Then it is validated and the Incarnation of all its Map objects is requested to continue validation down the tree hierarchy. Incarnation

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • MapList.h
Generated on Tue Jan 15 10:29:09 2008 for NVSGSDK by NVIDIA


Member List

MapList Member List

This is the complete list of members for MapList, including all inherited members.
addMapObject(MapObjectHandle *mo) | MapList | [inline]
clear(void) | MapList |
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getMapObject(unsigned int index) const | MapList | [inline]
getName() const | Object |
getNumberOfMapObjects(void) const | MapList | [inline]
getObjectCode() const | Object | [inline]
getUserData() const | Object | [inline]
insertMapObject(unsigned int index, MapObjectHandle *mo) | MapList | [inline]
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
MapList() | MapList |
MapList(const MapList &rhs) | MapList |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Object &rhs) | Object | [protected]
pickMap(int x, int y, unsigned int *index=NULL) const | MapList |
removeMapObject(unsigned int index) | MapList | [inline]
replaceMapObject(unsigned int index, MapObjectHandle *mo) | MapList | [inline]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | MapList | [virtual]
~MapList(void) | MapList | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:09 2008 for NVSGSDK by NVIDIA


MapMatrix Class Reference

Class to hold a matrix of Map objects. More...

#include <MapMatrix.h>

Inheritance diagram for MapMatrix:

[legend]
Collaboration diagram for MapMatrix:

[legend]
List of all members.

Public Member Functions

NVSG_API | MapMatrix (void)
Default-constructs a MapMatrix.

NVSG_API | MapMatrix (const MapMatrix &rhs)
Copy-constructs a MapMatrix.

virtual NVSG_API | ~MapMatrix (void)
Destructs a MapMatrix.

NVSG_API MapAlignment | getAlignment (MapOrientation orientation) const
Get the alignment of the MapMatrix along the orientation.

NVSG_API void | setAlignment (MapOrientation orientation, MapAlignment alignment)
Set the alignment of the MapMatrix along the orientation.

NVSG_API unsigned int | getSpacing (MapOrientation orientation) const
Get the spacing between consecutive Map objects along the orientation.

NVSG_API void | setSpacing (MapOrientation orientation, unsigned int spacing)
Set the spacing between consecutive Map objects.

NVSG_API MapTraversalDirection | getTraversalDirection (MapOrientation orientation) const
Get the traversal direction of the MapMatrix along the orientation.

NVSG_API void | setTraversalDirection (MapOrientation orientation, MapTraversalDirection direction)
Set the traversal direction of the MapMatrix along the orientation.

NVSG_API unsigned int | getNumberOfColumns (void) const
Get the number of columns of Map objects.

NVSG_API void | addEmptyColumn (void)
Add an empty column of Map objects as the last column.

NVSG_API void | insertEmptyColumn (unsigned int col)
Insert an empty column of Map objects in front of column col.

NVSG_API void | removeColumn (unsigned int col)
Remove the column col of Map objects.

NVSG_API unsigned int | getNumberOfMaps (unsigned int col) const
Get the number of Map objects in the column col.

NVSG_API TextureImageHandle * | getMap (unsigned int col, unsigned int row) const
Get a pointer to the image at the specified position.

NVSG_API bool | getIndexOfMap (TextureImageHandle *img, unsigned int &col, unsigned int &row) const
Get the index of an image in this MapMatrix.

NVSG_API void | addMap (unsigned int col, TextureImageHandle *img)
Add an image at the end of the column col.

NVSG_API void | insertMap (unsigned int col, unsigned int row, TextureImageHandle *map)
Insert an image in the column col in front of index row.

NVSG_API void | replaceMap (unsigned int col, unsigned int row, TextureImageHandle *img)
Replace the image in the column col at index row.

NVSG_API void | removeMap (unsigned int col, unsigned int row)
Remove the Map in the column col at index row.

NVSG_API void | getEntrySize (unsigned int &width, unsigned int &height) const
Get the maximal width and height of the Map objects.

virtual NVSG_API void | getSize (unsigned int &width, unsigned int &height) const
Get the overall size of the MapMatrix.

virtual NVSG_API TextureImageHandle * | pickMap (int x, int y) const
Get the image located at the specified raster position.

Detailed Description

Class to hold a matrix of Map objects.

Namespace: nvsg
Remarks:
This class is used to add a matrix of Map objects to a MapList. Each Map is positioned in a raster field, with each field as large as the largest Map in the MapMatrix. The Map objects can be aligned along a common base, a center, or a top line. The traversal direction can be from the lower to the higher index, or vice versa. A spacing can be determined to be between each of the Map objects.
The MapMatrix is organized as a row of columns, where each column can have a different number of entries.
See also:
Map, MapElement, MapList, MapMatrix

Constructor & Destructor Documentation

NVSG_API MapMatrix ( void )

Default-constructs a MapMatrix.

Remarks:
The MapMatrix initially is aligned to the lower base line (MA_LOWER), has a spacing of 1 pixel, and will be traversed from low index to high index (MTD_LOW_TO_HIGH).

NVSG_API MapMatrix ( const MapMatrix & rhs )

Copy-constructs a MapMatrix.

Parameters:
rhs Source MapMatrix.

virtual NVSG_API ~MapMatrix ( void ) [virtual]

Destructs a MapMatrix.

Member Function Documentation

MapAlignment getAlignment ( MapOrientation orientation ) const [inline]

Get the alignment of the MapMatrix along the orientation.

Parameters:
orientation The MapOrientation to get the alignment for.
Returns:
The MapAlignment of the Map objects in the MapOrienation orientation.
Remarks:
If the Map objects of the MapMatrix have different sizes, they can be aligned along their lower (MA_LOWER), center (MA_CENTER), or upper (MA_UPPER) coordinate. The default is MA_LOWER.
Example
If the Map objects have different heights, they can have a common base line (MA_LOWER), a common center line (MA_CENTER), or a common top line (MA_UPPER).
If the Map objects have different widths, they can have a common left margin (MA_LOWER), a common center line (MA_CENTER), or a common right margin (MA_UPPER).
See also:
setAlignment

void setAlignment | ( | MapOrientation | orientation,
 |  | MapAlignment | alignment
 | ) | [inline]

Set the alignment of the MapMatrix along the orientation.

Parameters:
orientation | The MapOrientation along which to set the alignment.
alignment | The MapAlignment of the Map objects along the MapOrientation orientation.
Remarks:
If the Map objects of the MapMatrix have different sizes, they can be aligned along their lower (MA_LOWER), center (MA_CENTER), or upper (MA_UPPER) coordinate. The default is MA_LOWER.
Example
If the Map objects have different heights, they can have a common base line (MA_LOWER), a common center line (MA_CENTER), or a common top line (MA_UPPER).
If the Map objects have different widths, they can have a common left margin (MA_LOWER), a common center line (MA_CENTER), or a common right margin (MA_UPPER).
See also:
getAlignment

unsigned int getSpacing ( MapOrientation orientation ) const [inline]

Get the spacing between consecutive Map objects along the orientation.

Parameters:
orientation The MapOrientation to use to get the spacing.
Returns:
The spacing between consecutive Map objects in the MapOrientation orientation.
Remarks:
Between each Map of the MapMatrix, there can be some open space left. Each direction can have a different spacing, but between each Map, then, the spacing is equal. The default is one in both directions.
See also:
setSpacing

void setSpacing | ( | MapOrientation | orientation,
 |  | unsigned int | spacing
 | ) | [inline]

Set the spacing between consecutive Map objects.

Parameters:
orientation | The MapOrientation to use when setting the spacing.
spacing | The spacing between consecutive Map objects.
Remarks:
Between each Map of the MapMatrix, there can be some open space left. Each direction can have a different spacing, but between each Map, then, the spacing is equal. The default is one in both directions.
See also:
getSpacing

MapTraversalDirection getTraversalDirection ( MapOrientation orientation ) const [inline]

Get the traversal direction of the MapMatrix along the orientation.

Parameters:
orientation The MapOrientation to use for getting the traversal direction.
Returns:
The MapTraversalDirection of the MapMatrix in the MapOrientation orientation.
Remarks:
The Map objects of the MapMatrix can be traversed either from lower to higher index (MTD_LOW_TO_HIGH) or from higher to lower index (MTD_HIGH_TO_LOW), independently in both orientations. The default is MTD_LOW_TO_HIGH in both orientations.
Example
If the traversal direction for the orientation MO_VERTICAL is MTD_LOW_TO_HIGH, in each column of the MapMatrix, the Map with index 0 is drawn at the bottom, the Map with index 1 is drawn above, and so on.
See also:
getAlignment, setTraversalDirection

void setTraversalDirection | ( | MapOrientation | orientation,
 |  | MapTraversalDirection | direction
 | ) | [inline]

Set the traversal direction of the MapMatrix along the orientation.

Parameters:
orientation | The MapOrientation to use for setting the traversal direction.
direction | The MapTraversalDirection of the MapMatrix in the MapOrientation orientation.
Remarks:
The Map objects of the MapMatrix can be traversed either from lower to higher index (MTD_LOW_TO_HIGH) or from higher to lower index (MTD_HIGH_TO_LOW), independently in both orientations. The default is MTD_LOW_TO_HIGH in both orientations.
Example
If the traversal direction for the orientation MO_VERTICAL is MTD_LOW_TO_HIGH, in each column of the MapMatrix, the Map with index 0 is drawn at the bottom, the Map with index 1 is drawn above, and so on.
See also:
getTraversalDirection, setAlignment

unsigned int getNumberOfColumns ( void ) const [inline]

Get the number of columns of Map objects.

Returns:
The number of columns of Map objects.
See also:
addEmptyColumn, insertEmptyColumn, removeColumn

void addEmptyColumn ( void ) [inline]

Add an empty column of Map objects as the last column.

See also:
addMap, getNumberOfColumns, insertEmptyColumn, removeColumn

void insertEmptyColumn ( unsigned int col ) [inline]

Insert an empty column of Map objects in front of column col.

Parameters:
col Index to insert an empty column of Map objects before.
Note:
The behavior is undefined if col is larger than or equal to the current number of columns.
See also:
addEmptyColumn, addMap, getNumberOfColumns, removeColumn

NVSG_API void removeColumn ( unsigned int col )

Remove the column col of Map objects.

Parameters:
col Index of column of Map objects to remove.
Note:
The behavior is undefined if col is larger than or equal to the current number of columns.
See also:
addEmptyColumn, getNumberOfColumns, insertEmptyColumn

unsigned int getNumberOfMaps ( unsigned int col ) const [inline]

Get the number of Map objects in the column col.

Parameters:
col Index of the column to use to get the number of Map objects.
Returns:
The number of Map objects in the column col.
See also:
addMap, getMap, getNumberOfColumns, insertMap

TextureImageHandle * getMap | ( | unsigned int | col,
 |  | unsigned int | row
 | ) | const [inline]

Get a pointer to the image at the specified position.

Parameters:
col | Index of the column.
row | Index of the row in column col.
Returns:
A pointer to the image at the specified position.
Note:
The behavior is undefined if col is larger than or equal to the number of columns, or if row is larger than or equal to the number of images in the column col.
See also:
addMap, getIndexOfMap, getNumberOfColumns, getNumberOfMaps, pickMap

NVSG_API bool getIndexOfMap | ( | TextureImageHandle * | img,
 |  | unsigned int & | col,
 |  | unsigned int & | row
 | ) | const

Get the index of an image in this MapMatrix.

Parameters:
img | A pointer to the image to use for getting the index.
col | A reference to get the column, where img is in.
row | A reference to get the row, where img is in.
Returns:
true, if img is part of this MapMatrix, otherwise false.
See also:
getMap, getNumberOfColumns, getNumberOfMaps, pickMap

void addMap | ( | unsigned int | col,
 |  | TextureImageHandle * | img
 | ) | [inline]

Add an image at the end of the column col.

Parameters:
col | Index of the column to add the Map to.
img | A pointer to the image to add.
Remarks:
The reference count of img is increased.
Note:
The behavior is undefined if col is larger than or equal to the number of columns.
See also:
getNumberOfColumns, getNumberOfMaps, insertMap, removeMap, replaceMap

void insertMap | ( | unsigned int | col,
 |  | unsigned int | row,
 |  | TextureImageHandle * | map
 | ) | [inline]

Insert an image in the column col in front of index row.

Parameters:
col | Index of the column to insert the image into.
row | Index of the row in the column col to insert the image before.
map | A pointer to the image to insert.
Remarks:
The reference count of img is increased.
Note:
The behavior is undefined if col is larger than or equal to the number of columns, or if row is larger than or equal to the number of images in the column col.
See also:
addMap, getNumberOfColumns, getNumberOfMaps, removeMap, replaceMap

void replaceMap | ( | unsigned int | col,
 |  | unsigned int | row,
 |  | TextureImageHandle * | img
 | ) | [inline]

Replace the image in the column col at index row.

Parameters:
col | Index of the column to replace the image in.
row | Index of the row in the column col to replace the image at.
img | A pointer to the image to replace with.
Remarks:
The reference count of img is incremented, and the reference count of the image previously at column col, row row, is decremented.
Note:
The behavior is undefined if col is larger than or equal to the number of columns, or if row is larger than or equal to the number of images in the column col.
See also:
addMap, getNumberOfColumns, getNumberOfMaps, insertMap, removeMap

void removeMap | ( | unsigned int | col,
 |  | unsigned int | row
 | ) | [inline]

Remove the Map in the column col at index row.

Parameters:
col | Index of the column to remove the Map in.
row | Index of the row in the column col to remove the Map at.
Note:
The behavior is undefined if col is larger than or equal to the number of columns, or if row is larger than or equal to the number of Map objects in the column col.
See also:
addMap, getNumberOfColumns, getNumberOfMaps, insertMap, replaceMap

NVSG_API void getEntrySize | ( | unsigned int & | width,
 |  | unsigned int & | height
 | ) | const

Get the maximal width and height of the Map objects.

Parameters:
width | Reference to the maximal width, in pixels, to get.
height | Reference to the maximal height, in pixels, to get.
Remarks:
The entry size is the width and height of the matrix cells, in pixels, where each Map fits in. It is the maximal width and maximal height of all the Map objects.
See also:
getSize

virtual NVSG_API void getSize | ( | unsigned int & | width,
 |  | unsigned int & | height
 | ) | const [virtual]

Get the overall size of the MapMatrix.

Parameters:
width | Reference to the overall width, in pixels, to get.
height | Reference to the overall height, in pixels, to get.
Remarks:
The overall size of a MapMatrix is the size, in pixels, the complete MapMatrix has. The overall width is the maximal width of the Map objects times the number of columns, plus the horizontal spacing between each of these. The overall height is the maximal height of the Map objects times the maximal number of rows of all columns, plus the vertical spacing between each of these.
See also:
getEntrySize, getNumberOfColumns, getNumberOfMaps

Implements MapObject.

virtual NVSG_API TextureImageHandle* pickMap | ( | int | x,
 |  | int | y
 | ) | const [virtual]

Get the image located at the specified raster position.

Parameters:
x | Horizontal raster coordinate to use for getting the image.
y | Vertical raster coordinate to use for getting the image.
Returns:
A pointer to the image located at the specified raster position, or NULL if there is none.
Remarks:
This function determines the image of this MapMatrix at the specified raster position (x, y), if any. It takes into account the position, alignment, direction, and spacing. Each image is considered to be the size of the largest image in this MapMatrix. If the position is in the spacing between two images, or outside of the overall size of the MapMatrix, NULL is returned.
See also:
getEntrySize, getSize, getMap

Implements MapObject.

The documentation for this class was generated from the following file:
  • MapMatrix.h
Generated on Tue Jan 15 10:29:09 2008 for NVSGSDK by NVIDIA


Member List

MapMatrix Member List

This is the complete list of members for MapMatrix, including all inherited members.
addEmptyColumn(void) | MapMatrix | [inline]
addMap(unsigned int col, TextureImageHandle *img) | MapMatrix | [inline]
enterCS() const | Object | [inline, protected]
getAlignment(MapOrientation orientation) const | MapMatrix | [inline]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getEntrySize(unsigned int &width, unsigned int &height) const | MapMatrix |
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIndexOfMap(TextureImageHandle *img, unsigned int &col, unsigned int &row) const | MapMatrix |
getLowerLeft(int &x, int &y) const | MapObject |
getMap(unsigned int col, unsigned int row) const | MapMatrix | [inline]
getName() const | Object |
getNumberOfColumns(void) const | MapMatrix | [inline]
getNumberOfMaps(unsigned int col) const | MapMatrix | [inline]
getObjectCode() const | Object | [inline]
getPosition(int &x, int &y) const | MapObject | [inline]
getRelation(void) const | MapObject | [inline]
getSize(unsigned int &width, unsigned int &height) const | MapMatrix | [virtual]
getSpacing(MapOrientation orientation) const | MapMatrix | [inline]
getTraversalDirection(MapOrientation orientation) const | MapMatrix | [inline]
getUserData() const | Object | [inline]
insertEmptyColumn(unsigned int col) | MapMatrix | [inline]
insertMap(unsigned int col, unsigned int row, TextureImageHandle *map) | MapMatrix | [inline]
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
MapMatrix(void) | MapMatrix |
MapMatrix(const MapMatrix &rhs) | MapMatrix |
MapObject(void) | MapObject | [protected]
MapObject(const MapObject &rhs) | MapObject | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Object &rhs) | Object | [protected]
pickMap(int x, int y) const | MapMatrix | [virtual]
removeColumn(unsigned int col) | MapMatrix |
removeMap(unsigned int col, unsigned int row) | MapMatrix | [inline]
replaceMap(unsigned int col, unsigned int row, TextureImageHandle *img) | MapMatrix | [inline]
setAlignment(MapOrientation orientation, MapAlignment alignment) | MapMatrix | [inline]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setPosition(int x, int y) | MapObject | [inline]
setRelation(MapRelation relation) | MapObject | [inline]
setSpacing(MapOrientation orientation, unsigned int spacing) | MapMatrix | [inline]
setTraversalDirection(MapOrientation orientation, MapTraversalDirection direction) | MapMatrix | [inline]
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~MapMatrix(void) | MapMatrix | [virtual]
~MapObject(void) | MapObject | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:09 2008 for NVSGSDK by NVIDIA


MapObject Class Reference

Abstract base class to position one or more Map objects. More...

#include <MapObject.h>

Inheritance diagram for MapObject:

[legend]
Collaboration diagram for MapObject:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~MapObject (void)
Destructs a MapObject.

NVSG_API void | getPosition (int &x, int &y) const
Get the raster position.

NVSG_API void | setPosition (int x, int y)
Set the raster position.

NVSG_API MapRelation | getRelation (void) const
Get the relation of the MapObject.

NVSG_API void | setRelation (MapRelation relation)
Set the relation of the MapObject.

NVSG_API void | getLowerLeft (int &x, int &y) const
Get the lower left position of the MapObject.

virtual NVSG_API void | getSize (unsigned int &width, unsigned int &height) const=0
Interface to get the overall size of the MapObject.

virtual NVSG_API TextureImageHandle * | pickMap (int x, int y) const=0
Interface to get an image at a specified raster position.

Protected Member Functions

NVSG_API | MapObject (void)
Protected default constructor to prevent explicit creation.

NVSG_API | MapObject (const MapObject &rhs)
Protected copy constructor to prevent explicit creation.

Detailed Description

Abstract base class to position one or more Map objects.

Namespace: nvsg
Remarks:
The position of a MapObject is given in raster coordinates, relative to the lower left corner of the viewport. The MapRelation determines which point of the MapObject corresponds to that position.
The default position is the origin (0,0) with a MapRelation of MR_LOWER_LEFT.
See also:
MapArray, MapElement, MapMatrix

Constructor & Destructor Documentation

virtual NVSG_API ~MapObject ( void ) [virtual]

Destructs a MapObject.

NVSG_API MapObject ( void ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
The default setting for a MapObject are:
  • MapRelation to lower left (MR_LOWER_LEFT)
  • position at the origin (0,0).

NVSG_API MapObject ( const MapObject & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Remarks:
The MapRelation and position is copied over from rhs.

Member Function Documentation

void getPosition | ( | int & | x,
 |  | int & | y
 | ) | const [inline]

Get the raster position.

Parameters:
x | A reference to the x-coordinate to get.
y | A reference to the y-coordinate to get.
Remarks:
The position of the MapObject is the raster position relative to the lower left corner of the viewport. The point of the MapObject which corresponds to the position is defined by the MapRelation.
The default position is the origin (0,0).
See also:
getMapRelation, setPosition

void setPosition | ( | int | x,
 |  | int | y
 | ) | [inline]

Set the raster position.

Parameters:
x | The x-coordinate of the raster position.
y | The y-coordinate of the raster position.
Remarks:
The position of the MapObject is the raster position relative to the lower left corner of the viewport. The point of the MapObject which corresponds to the position is defined by the MapRelation.
The default position is the origin (0,0).
See also:
getPosition, setMapReleation

MapRelation getRelation ( void ) const [inline]

Get the relation of the MapObject.

Returns:
The MapRelation of the MapObject.
Remarks:
The MapRelation describes which point of the MapObject is used as the position.
The default MapRelation is MR_LOWER_LEFT.
Example
If the MapRelation is MR_LOWER_LEFT, the lower left corner of the MapObject corresponds to the position; that is, the MapObject is displayed to the upper right of the position.
If the MapRelation is MR_UPPER_RIGHT, the upper right corner of the MapObject corresponds to the position; that is, the MapObject is displayed below and to the left of the position.
See also:
getPosition, setRelation

void setRelation ( MapRelation relation ) [inline]

Set the relation of the MapObject.

Parameters:
relation The MapRelation of the MapObject to set.
Remarks:
The MapRelation describes which point of the MapObject is used as the position.
The default MapRelation is MR_LOWER_LEFT.
Example
If the MapRelation is MR_LOWER_LEFT, the lower left corner of the MapObject corresponds to the position; that is, the MapObject is displayed to the upper right of the position.
If the MapRelation is MR_UPPER_RIGHT, the upper right corner of the MapObject corresponds to the position; that is, the MapObject is displayed below and to the left of the position.
See also:
getRelation, setPosition

NVSG_API void getLowerLeft | ( | int & | x,
 |  | int & | y
 | ) | const

Get the lower left position of the MapObject.

Parameters:
x | A reference to the x-coordinate to get.
y | A reference to the y-coordinate to get.
Remarks:
The lower left position of the MapObject is calculated from its position, the MapRelation (describing the relative point of the MapObject corresponding to that position), and the Map objects with the heights, widths, and spacings.
Example
If the MapRelation is MR_LOWER_LEFT (the default), the lower left position equals the position of the MapObject.
If the MapRelation is MR_CENTER, the lower left position is half the width of the MapObject to the left, and half the height to below it's position.
See also:
getPosition, getRelation

virtual NVSG_API void getSize | ( | unsigned int & | width,
 |  | unsigned int & | height
 | ) | const [pure virtual]

Interface to get the overall size of the MapObject.

Parameters:
width | Reference to the overall width, in pixels, to get.
height | Reference to the overall height, in pixels, to get.
Remarks:
If the MapObject just holds one Map, the size is the size of the Map. If it holds more than one Map and/or does some special alignment or other operations on its Map objects, the size is the overall size of these Map objects after any alignment or other operations have been applied to the Map objects.
See also:
getLowerLeft, getPosition

Implemented in MapArray, MapElement, and MapMatrix.

virtual NVSG_API TextureImageHandle* pickMap | ( | int | x,
 |  | int | y
 | ) | const [pure virtual]

Interface to get an image at a specified raster position.

Parameters:
x | Horizontal raster coordinate for the image to get.
y | Vertical raster coordinate for the image to get.
Returns:
A pointer to a TextureImageHandle specifying the image at the specified raster position, or NULL if no image was found at that position.

Implemented in MapArray, MapElement, and MapMatrix.

The documentation for this class was generated from the following file:
  • MapObject.h
Generated on Tue Jan 15 10:29:09 2008 for NVSGSDK by NVIDIA


Member List

MapObject Member List

This is the complete list of members for MapObject, including all inherited members.
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLowerLeft(int &x, int &y) const | MapObject |
getName() const | Object |
getObjectCode() const | Object | [inline]
getPosition(int &x, int &y) const | MapObject | [inline]
getRelation(void) const | MapObject | [inline]
getSize(unsigned int &width, unsigned int &height) const=0 | MapObject | [pure virtual]
getUserData() const | Object | [inline]
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
MapObject(void) | MapObject | [protected]
MapObject(const MapObject &rhs) | MapObject | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Object &rhs) | Object | [protected]
pickMap(int x, int y) const=0 | MapObject | [pure virtual]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setPosition(int x, int y) | MapObject | [inline]
setRelation(MapRelation relation) | MapObject | [inline]
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~MapObject(void) | MapObject | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:09 2008 for NVSGSDK by NVIDIA


Material Class Reference

StateAttribute that describes material properties. More...

#include <Material.h>

Inheritance diagram for Material:

[legend]
Collaboration diagram for Material:

[legend]
List of all members.

Public Member Functions

NVSG_API | Material ()
Default-constructs a Material.

NVSG_API | Material (const StateAttribute &rhs)
Constructs a Material from a StateAttribute.

NVSG_API | Material (const Material &rhs)
Constructs a Material as a copy from another Material.

virtual NVSG_API | ~Material ()
Destructs a Material.

virtual NVSG_API bool | isDataShared () const
Query whether the data of this Material is shared with other Material objects.

virtual NVSG_API DataID | getDataID () const
Get the unique data identifier of this object.

NVSG_API const nvmath::Vec3f & | getAmbientColor (MaterialFace mf=MF_FRONT) const
Get the ambient color.

NVSG_API void | setAmbientColor (const nvmath::Vec3f &ac, MaterialFace mf=MF_FRONT_AND_BACK)
Set the ambient color.

NVSG_API const nvmath::Vec3f & | getDiffuseColor (MaterialFace mf=MF_FRONT) const
Get the diffuse color.

NVSG_API void | setDiffuseColor (const nvmath::Vec3f &dc, MaterialFace mf=MF_FRONT_AND_BACK)
Set the diffuse color.

NVSG_API const nvmath::Vec3f & | getEmissiveColor (MaterialFace mf=MF_FRONT) const
Get the emissive color.

NVSG_API void | setEmissiveColor (const nvmath::Vec3f &ec, MaterialFace mf=MF_FRONT_AND_BACK)
Set the emissive color.

NVSG_API float | getOpacity (MaterialFace mf=MF_FRONT) const
Get the opacity.

NVSG_API void | setOpacity (float o, MaterialFace mf=MF_FRONT_AND_BACK)
Set the opacity.

NVSG_API const nvmath::Vec3f & | getSpecularColor (MaterialFace mf=MF_FRONT) const
Get the specular color.

NVSG_API void | setSpecularColor (const nvmath::Vec3f &sc, MaterialFace mf=MF_FRONT_AND_BACK)
Set the specular color.

NVSG_API float | getSpecularExponent (MaterialFace mf=MF_FRONT) const
Get the specular exponent.

NVSG_API void | setSpecularExponent (float se, MaterialFace mf=MF_FRONT_AND_BACK)
Set the specular exponent.

NVSG_API Material & | operator= (const Material &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other Material.

Detailed Description

StateAttribute that describes material properties.

Namespace: nvsg
Remarks:
A Material describes the color properties of a geometry. The properties for front and back faces can be described independently. The following are the default values that Material uses for both front and back faces:
  • ambient color is dark grey (0.3,0.3,0.3)
  • diffuse color is light grey (0.9,0.9,0.9)
  • emissive color is black (0.0,0.0,0.0)
  • opacity is opaque 1.0
  • specular color is light grey (0.9,0.9,0.9)
  • specular exponent is medium 10.0
See also:
StateAttribute

Constructor & Destructor Documentation

NVSG_API Material ( )

Default-constructs a Material.

NVSG_API Material ( const StateAttribute & rhs ) [explicit]

Constructs a Material from a StateAttribute.

NVSG_API Material ( const Material & rhs )

Constructs a Material as a copy from another Material.

virtual NVSG_API ~Material ( ) [virtual]

Destructs a Material.

Member Function Documentation

virtual NVSG_API bool isDataShared ( ) const [virtual]

Query whether the data of this Material is shared with other Material objects.

Returns:
true, if the data of this Material is shared with other Material objects, otherwise false.
Remarks:
A Material object shares its data with another Material object if it was either instantiated as a copy of the other, using Material::clone, or if it was assigned to by the other object using the assignment operator. In that case, the two objects have the same DataID.
See also:
clone, getDataID, operator=()

Reimplemented from Object.

virtual NVSG_API DataID getDataID ( ) const [virtual]

Get the unique data identifier of this object.

Returns:
A 64-bit value that uniquely identifies the embedded data.
Remarks:
A Material object shares its data with another Material object if it was either instantiated as a copy of the other, using Material::clone, or if it was assigned to by the other object using the assignment operator. In that case, the two objects have the same DataID.
See also:
clone, isDataShared, operator=()

Reimplemented from Object.

const nvmath::Vec3f & getAmbientColor ( MaterialFace mf = MF_FRONT ) const [inline]

Get the ambient color.

Parameters:
mf Optional identifier to select front face (MF_FRONT) or back face (MF_BACK) ambient color. The default is MF_FRONT.
Returns:
A reference to the constant ambient color.
Remarks:
Ambient reflection, like ambient light, is nondirectional. Ambient reflection has a lesser impact on the apparent color of a rendered object, but it does affect the overall color and is most noticeable when little or no diffuse light reflects off the material. A material's ambient reflection is affected by the ambient light set for a scene. The default is dark grey (0.3,0.3,0.3).
Note:
The behaviour is undefined, if MF_FRONT_AND_BACK is used as the MaterialFace mf.
See also:
getDiffuseColor, getEmissiveColor, getSpecularColor, setAmbientColor

NVSG_API void setAmbientColor | ( | const nvmath::Vec3f & | ac,
 |  | MaterialFace | mf = MF_FRONT_AND_BACK
 | ) |

Set the ambient color.

Parameters:
ac | A reference to the constant color to set as ambient.
mf | Optional identifier to select front face (MF_FRONT), back face (FM_BACK) or both (MF_FRONT_AND_BACK) to set. The default is MF_FRONT_AND_BACK.
Remarks:
Ambient reflection, like ambient light, is nondirectional. Ambient reflection has a lesser impact on the apparent color of a rendered object, but it does affect the overall color and is most noticeable when little or no diffuse light reflects off the material. A material's ambient reflection is affected by the ambient light set for a scene. The default is dark grey (0.3,0.3,0.3).
See also:
getAmbientColor, setDiffuseColor, setEmissiveColor, setSpecularColor

const nvmath::Vec3f & getDiffuseColor ( MaterialFace mf = MF_FRONT ) const [inline]

Get the diffuse color.

Parameters:
mf Optional identifier to select front face (MF_FRONT) or back face (MF_BACK) diffuse color. The default is MF_FRONT.
Returns:
A reference to the constant diffuse color.
Remarks:
The diffuse and ambient colors of a material describe how a material reflects the ambient and diffuse light in a scene. Because most scenes contain much more diffuse light than ambient light, diffuse reflection plays the largest role in determining color. Additionally, because diffuse light is directional, the angle of incidence for diffuse light affects the overall intensity of the reflection. Diffuse reflection is greatest when the light strikes a vertex parallel to the vertex normal. As the angle increases, the effect of diffuse reflection diminishes. The amount of light reflected is the cosine of the angle between the incoming light and the vertex normal. The default is light grey (0.9,0.9,0.9).
Note:
The behavior is undefined if MF_FRONT_AND_BACK is used as the MaterialFace mf.
See also:
getAmbientColor, getEmissiveColor, getSpecularColor, setDiffuseColor

NVSG_API void setDiffuseColor | ( | const nvmath::Vec3f & | dc,
 |  | MaterialFace | mf = MF_FRONT_AND_BACK
 | ) |

Set the diffuse color.

Parameters:
dc | A reference to the constant color to set as diffuse.
mf | Optional identifier to select front face (MF_FRONT), back face (FM_BACK) or both (MF_FRONT_AND_BACK) to set. The default is MF_FRONT_AND_BACK.
Remarks:
The diffuse and ambient colors of a material describe how a material reflects the ambient and diffuse light in a scene. Because most scenes contain much more diffuse light than ambient light, diffuse reflection plays the largest role in determining color. Additionally, because diffuse light is directional, the angle of incidence for diffuse light affects the overall intensity of the reflection. Diffuse reflection is greatest when the light strikes a vertex parallel to the vertex normal. As the angle increases, the effect of diffuse reflection diminishes. The amount of light reflected is the cosine of the angle between the incoming light and the vertex normal. The default is light grey (0.9,0.9,0.9).
See also:
getDiffuseColor, setAmbientColor, setEmissiveColor, setSpecularColor

const nvmath::Vec3f & getEmissiveColor ( MaterialFace mf = MF_FRONT ) const [inline]

Get the emissive color.

Parameters:
mf Optional identifier to select front face (MF_FRONT) or back face (MF_BACK) emissive color. The default is MF_FRONT.
Returns:
A reference to the constant emissive color.
Remarks:
Materials can be used to make a rendered object appear to be self-luminous. The emissive color of a material is used to describe the color of the emitted light. Emission affects an object's color and can, for example, make a dark material brighter and take on part of the emitted color. You can use a material's emissive color to add the illusion that an object is emitting light, without incurring the computational overhead of adding a light to the scene. Remember, materials with emissive color don't emit light that can be reflected by other objects in a scene. To achieve this reflected light, you need to place an additional light within the scene. The default is black (0.0,0.0,0.0).
Note:
The behavior is undefined if MF_FRONT_AND_BACK is used as the MaterialFace mf.
See also:
getAmbientColor, getDiffuseColor, getSpecularColor, setEmissiveColor

NVSG_API void setEmissiveColor | ( | const nvmath::Vec3f & | ec,
 |  | MaterialFace | mf = MF_FRONT_AND_BACK
 | ) |

Set the emissive color.

Parameters:
ec | A reference to the constant color to set as emissive.
mf | Optional identifier to select front face (MF_FRONT), back face (FM_BACK) or both (MF_FRONT_AND_BACK) to set. The default is MF_FRONT_AND_BACK.
Remarks:
Materials can be used to make a rendered object appear to be self-luminous. The emissive color of a material is used to describe the color of the emitted light. Emission affects an object's color, and can, for example, make a dark material brighter and take on part of the emitted color. You can use a material's emissive color to add the illusion that an object is emitting light, without incurring the computational overhead of adding a light to the scene. Remember, materials with emissive color don't emit light that can be reflected by other objects in a scene. To achieve this reflected light, you need to place an additional light within the scene. The default is black (0.0,0.0,0.0).
See also:
getEmissiveColor, setAmbientColor, setDiffuseColor, setSpecularColor

float getOpacity ( MaterialFace mf = MF_FRONT ) const [inline]

Get the opacity.

Parameters:
mf Optional identifier to select front face (MF_FRONT) or back face (MF_BACK) opacity. The default is MF_FRONT.
Returns:
The opacity.
Remarks:
The opacity of a material controls how much light is reflected and how much light goes through. An opacity of 1.0 means the material is completely opaque - all light is reflected and no objects behind shine through. An opacity of 0.0 means the material is completely transparent - no light is reflected and objects behind are seen undisturbed. The default is opaque 1.0.
Note:
The behavior is undefined if MF_FRONT_AND_BACK is used as the MaterialFace mf.
See also:
setOpacity

NVSG_API void setOpacity | ( | float | o,
 |  | MaterialFace | mf = MF_FRONT_AND_BACK
 | ) |

Set the opacity.

Parameters:
o | The opacity to set.
mf | Optional identifier to select front face (MF_FRONT), back face (FM_BACK) or both (MF_FRONT_AND_BACK) to set. The default is MF_FRONT_AND_BACK.
Remarks:
The opacity of a material controls how much light is reflected and how much light goes through. An opacity of 1.0 means the material is completely opaque - all light is reflected and no objects behind shine through. An opacity of 0.0 means the material is completely transparent - no light is reflected and objects behind are seen undisturbed. The default opacity is 1.0 (completely opaque).
See also:
getOpacity

const nvmath::Vec3f & getSpecularColor ( MaterialFace mf = MF_FRONT ) const [inline]

Get the specular color.

Parameters:
mf Optional identifier to select front face (MF_FRONT) or back face (MF_BACK) specular color. The default is MF_FRONT.
Returns:
A reference to the constant specular color.
Remarks:
Specular reflection creates highlights on objects, making them appear shiny. The material contains two members that describe the specular highlight color as well as the material's overall shininess. You establish the color of the specular highlights by setting the specular color to the desired RGBA color — the most common colors are white or light gray. The values you set in the specular exponent control how sharp the specular effects are. The default of the specular color is dark grey (0.9,0.9,0.9).
Note:
The behavior is undefined if MF_FRONT_AND_BACK is used as the MaterialFace mf.
See also:
getAmbientColor, getDiffuseColor, getEmissiveColor, getSpecularExponent, setSpecularColor

NVSG_API void setSpecularColor | ( | const nvmath::Vec3f & | sc,
 |  | MaterialFace | mf = MF_FRONT_AND_BACK
 | ) |

Set the specular color.

Parameters:
sc | A reference to the constant color to set as specular.
mf | Optional identifier to select front face (MF_FRONT), back face (FM_BACK) or both (MF_FRONT_AND_BACK) to set. The default is MF_FRONT_AND_BACK.
Remarks:
Specular reflection creates highlights on objects, making them appear shiny. The material contains two members that describe the specular highlight color as well as the material's overall shininess. You establish the color of the specular highlights by setting the specular color to the desired RGBA color — the most common colors are white or light gray. The values you set in the specular exponent control how sharp the specular effects are. The default of the specular color is dark grey (0.9,0.9,0.9).
See also:
getSpecularColor, setAmbientColor, setDiffuseColor, setEmissiveColor, setSpecularExponent

float getSpecularExponent ( MaterialFace mf = MF_FRONT ) const [inline]

Get the specular exponent.

Parameters:
mf Optional identifier to select front face (MF_FRONT) or back face (MF_BACK) opacity. The default is MF_FRONT.
Returns:
The specular exponent.
Remarks:
Specular reflection creates highlights on objects, making them appear shiny. The material contains two members that describe the specular highlight color as well as the material's overall shininess. You establish the color of the specular highlights by setting the specular color to the desired RGBA color — the most common colors are white or light gray. The values you set in the specular exponent control how sharp the specular effects are. The default of the specular exponent is 10.0.
Note:
The behavior is undefined if MF_FRONT_AND_BACK is used as the MaterialFace mf.
See also:
getSpecularColor, setSpecularExponent

NVSG_API void setSpecularExponent | ( | float | se,
 |  | MaterialFace | mf = MF_FRONT_AND_BACK
 | ) |

Set the specular exponent.

Parameters:
se | The specular exponent to set.
mf | Optional identifier to select front face (MF_FRONT), back face (FM_BACK) or both (MF_FRONT_AND_BACK) to set. The default is MF_FRONT_AND_BACK.
Remarks:
Specular reflection creates highlights on objects, making them appear shiny. The material contains two members that describe the specular highlight color as well as the material's overall shininess. You establish the color of the specular highlights by setting the specular color to the desired RGBA color — the most common colors are white or light gray. The values you set in the specular exponent control how sharp the specular effects are. The default of the specular exponent is 10.0.
See also:
getSpecularExponent, setSpecularColor

NVSG_API Material& operator= ( const Material & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant Material to copy from.
Returns:
A reference to the assigned Material.
Remarks:
The assignment operator calls the assignment operator of StateAttribute and copies all the material properties.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other Material.

Parameters:
p | A reference to the constant Material to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the Material p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as StateAttribute, they are equivalent if all their material properties are equal.
See also:
StateAttribute

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • Material.h
Generated on Tue Jan 15 10:29:10 2008 for NVSGSDK by NVIDIA


Member List

Material Member List

This is the complete list of members for Material, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAmbientColor(MaterialFace mf=MF_FRONT) const | Material | [inline]
getAnnotation() const | Object |
getDataID() const | Material | [virtual]
getDiffuseColor(MaterialFace mf=MF_FRONT) const | Material | [inline]
getEmissiveColor(MaterialFace mf=MF_FRONT) const | Material | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOpacity(MaterialFace mf=MF_FRONT) const | Material | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getSpecularColor(MaterialFace mf=MF_FRONT) const | Material | [inline]
getSpecularExponent(MaterialFace mf=MF_FRONT) const | Material | [inline]
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Material | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Material | [virtual]
isTransparent(void) const | StateAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Material() | Material |
Material(const StateAttribute &rhs) | Material | [explicit]
Material(const Material &rhs) | Material |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Material &rhs) | Material |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAmbientColor(const nvmath::Vec3f &ac, MaterialFace mf=MF_FRONT_AND_BACK) | Material |
setAnnotation(const std::string &anno) | Object |
setDiffuseColor(const nvmath::Vec3f &dc, MaterialFace mf=MF_FRONT_AND_BACK) | Material |
setEmissiveColor(const nvmath::Vec3f &ec, MaterialFace mf=MF_FRONT_AND_BACK) | Material |
setName(const std::string &name) | Object |
setOpacity(float o, MaterialFace mf=MF_FRONT_AND_BACK) | Material |
setSpecularColor(const nvmath::Vec3f &sc, MaterialFace mf=MF_FRONT_AND_BACK) | Material |
setSpecularExponent(float se, MaterialFace mf=MF_FRONT_AND_BACK) | Material |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~Material() | Material | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:10 2008 for NVSGSDK by NVIDIA


TemplateMatnnt class Reference

Matnnt Class Template Reference

Matrix class of fixed size and type. More...

#include <Matnnt.h>

List of all members.

Public Member Functions

Matnnt ()
Default constructor.

template<unsigned int m, typename S> | Matnnt (const Matnnt< m, S > &rhs)
Copy constructor from a matrix of possibly different size and type.

Matnnt (T m00, T m01, T m02, T m10, T m11, T m12, T m20, T m21, T m22)
Constructor for a 3 by 3 matrix out of 9 scalar values.

Matnnt (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1, const Vecnt< n, T > &v2)
Constructor for a 3 by 3 matrix out of three vectors of three values each.

Matnnt (T m00, T m01, T m02, T m03, T m10, T m11, T m12, T m13, T m20, T m21, T m22, T m23, T m30, T m31, T m32, T m33)
Constructor for a 4 by 4 matrix out of 16 scalar values.

Matnnt (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1, const Vecnt< n, T > &v2, const Vecnt< n, T > &v3)
Constructor for a 4 by 4 matrix out of four vectors of four values each.

Matnnt (const Vecnt< n, T > &axis, T angle)
Constructor for a 3 by 3 rotation matrix out of an axis and an angle.

Matnnt (const Quatt< T > &ori)
Constructor for a 3 by 3 rotation matrix out of a normalized quaternion.

Matnnt (const Quatt< T > &ori, const Vecnt< n-1, T > &trans)
Constructor for a 4 by 4 transformation matrix out of a quaternion and a translation.

Matnnt (const Quatt< T > &ori, const Vecnt< n-1, T > &trans, const Vecnt< n-1, T > &scale)
Constructor for a 4 by 4 transformation matrix out of a quaternion, a translation, and a scaling.

const T * | getPtr () const
Get a constant pointer to the n times n values of the matrix.

bool | invert ()
Invert the matrix.

template<typename S> Vecnt< n, T > & | operator[] (S i)
Non-constant subscript operator.

template<typename S> const Vecnt< n, T > & | operator[] (S i) const
Constant subscript operator.

template<typename S> Matnnt< n, T > & | operator+= (const Matnnt< n, S > &m)
Matrix addition and assignment operator.

template<typename S> Matnnt< n, T > & | operator-= (const Matnnt< n, S > &m)
Matrix subtraction and assignment operator.

template<typename S> Matnnt< n, T > & | operator *= (S s)
Scalar multiplication and assignment operator.

Matnnt< n, T > & | operator *= (const Matnnt< n, T > &m)
Matrix multiplication and assignment operator.

template<typename S> Matnnt< n, T > & | operator/= (S s)
Scalar division and assignment operator.

Detailed Description

template<unsigned int n, typename T>
class nvmath::Matnnt< n, T >

Matrix class of fixed size and type.

Remarks:
This class is templated by size and type. It holds n times n values of type T. There are typedefs for the most common usage with 3 and 4 values of type float and double: Mat33f, Mat33d, Mat44f, Mat44d.

Constructor & Destructor Documentation

Matnnt ( ) [inline]

Default constructor.

Remarks:
For performance reasons, no initialization is performed.

Matnnt ( const Matnnt< m, S > & rhs ) [inline, explicit]

Copy constructor from a matrix of possibly different size and type.

Parameters:
rhs A matrix with m times m values of type S.
Remarks:
The minimum k of n and m is determined. The first k values of type S in the first k rows from rhs are converted to type T and assigned as the first k values in the first k rows of this. If k is less than n, the n - k last values of the n - k last rows of this are not initialized.

Matnnt | ( | T | m00,
 |  | T | m01,
 |  | T | m02,
 |  | T | m10,
 |  | T | m11,
 |  | T | m12,
 |  | T | m20,
 |  | T | m21,
 |  | T | m22
 | ) | [inline]

Constructor for a 3 by 3 matrix out of 9 scalar values.

Parameters:
m00 | First element of the first row of the matrix.
m01 | Second element of the first row of the matrix.
m02 | Third element of the first row of the matrix.
m10 | First element of the second row of the matrix.
m11 | Second element of the second row of the matrix.
m12 | Third element of the second row of the matrix.
m20 | First element of the third row of the matrix.
m21 | Second element of the third row of the matrix.
m22 | Third element of the third row of the matrix.
Remarks:
This constructor can only be used with 3 by 3 matrices, like Mat33f.
Example:
    Mat33f m33f( 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f );

Matnnt | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1,
 |  | const Vecnt< n, T > & | v2
 | ) | [inline]

Constructor for a 3 by 3 matrix out of three vectors of three values each.

Parameters:
v0 | First row of the matrix.
v1 | Second row of the matrix.
v2 | Third row of the matrix.
Remarks:
This constructor can only be used with 3 by 3 matrices, like Mat33f.
Example:
    Mat33f m33f( xAxis, yAxis, zAxis );

Matnnt | ( | T | m00,
 |  | T | m01,
 |  | T | m02,
 |  | T | m03,
 |  | T | m10,
 |  | T | m11,
 |  | T | m12,
 |  | T | m13,
 |  | T | m20,
 |  | T | m21,
 |  | T | m22,
 |  | T | m23,
 |  | T | m30,
 |  | T | m31,
 |  | T | m32,
 |  | T | m33
 | ) | [inline]

Constructor for a 4 by 4 matrix out of 16 scalar values.

Parameters:
m00 | First element of the first row of the matrix.
m01 | Second element of the first row of the matrix.
m02 | Third element of the first row of the matrix.
m03 | Fourth element of the first row of the matrix.
m10 | First element of the second row of the matrix.
m11 | Second element of the second row of the matrix.
m12 | Third element of the second row of the matrix.
m13 | Fourth element of the second row of the matrix.
m20 | First element of the third row of the matrix.
m21 | Second element of the third row of the matrix.
m22 | Third element of the third row of the matrix.
m23 | Fourth element of the third row of the matrix.
m30 | First element of the fourth row of the matrix.
m31 | Second element of the fourth row of the matrix.
m32 | Third element of the fourth row of the matrix.
m33 | Fourth element of the fourth row of the matrix.
Remarks:
This constructor can only be used with 4 by 4 matrices, like Mat44f.
Example:
    Mat44f m44f(  1.0f,  2.0f,  3.0f,  4.0f
               ,  5.0f,  6.0f,  7.0f,  8.0f
               ,  9.0f, 10.0f, 11.0f, 12.0f
               , 13.0f, 14.0f, 15.0f, 16.0f );

Matnnt | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1,
 |  | const Vecnt< n, T > & | v2,
 |  | const Vecnt< n, T > & | v3
 | ) | [inline]

Constructor for a 4 by 4 matrix out of four vectors of four values each.

Parameters:
v0 | First row of the matrix.
v1 | Second row of the matrix.
v2 | Third row of the matrix.
v3 | Fourth row of the matrix.
Remarks:
This constructor can only be used with 4 by 4 matrices, like Mat44f.
Example:
    Mat44f m44f( Vec3f( xAxis, 0.0f )
               , Vec4f( yAxis, 0.0f )
               , Vec4f( zAxis, 0.0f )
               , Vec4f( trans, 1.0f ) );

Matnnt | ( | const Vecnt< n, T > & | axis,
 |  | T | angle
 | ) | [inline]

Constructor for a 3 by 3 rotation matrix out of an axis and an angle.

Parameters:
axis | A reference to the constant axis to rotate about.
angle | The angle, in radians, to rotate.
Remarks:
The resulting 3 by 3 matrix is a pure rotation.
Note:
The behavior is undefined, if axis is not normalized.
Example:
    Mat33f rotZAxisBy45Degrees( Vec3f( 0.0f, 0.0f, 1.0f ), PI/4 );

Matnnt ( const Quatt< T > & ori ) [inline, explicit]

Constructor for a 3 by 3 rotation matrix out of a normalized quaternion.

Parameters:
ori A reference to the normalized quaternion representing the rotation.
Remarks:
The resulting 3 by 3 matrix is a pure rotation.
Note:
The behavior is undefined, if ori is not normalized.

Matnnt | ( | const Quatt< T > & | ori,
 |  | const Vecnt< n-1, T > & | trans
 | ) | [inline]

Constructor for a 4 by 4 transformation matrix out of a quaternion and a translation.

Parameters:
ori | A reference to the normalized quaternion representing the rotational part.
trans | A reference to the vector representing the translational part.
Note:
The behavior is undefined, if \ ori is not normalized.

Matnnt | ( | const Quatt< T > & | ori,
 |  | const Vecnt< n-1, T > & | trans,
 |  | const Vecnt< n-1, T > & | scale
 | ) | [inline]

Constructor for a 4 by 4 transformation matrix out of a quaternion, a translation, and a scaling.

Parameters:
ori | A reference to the normalized quaternion representing the rotational part.
trans | A reference to the vector representing the translational part.
scale | A reference to the vector representing the scaling along the three axis directions.
Note:
The behavior is undefined, if \ ori is not normalized.

Member Function Documentation

const T * getPtr ( ) const [inline]

Get a constant pointer to the n times n values of the matrix.

Returns:
A constant pointer to the matrix elements.
Remarks:
The matrix elements are stored in row-major order. This function returns the address of the first element of the first row. It is assured, that the other elements of the matrix follow linearly.
Example:
If m is a 3 by 3 matrix, m.getPtr() gives a pointer to the 9 elements m00, m01, m02, m10, m11, m12, m20, m21, m22, in that order.

bool invert ( )

Invert the matrix.

Returns:
true, if the matrix was successfully inverted, otherwise false.
Note:
If the matrix was not successfully inverted, the resulting matrix is undefined.

Vecnt< n, T > & operator[] ( S i ) [inline]

Non-constant subscript operator.

Parameters:
i Index of the row to address.
Returns:
A reference to the i th row of the matrix.

const Vecnt< n, T > & operator[] ( S i ) const [inline]

Constant subscript operator.

Parameters:
i Index of the row to address.
Returns:
A constant reference to the i th row of the matrix.

Matnnt< n, T > & operator+= ( const Matnnt< n, S > & m ) [inline]

Matrix addition and assignment operator.

Parameters:
m A constant reference to the matrix to add.
Returns:
A reference to this.
Remarks:
The matrix m has to be of the same size as this, but may hold values of a different type. The matrix elements of type S of m are converted to type T and added to the corresponding matrix elements of this.

Matnnt< n, T > & operator-= ( const Matnnt< n, S > & m ) [inline]

Matrix subtraction and assignment operator.

Parameters:
m A constant reference to the matrix to subtract.
Returns:
A reference to this.
Remarks:
The matrix m has to be of the same size as this, but may hold values of a different type. The matrix elements of type S of m are converted to type T and subtracted from the corresponding matrix elements of this.

Matnnt< n, T > & operator *= ( S s ) [inline]

Scalar multiplication and assignment operator.

Parameters:
s A scalar value to multiply with.
Returns:
A reference to this.
Remarks:
The type of s may be of different type as the elements of the this. s is converted to type T and each element of this is multiplied with it.

Matnnt< n, T > & operator *= ( const Matnnt< n, T > & m ) [inline]

Matrix multiplication and assignment operator.

Parameters:
m A constant reference to the matrix to multiply with.
Returns:
A reference to this.
Remarks:
The matrix multiplication
 *this * m
is calculated and assigned to this.

Matnnt< n, T > & operator/= ( S s ) [inline]

Scalar division and assignment operator.

Parameters:
s A scalar value to divide by.
Returns:
A reference to this.
Remarks:
The type of s may be of different type as the elements of the this. s is converted to type T and each element of this is divided by it.
Note:
The behavior is undefined if s is very close to zero.

The documentation for this class was generated from the following file:
  • Matnnt.h
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


Member List

Matnnt Member List

This is the complete list of members for Matnnt, including all inherited members.
getPtr() const | Matnnt | [inline]
invert() | Matnnt |
Matnnt() | Matnnt | [inline]
Matnnt(const Matnnt< m, S > &rhs) | Matnnt | [inline, explicit]
Matnnt(T m00, T m01, T m02, T m10, T m11, T m12, T m20, T m21, T m22) | Matnnt | [inline]
Matnnt(const Vecnt< n, T > &v0, const Vecnt< n, T > &v1, const Vecnt< n, T > &v2) | Matnnt | [inline]
Matnnt(T m00, T m01, T m02, T m03, T m10, T m11, T m12, T m13, T m20, T m21, T m22, T m23, T m30, T m31, T m32, T m33) | Matnnt | [inline]
Matnnt(const Vecnt< n, T > &v0, const Vecnt< n, T > &v1, const Vecnt< n, T > &v2, const Vecnt< n, T > &v3) | Matnnt | [inline]
Matnnt(const Vecnt< n, T > &axis, T angle) | Matnnt | [inline]
Matnnt(const Quatt< T > &ori) | Matnnt | [inline, explicit]
Matnnt(const Quatt< T > &ori, const Vecnt< n-1, T > &trans) | Matnnt | [inline]
Matnnt(const Quatt< T > &ori, const Vecnt< n-1, T > &trans, const Vecnt< n-1, T > &scale) | Matnnt | [inline]
operator *=(S s) | Matnnt | [inline]
operator *=(const Matnnt< n, T > &m) | Matnnt | [inline]
operator+=(const Matnnt< n, S > &m) | Matnnt | [inline]
operator-=(const Matnnt< n, S > &m) | Matnnt | [inline]
operator/=(S s) | Matnnt | [inline]
operator[](S i) | Matnnt | [inline]
operator[](S i) const | Matnnt | [inline]
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


TemplateMemFunTbl class Reference

MemFunTbl Class Template Reference

Member Function Table template. More...

#include <MemFunTbl.h>

Inheritance diagram for MemFunTbl:

[legend]
List of all members.

Public Member Functions

MemFunTbl (size_t size)
reserve 'size' table entries, to avoid frequend allocations

PMFN | operator[] (size_t i) const
read-only access the function pointer stored at index i; behavior is undefined for invalid indices

template<typename U> void | addEntry (size_t i, U pmfn)
register function pointer pmfn at index i; former entry at i will by overridden

bool | testEntry (size_t i) const
test if entry at i is valid

Detailed Description

template<typename T>
class nvutil::MemFunTbl< T >

Member Function Table template.

Constructor & Destructor Documentation

MemFunTbl ( size_t size ) [inline, explicit]

reserve 'size' table entries, to avoid frequend allocations

Member Function Documentation

MemFunTbl< T >::PMFN operator[] ( size_t i ) const [inline]

read-only access the function pointer stored at index i; behavior is undefined for invalid indices

void addEntry | ( | size_t | i,
 |  | U | pmfn
 | ) | [inline]

register function pointer pmfn at index i; former entry at i will by overridden

bool testEntry ( size_t i ) const [inline]

test if entry at i is valid

The documentation for this class was generated from the following file:
  • MemFunTbl.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

MemFunTbl Member List

This is the complete list of members for MemFunTbl, including all inherited members.
addEntry(size_t i, U pmfn) | MemFunTbl | [inline]
MemFunTbl(size_t size) | MemFunTbl | [inline, explicit]
operator[](size_t i) const | MemFunTbl | [inline]
testEntry(size_t i) const | MemFunTbl | [inline]
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


MeshedPrimitiveSet Class Reference

Abstract base class for PrimitiveSet objects with points organized as meshes. More...

#include <MeshedPrimitiveSet.h>

Inheritance diagram for MeshedPrimitiveSet:

[legend]
Collaboration diagram for MeshedPrimitiveSet:

[legend]
List of all members.

Public Member Functions

NVSG_API | MeshedPrimitiveSet ()
Destructs a MeshedPrimtiveSet.

virtual NVSG_API | ~MeshedPrimitiveSet ()
Destructor.

virtual NVSG_API bool | isDataShared () const
Query whether the data of this MeshedPrimitiveSet is shared with other MeshedPrimitiveSet objects.

virtual NVSG_API DataID | getDataID () const
Get the unique data identifier of this object.

NVSG_API bool | hasMeshes () const
Query if this MeshedPrimitiveSet has meshes.

NVSG_API unsigned int | getNumberOfMeshes () const
Get the number of meshes.

NVSG_API const IndexMesh * | getMeshes () const
Get a pointer to the meshes.

NVSG_API void | setMeshes (const IndexMesh *meshes, unsigned int numMeshes)
Set the meshes of this MeshedPrimitiveSet.

NVSG_API void | setMeshes (unsigned int pos, const IndexMesh *meshes, unsigned int numMeshes)
Set a subset of meshes of this MeshedPrimitiveSet.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other MeshedPrimitiveSet.

Protected Member Functions

NVSG_API | MeshedPrimitiveSet (const MeshedPrimitiveSet &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Calculates the bounding box of this MeshedPrimitiveSet.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this MeshedPrimitiveSet.

NVSG_API MeshedPrimitiveSet & | operator= (const MeshedPrimitiveSet &rhs)
Assignment operator.

Detailed Description

Abstract base class for PrimitiveSet objects with points organized as meshes.

Namespace: nvsg
Remarks:
This class holds a vector of IndexMesh elements used in meshed primitives like QuadMeshes. The meshes are defined by a vector of IndexMesh elements. Each IndexMesh holds the width and height of the mesh and is an IndexSet with width times height elements, and represents one mesh.
See also:
IndependentPrimitiveSet, QuadMeshes, StrippedPrimitiveSet

Constructor & Destructor Documentation

NVSG_API MeshedPrimitiveSet ( )

Destructs a MeshedPrimtiveSet.

virtual NVSG_API ~MeshedPrimitiveSet ( ) [virtual]

Destructor.

Remarks:
The destructor is never used explicitly, but only when the reference count of the MeshedPrimitiveSet is decremented to zero.
See also:
addRef, removeRef

NVSG_API MeshedPrimitiveSet ( const MeshedPrimitiveSet & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant MeshedPrimitiveSet to copy from.
Remarks:
The newly created MeshedPrimitiveSet is copied from rhs.
Note:
A MeshedPrimitiveSet will not be instantiated directly, but through instantiating a derived object like QuadMeshes for example.

Member Function Documentation

virtual NVSG_API bool isDataShared ( ) const [virtual]

Query whether the data of this MeshedPrimitiveSet is shared with other MeshedPrimitiveSet objects.

Returns:
true, if the data of this MeshedPrimitiveSet is shared with other MeshedPrimitiveSet objects, otherwise false.
Remarks:
A MeshedPrimitiveSet object shares it's data with another MeshedPrimitiveSet object, if it was either instantiated as a copy of the other, using MeshedPrimitiveSet::clone, or if it was assigned to by the other object using the assignment operator. In that case, the two objects have the same DataID.
See also:
clone, getDataID, operator=()

Reimplemented from Object.

virtual NVSG_API DataID getDataID ( ) const [virtual]

Get the unique data identifier of this object.

Returns:
A 64-bit value that uniquely identifies the embedded data.
Remarks:
A MeshedPrimitiveSet object shares it's data with another MeshedPrimitiveSet object, if it was either instantiated as a copy of the other, using MeshedPrimitiveSet::clone, or if it was assigned to by the other object using the assignment operator. In that case, the two objects have the same DataID.
See also:
clone, isDataShared, operator=()

Reimplemented from Object.

bool hasMeshes ( ) const [inline]

Query if this MeshedPrimitiveSet has meshes.

Returns:
true, if this MeshedPrimitiveSet has at least one IndexMesh, otherwise false.
See also:
getNumberOfMeshes, getMeshes, setMeshes

unsigned int getNumberOfMeshes ( ) const [inline]

Get the number of meshes.

Returns:
The number of meshes of this MeshedPrimitiveSet.
See also:
hasMeshes, getMeshes, setMeshes

const IndexMesh * getMeshes ( ) const [inline]

Get a pointer to the meshes.

Returns:
A pointer to the constant IndexMesh elements of this MeshedPrimitiveSet.
See also:
hasMeshes, getNumberOfMeshes, setMeshes

NVSG_API void setMeshes | ( | const IndexMesh * | meshes,
 |  | unsigned int | numMeshes
 | ) |

Set the meshes of this MeshedPrimitiveSet.

Parameters:
meshes | A pointer to the constant IndexMesh elements to use.
numMeshes | The number of meshes.
Remarks:
Copies numMeshes meshes from meshes into this MeshedPrimitiveSet.
Note:
The behaviour is undefined, if there are less than numMeshes values of type IndexMesh located at meshes.
See also:
hasMeshes, getNumberOfMeshes, getMeshes

NVSG_API void setMeshes | ( | unsigned int | pos,
 |  | const IndexMesh * | meshes,
 |  | unsigned int | numMeshes
 | ) |

Set a subset of meshes of this MeshedPrimitiveSet.

Parameters:
pos | The start position inside the range of pre-existing meshes.
meshes | A pointer to the constant meshes to use.
numMeshes | The number of meshes.
Remarks:
Copies numMeshes of IndexMesh elements from meshes into this MeshedPrimitiveSet, starting at position pos inside the range of pre-existing indices.
Pre-existing meshes in the range [pos, pos + numMeshes) will be replaced. Pre-existing meshes outside this range remain untouched.
If you specifiy (-1) for pos or pos specifies the number of meshes currently stored, the meshes pointed to by meshes will be appended to the pre-existing meshes.
Note:
The behaviour is undefined, if pos is neither a valid position inside the range of pre-existing meshes, nor the number of meshes currently stored, nor (-1).

The behaviour is undefined, if there are less than numMeshes values of type IndexMesh located at meshes.

See also:
hasMeshes, getNumberOfMeshes, getMeshes

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other MeshedPrimitiveSet.

Parameters:
p | A reference to the constant MeshedPrimitiveSet to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the MeshedPrimitiveSet p is equivalent to this, otherwise false.
Remarks:
Two MeshedPrimitiveSet objects are equivalent, if they are equivalent as PrimitiveSet, and all their IndexMesh elements are pairwise equal.
Note:
The behaviour is undefined if p is not an MeshedPrimitiveSet or derived from one.
See also:
PrimitiveSet

Reimplemented from PrimitiveSet.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Calculates the bounding box of this MeshedPrimitiveSet.

Returns:
The axis-aligned bounding box of this MeshedPrimitiveSet.
Remarks:
This function is called by the framework when re-calculation of the bounding box is required for this MeshedPrimitiveSet.

Implements Drawable.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this MeshedPrimitiveSet.

Returns:
A nvmath::Sphere3f that contains the complete MeshedPrimitiveSet.
Remarks:
This function is called by the framework to determine a sphere that completely contains the MeshedPrimitiveSet.

Implements Drawable.

NVSG_API MeshedPrimitiveSet& operator= ( const MeshedPrimitiveSet & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant MeshedPrimitiveSet to copy from.
Returns:
A reference to the assigned MeshedPrimitiveSet.
Remarks:
The assignment operator calls the assignment operator of PrimitiveSet and copies the IndexMesh elements.

The documentation for this class was generated from the following file:
  • MeshedPrimitiveSet.h
Generated on Tue Jan 15 10:29:10 2008 for NVSGSDK by NVIDIA


Member List

MeshedPrimitiveSet Member List

This is the complete list of members for MeshedPrimitiveSet, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | MeshedPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | MeshedPrimitiveSet | [protected, virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | MeshedPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getMeshes() const | MeshedPrimitiveSet | [inline]
getName() const | Object |
getNumberOfMeshes() const | MeshedPrimitiveSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasMeshes() const | MeshedPrimitiveSet | [inline]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | MeshedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | MeshedPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
MeshedPrimitiveSet() | MeshedPrimitiveSet |
MeshedPrimitiveSet(const MeshedPrimitiveSet &rhs) | MeshedPrimitiveSet | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const MeshedPrimitiveSet &rhs) | MeshedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setMeshes(const IndexMesh *meshes, unsigned int numMeshes) | MeshedPrimitiveSet |
setMeshes(unsigned int pos, const IndexMesh *meshes, unsigned int numMeshes) | MeshedPrimitiveSet |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~MeshedPrimitiveSet() | MeshedPrimitiveSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
Generated on Tue Jan 15 10:29:10 2008 for NVSGSDK by NVIDIA


meshSet_t Struct Reference

The meshSet_t structure specifies how an mesh set is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t width
Specifies the width of the mesh.

uint_t height
Specifies the height of the mesh.

uint_t indices
a index is a 32-bit unsigned integer value.

Detailed Description

The meshSet_t structure specifies how an mesh set is stored in a .NBF file.

Mesh sets, in this context, need to be considered in conjunction with NBFMeshedPrimitiveSet objects.

Member Data Documentation

uint_t width

Specifies the width of the mesh.

uint_t height

Specifies the height of the mesh.

uint_t indices

a index is a 32-bit unsigned integer value.

Specifies the file offset to the indices. As specified by the NBF format,

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

meshSet_t Member List

This is the complete list of members for meshSet_t, including all inherited members.
height | meshSet_t
indices | meshSet_t
width | meshSet_t
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


MissingResult Class Reference

AnalyzeResult indicating non-complete objects. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for MissingResult:

[legend]
Collaboration diagram for MissingResult:

[legend]
List of all members.

Public Member Functions

virtual | ~MissingResult ()
Virtual Destructor.

Public Attributes

unsigned int | missingCount
The number of objects with missing information.

Detailed Description

AnalyzeResult indicating non-complete objects.

Namespace: nvsg
Remarks:
All Objects with missing information (e.g. an AnimatedTransform without an Animation) are reported with a MissingResult.
See also:
AnalyzeResult, AnalyzeTraverser

Constructor & Destructor Documentation

virtual ~MissingResult ( ) [inline, virtual]

Virtual Destructor.

Member Data Documentation

unsigned int missingCount

The number of objects with missing information.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


Member List

MissingResult Member List

This is the complete list of members for MissingResult, including all inherited members.
missingCount | MissingResult |
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~MissingResult() | MissingResult | [inline, virtual]
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


MouseInput Class Reference

Mouse input helper class to store mouse events. More...

#include <MouseInput.h>

List of all members.

Public Member Functions

NVSG_API | MouseInput ()
Default constructor.

virtual NVSG_API | ~MouseInput ()
Default destructor.

void | resetButtonState ()
Reset the current mouse button state.

void | resetPositions ()
Reset the current mouse position information.

UINT | getButtonState () const
Determine the current mouse button state.

NVSG_API void | mouseButtonDown (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseButtonUp (UINT btn, int x, int y)
Handle mouse button release events.

NVSG_API void | mouseMotion (int x, int y)
Handle mouse motion.

NVSG_API void | motionHandled ()
Flag current mouse motion information as handled by the manipulator.

NVSG_API int | getLastX () const
Get the x-coordinate of the last and not handled mouse position.

NVSG_API int | getLastY () const
Get the y-coordinate of the last and not handled mouse position.

NVSG_API int | getCurrentX () const
Get the x-coordinate of the current mouse position.

NVSG_API int | getCurrentY () const
Get the y-coordinate of the current mouse position.

NVSG_API int | getStartX () const
Get the x-coordinate of the mouse position where a button was pressed.

NVSG_API int | getStartY () const
Get the y-coordinate of the mouse position where a button was pressed.

NVSG_API MouseInput & | operator= (const MouseInput &rhs)
Assignment operator.

NVSG_API bool | operator== (const MouseInput &rhs) const
Equality operator.

NVSG_API bool | operator!= (const MouseInput &rhs) const
Inequality operator.

Protected Attributes

UINT | m_buttonState
Current button mask containing the concatenation of mouse button codes.

int | m_currentX
Current mouse x-position.

int | m_currentY
Current mouse y-position.

int | m_lastX
Last and not handled mouse x-position for motion delta.

int | m_lastY
Last and not handled mouse y-position for motion delta.

int | m_startX
Mouse start x-position where the last button was pressed.

int | m_startY
Mouse start y-position where the last button was pressed.

Detailed Description

Mouse input helper class to store mouse events.

Namespace: nvui
Remarks:
This class can be used to help managing simple mouse button press, release, and motion events. It a simple container that can be used inside of, for example, a Manipulator class that uses mouse button and motion events to control its functionality.
Whenever a mouse button is pressed the Manipulator stores the code and mouse position for this button in this container and removes the code and position when the button is released. The button state represents the concatenation of the button codes of the currently pressed buttons on the mouse.
The MouseInput class also helps also to keep track of the mouse motion.
A simple enum defines the button codes - It makes sense to choose the codes to allow combinations of different buttons at the same time.
  enum
  { _NO_KEY           = 0x0000
  , _LEFT_MOUSE_BTN   = 0x0001
  , _MIDDLE_MOUSE_BTN = 0x0002
  , _RIGHT_MOUSE_BTN  = 0x0004
  };

Have a look at the ManipSampleViewer tutorial on how to use this class.

Constructor & Destructor Documentation

NVSG_API MouseInput ( )

Default constructor.

Remarks:
The constructor simply resets the button state and mouse positions.
See also:
resetButtonState, resetPositions

virtual NVSG_API ~MouseInput ( ) [virtual]

Default destructor.

Member Function Documentation

void resetButtonState ( ) [inline]

Reset the current mouse button state.

Remarks:
This function resets all the information on currently pressed mouse buttons. Default: NULL

void resetPositions ( ) [inline]

Reset the current mouse position information.

Remarks:
This function resets all the information about mouse positions. Default value: (0,0)

UINT getButtonState ( ) const [inline]

Determine the current mouse button state.

Returns:
The concatenation of the current mouse button codes.
Remarks:
This function can be used to get information on the currently pressed mouse buttons.
Example
Extract the mouse button codes:
  UINT DOLLY = _LEFT_MOUSE_BTN | _MIDDLE_MOUSE_BTN;
  [...]
  switch (m_mouseInput.getButtonState())
  {
    case DOLLY:
      [...]
      break;
    [...]
  }
See also:
mouseButtonDown, mouseButtonUp

NVSG_API void mouseButtonDown | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code (or concatenation) of the pressed button(s).
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The application or manipulator can use this function to inform the MouseInput object about pressed mouse buttons by providing the button code of the newly pressed mouse button and the current mouse cursor position in window coordinates. (lastPosition = startPosition = currentPosition)
The button code is defined by the application or Manipulator. See the description of MouseInput for button codes.
See also:
mouseButtonUp, getButtonState, MouseInput

NVSG_API void mouseButtonUp | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button release events.

Parameters:
btn | The mouse button code (or concatenation) of the released button(s).
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The application or manipulator can use this function to inform the MouseInput object about released mouse buttons by providing the button code of the newly released mouse button and the current mouse cursor position in window coordinates.
The button code is defined by the application or Manipulator. See the description of MouseInput for button codes.
See also:
mouseButtonDown, getButtonState, MouseInput

NVSG_API void mouseMotion | ( | int | x,
 |  | int | y
 | ) |

Handle mouse motion.

Parameters:
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates. The application or manipulator must tell the MouseInput object the mouse motion events. The MouseInput object stores the current mouse position (window coordinates).

NVSG_API void motionHandled ( )

Flag current mouse motion information as handled by the manipulator.

Remarks:
The manipulators need the motion delta between every frame, not from mouse motion to mouse motion. Calling this method tells the MouseInput object that the motion data was used for the last frame and that a new motion delta needs to be tracked for the next frame. (lastPosition = currentPosition)
See also:
mouseMotion

int getLastX ( ) const [inline]

Get the x-coordinate of the last and not handled mouse position.

Returns:
X-coordinate of the position in window coordinates.
Remarks:
The manipulators need the motion delta between every frame, not from mouse motion to mouse motion. This function returns only the not handled mouse position. The Manipulator needs to call motionHandled to mark the mouse position as handled.
See also:
getLastY, mouseButtonDown, mouseMotion, motionHandled

int getLastY ( ) const [inline]

Get the y-coordinate of the last and not handled mouse position.

Returns:
Y-coordinate of the position in window coordinates.
Remarks:
The manipulators need the motion delta between every frame, not from mouse motion to mouse motion. This function returns only the not handled mouse position. The Manipulator needs to call motionHandled to mark the mouse position as handled.
See also:
getLastY, mouseButtonDown, mouseMotion, motionHandled

int getCurrentX ( ) const [inline]

Get the x-coordinate of the current mouse position.

Returns:
X-coordinate of the position in window coordinates.
Remarks:
The current position does not care if it was handled. It is simply the current position of the mouse cursor while a button is pressed.
See also:
getCurrentY, mouseMotion

int getCurrentY ( ) const [inline]

Get the y-coordinate of the current mouse position.

Returns:
Y-coordinate of the position in window coordinates.
Remarks:
The current position does not care if it was handled. It is simply the current position of the mouse cursor while a button is pressed.
See also:
getCurrentX, mouseMotion

int getStartX ( ) const [inline]

Get the x-coordinate of the mouse position where a button was pressed.

Returns:
X-coordinate of the position in window coordinates
Remarks:
The last mouse position represents the cursor position of the mouse where the last button was pressed.
See also:
getLastY, mouseButtonDown

int getStartY ( ) const [inline]

Get the y-coordinate of the mouse position where a button was pressed.

Returns:
Y-coordinate of the position in window coordinates
Remarks:
The last mouse position represents the cursor position of the mouse where the last button was pressed.
See also:
getLastY, mouseButtonDown

NVSG_API MouseInput& operator= ( const MouseInput & rhs )

Assignment operator.

Parameters:
rhs Reference to an MouseInput object.
Returns:
Reference to an MouseInput object.
Remarks:
Use the assignment operator to easily assign one MouseInput object to another one.

NVSG_API bool operator== ( const MouseInput & rhs ) const

Equality operator.

Parameters:
rhs Reference to an MouseInput object - object to compare with.
Returns:
When the data of both objects are equal, the return value is true.
Remarks:
Compare the two objects on equality. Internally only the mouse button state mask containing the concatenated button codes and all the position information are compared.
See also:
operator!=()

NVSG_API bool operator!= ( const MouseInput & rhs ) const

Inequality operator.

Parameters:
rhs Reference to an MouseInput object - object to compare with.
Returns:
When the data of both objects are unequal, the return value is true.
Remarks:
Compare the two objects on inequality. Internally only the mouse button state mask containing the concatenated button codes and all the position information are compared.
See also:
operator!=()

Member Data Documentation

UINT m_buttonState [protected]

Current button mask containing the concatenation of mouse button codes.

int m_currentX [protected]

Current mouse x-position.

int m_currentY [protected]

Current mouse y-position.

int m_lastX [protected]

Last and not handled mouse x-position for motion delta.

int m_lastY [protected]

Last and not handled mouse y-position for motion delta.

int m_startX [protected]

Mouse start x-position where the last button was pressed.

int m_startY [protected]

Mouse start y-position where the last button was pressed.

The documentation for this class was generated from the following file:
  • MouseInput.h
Generated on Tue Jan 15 10:29:42 2008 for NVSGSDK by NVIDIA


Member List

MouseInput Member List

This is the complete list of members for MouseInput, including all inherited members.
getButtonState() const | MouseInput | [inline]
getCurrentX() const | MouseInput | [inline]
getCurrentY() const | MouseInput | [inline]
getLastX() const | MouseInput | [inline]
getLastY() const | MouseInput | [inline]
getStartX() const | MouseInput | [inline]
getStartY() const | MouseInput | [inline]
m_buttonState | MouseInput | [protected]
m_currentX | MouseInput | [protected]
m_currentY | MouseInput | [protected]
m_lastX | MouseInput | [protected]
m_lastY | MouseInput | [protected]
m_startX | MouseInput | [protected]
m_startY | MouseInput | [protected]
motionHandled() | MouseInput |
mouseButtonDown(UINT btn, int x, int y) | MouseInput |
mouseButtonUp(UINT btn, int x, int y) | MouseInput |
MouseInput() | MouseInput |
mouseMotion(int x, int y) | MouseInput |
operator!=(const MouseInput &rhs) const | MouseInput |
operator=(const MouseInput &rhs) | MouseInput |
operator==(const MouseInput &rhs) const | MouseInput |
resetButtonState() | MouseInput | [inline]
resetPositions() | MouseInput | [inline]
~MouseInput() | MouseInput | [virtual]
Generated on Tue Jan 15 10:29:42 2008 for NVSGSDK by NVIDIA


NBFAlphaTestAttribute Struct Reference

The NBFAlphaTestAttribute structure represents an alpha test state attribute in the NBF format. More...

#include <NBF.h>

Inheritance diagram for NBFAlphaTestAttribute:

[legend]
Collaboration diagram for NBFAlphaTestAttribute:

[legend]
List of all members.

Public Member Functions

PADDING (2)
Padding bits to ensure offset of threshold member is on a 4-byte boundary, regardless of packing.

Public Attributes

ubyte_t alphaFunction
Specifies the alpha function.

ubyte_t enabledMSAlpha
Specifies whether enabled during msalpha.

float threshold
Specifies the threshold value.

Detailed Description

The NBFAlphaTestAttribute structure represents an alpha test state attribute in the NBF format.

The object code for a NBFAlphaTestAttribute is NBF_ALPHA_TEST_ATTRIBUTE.

Member Function Documentation

PADDING ( 2 )

Padding bits to ensure offset of threshold member is on a 4-byte boundary, regardless of packing.

Member Data Documentation

ubyte_t alphaFunction

Specifies the alpha function.

ubyte_t enabledMSAlpha

Specifies whether enabled during msalpha.

float threshold

Specifies the threshold value.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

NBFAlphaTestAttribute Member List

This is the complete list of members for NBFAlphaTestAttribute, including all inherited members.
alphaFunction | NBFAlphaTestAttribute
enabledMSAlpha | NBFAlphaTestAttribute
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(2) | NBFAlphaTestAttribute
NBFStateAttribute::PADDING(3) | NBFObject
sourceObject | NBFObject
threshold | NBFAlphaTestAttribute
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


NBFAnimatedTransform Struct Reference

The NBFAnimatedTransform structure represents an animated transform group node. More...

#include <NBF.h>

Inheritance diagram for NBFAnimatedTransform:

[legend]
Collaboration diagram for NBFAnimatedTransform:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFAnimatedTransform is a multiple of 8, regardless of packing.

Public Attributes

uint_t animation

Detailed Description

The NBFAnimatedTransform structure represents an animated transform group node.

The object code for a NBFAnimatedTransform is NBF_ANIMATED_TRANSFORM.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFAnimatedTransform is a multiple of 8, regardless of packing.

Reimplemented from NBFTransform.

Member Data Documentation

uint_t animation

Specifies the file offset to the NBFTrafoAnimation object < to be applied to the transform group node.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


Member List

NBFAnimatedTransform Member List

This is the complete list of members for NBFAnimatedTransform, including all inherited members.
animation | NBFAnimatedTransform
annotation | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
lightSources | NBFGroup
numChildren | NBFGroup
numClipPlanes | NBFGroup
numLightSource | NBFGroup
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFAnimatedTransform
NBFGroup::PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
trafo | NBFTransform
userHints | NBFNode
Generated on Tue Jan 15 10:28:35 2008 for NVSGSDK by NVIDIA


NBFAnimatedVertexAttributeSet Struct Reference

The NBFAnimatedVertexAttributeSet structure represents a set of animated vertex attributes. More...

#include <NBF.h>

Inheritance diagram for NBFAnimatedVertexAttributeSet:

[legend]
Collaboration diagram for NBFAnimatedVertexAttributeSet:

[legend]
List of all members.

Public Member Functions

PADDING (4)

Public Attributes

uint_t animations [16]
uint_t normalizeFlags

Detailed Description

The NBFAnimatedVertexAttributeSet structure represents a set of animated vertex attributes.

Remarks:
A NBFAnimatedVertexAttributeSet derives from NBFVertexAttributeSet, and holds up to 16 animations, one for each of the up to 16 vertex attributes in a NBFVertexAttributeSet, and a field of flags to specify if a vertex attribute has to be normalized, for example after interpolating.

Member Data Documentation

uint_t animations[16]

Specifies the file offset to the animation objects, one < offset for each vertex attribute.

uint_t normalizeFlags

Flags that determine if a vertex attribute has to be < normalized after interpolation

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


Member List

NBFAnimatedVertexAttributeSet Member List

This is the complete list of members for NBFAnimatedVertexAttributeSet, including all inherited members.
animations | NBFAnimatedVertexAttributeSet
enableFlags | NBFVertexAttributeSet
isShared | NBFObject
normalizeEnableFlags | NBFVertexAttributeSet
normalizeFlags | NBFAnimatedVertexAttributeSet
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) (defined in NBFAnimatedVertexAttributeSet) | NBFAnimatedVertexAttributeSet
NBFVertexAttributeSet::PADDING(3) | NBFObject
sourceObject | NBFObject
vattribs | NBFVertexAttributeSet
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


NBFAnimation Struct Reference

The NBFAnimation structure represents the common anchor of all animation structures. More...

#include <NBF.h>

Inheritance diagram for NBFAnimation:

[legend]
List of all members.

Public Member Functions

PADDING (6)
Padding bits to ensure the size of NBFAnimation is a multiple of 8, regardless of packing.

Public Attributes

uint_t loopCount
Specifies the number of times to run through the Animation.

uint_t speed
Specifies the number if steps per advance.

bool | forward
Specifies to run the Animation forward or backward.

bool | swinging
Specifies to run the Animation looping or swinging (ping-pong).

Detailed Description

The NBFAnimation structure represents the common anchor of all animation structures.

A NBFAnimation serves as a base class only and needs to be considered in conjunction with either NBFFramedAnimation or NBFInterpolatedAnimation.

Member Function Documentation

PADDING ( 6 )

Padding bits to ensure the size of NBFAnimation is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t loopCount

Specifies the number of times to run through the Animation.

uint_t speed

Specifies the number if steps per advance.

bool forward

Specifies to run the Animation forward or backward.

bool swinging

Specifies to run the Animation looping or swinging (ping-pong).

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


Member List

NBFAnimation Member List

This is the complete list of members for NBFAnimation, including all inherited members.
forward | NBFAnimation
loopCount | NBFAnimation
PADDING(6) | NBFAnimation
speed | NBFAnimation
swinging | NBFAnimation
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


NBFBillboard Struct Reference

The NBFBillboard structure represents a billboard group node. More...

#include <NBF.h>

Inheritance diagram for NBFBillboard:

[legend]
Collaboration diagram for NBFBillboard:

[legend]
List of all members.

Public Member Functions

PADDING (3)
Padding bits to ensure the size of NBFBillboard is a multiple of 8, regardless of packing.

Public Attributes

float3_t rotationAxis
Specifies the axis to rotate the Billboard around.

ubyte_t alignment
Specifies the alignment (axis, viewer, or screen aligned).

Detailed Description

The NBFBillboard structure represents a billboard group node.

The object code for a NBFBillboard is NBF_BILLBOARD.

Member Function Documentation

PADDING ( 3 )

Padding bits to ensure the size of NBFBillboard is a multiple of 8, regardless of packing.

Reimplemented from NBFObject.

Member Data Documentation

float3_t rotationAxis

Specifies the axis to rotate the Billboard around.

ubyte_t alignment

Specifies the alignment (axis, viewer, or screen aligned).

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


Member List

NBFBillboard Member List

This is the complete list of members for NBFBillboard, including all inherited members.
alignment | NBFBillboard
annotation | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
lightSources | NBFGroup
numChildren | NBFGroup
numClipPlanes | NBFGroup
numLightSource | NBFGroup
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFBillboard
NBFGroup::PADDING(6) | NBFNode
rotationAxis | NBFBillboard
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


NBFBlendAttribute Struct Reference

The NBFBlendAttribute structure represents a blend function. More...

#include <NBF.h>

Inheritance diagram for NBFBlendAttribute:

[legend]
Collaboration diagram for NBFBlendAttribute:

[legend]
List of all members.

Public Member Functions

PADDING (6)
Padding bits to ensure size of NBFBlendAttribute is a multiple of 8.

Public Attributes

ubyte_t sourceFunction
Specifies the source blending function.

ubyte_t destinationFunction
Specifies the destination blending function.

Detailed Description

The NBFBlendAttribute structure represents a blend function.

The object code for a NBFBlendAttribute is NBF_BLEND_ATTRIBUTE.

Member Function Documentation

PADDING ( 6 )

Padding bits to ensure size of NBFBlendAttribute is a multiple of 8.

Member Data Documentation

ubyte_t sourceFunction

Specifies the source blending function.

ubyte_t destinationFunction

Specifies the destination blending function.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


Member List

NBFBlendAttribute Member List

This is the complete list of members for NBFBlendAttribute, including all inherited members.
destinationFunction | NBFBlendAttribute
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFBlendAttribute
NBFStateAttribute::PADDING(3) | NBFObject
sourceFunction | NBFBlendAttribute
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


NBFCamera Struct Reference

The NBFCamera represents a camera. More...

#include <NBF.h>

Inheritance diagram for NBFCamera:

[legend]
Collaboration diagram for NBFCamera:

[legend]
List of all members.

Public Member Functions

PADDING (3)
Padding bits to ensure offset of windowSize is on a 4-byte boundary, regardless of packing.

PADDING (4)
Padding bits to ensure the size of NBFCamera is a multiple of 8, regardless of packing.

Public Attributes

uint_t numHeadLights
Specifies the number of headlights attached.

uint_t headLights
float3_t upVector
Specifies the camera's normalized up vector.

float3_t position
Specifies the actual position of camera in world space.

float3_t direction
Specifies the normalized direction for the camera to look along.

float | farDist
Specifies the distance from the actual camera position to the far clipping plane.

float | nearDist
Specifies the distance from the actual camera position to the near clipping plane.

float | focusDist
Specifies the distance to the projection plane.

ubyte_t isAutoClipPlanes
Indicates if automatic generation of clipping planes is enabled.

float2_t windowSize
float2_t windowOffset

Detailed Description

The NBFCamera represents a camera.

A NBFCamera serves as base class only.
Concrete object codes valid for a NBFCamera are NBF_PARALLEL_CAMERA and NBF_PERSPECTIVE_CAMERA. Further object codes valid for a NBFCamera are subject to future extensions for the NBF format.

Member Function Documentation

PADDING ( 3 )

Padding bits to ensure offset of windowSize is on a 4-byte boundary, regardless of packing.

Reimplemented from NBFObject.

PADDING ( 4 )

Padding bits to ensure the size of NBFCamera is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t numHeadLights

Specifies the number of headlights attached.

uint_t headLights

Specifies the file offset to the offsets to the attached headlight objects. < Headlights are of type NBFLightSource.

float3_t upVector

Specifies the camera's normalized up vector.

float3_t position

Specifies the actual position of camera in world space.

float3_t direction

Specifies the normalized direction for the camera to look along.

float farDist

Specifies the distance from the actual camera position to the far clipping plane.

float nearDist

Specifies the distance from the actual camera position to the near clipping plane.

float focusDist

Specifies the distance to the projection plane.

ubyte_t isAutoClipPlanes

Indicates if automatic generation of clipping planes is enabled.

float2_t windowSize

Specifies the world-relative size of the viewing window. Whereas the x-component of < of the vector specifies the width, and the y-component of the vector specifies the height.

float2_t windowOffset

Specifies the world-relative offset from the viewing reference point to the center < of the viewing window.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


Member List

NBFCamera Member List

This is the complete list of members for NBFCamera, including all inherited members.
direction | NBFCamera
farDist | NBFCamera
focusDist | NBFCamera
headLights | NBFCamera
isAutoClipPlanes | NBFCamera
isShared | NBFObject
nearDist | NBFCamera
numHeadLights | NBFCamera
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFCamera
PADDING(4) | NBFCamera
position | NBFCamera
sourceObject | NBFObject
upVector | NBFCamera
windowOffset | NBFCamera
windowSize | NBFCamera
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


NBFCgFx Struct Reference

The NBFCgFx structure represents an effect attribute. More...

#include <NBF.h>

Inheritance diagram for NBFCgFx:

[legend]
Collaboration diagram for NBFCgFx:

[legend]
List of all members.

Public Member Functions

PADDING (3)
Padding bits to ensure offset of objectDataID is on a 8-byte boundary, regardless of packing.

PADDING (4)
Padding bits to ensure the size of NBFCgFx is a multiple of 8, regardless of packing.

Public Attributes

ubyte_t fromFile
Specifies whether the effect's source is a file. If this is false, the source member below is interpreted as a code string.

str_t source
Holds either the filename of an effect file or a source code string.

uint_t numTweaks
Specifies the number of tweakable effect parameters stored.

uint_t tweaks
Specifies the file offset to the tweakable effect paramters. Tweakables in the NBF format are stored as tweak_t objects.

uint_t numSamplers
Specifies the number of sampler parameters stored.

uint_t samplers
Specifies the file offset t the sampler parameters. Samplers parameters a stored as sampler_t objects.

str_t currTech
Specifies the name of the current technique used with rendering.

Detailed Description

The NBFCgFx structure represents an effect attribute.

The object code for a NBFCgFx is NBF_CGFX.

Member Function Documentation

PADDING ( 3 )

Padding bits to ensure offset of objectDataID is on a 8-byte boundary, regardless of packing.

Reimplemented from NBFObject.

PADDING ( 4 )

Padding bits to ensure the size of NBFCgFx is a multiple of 8, regardless of packing.

Member Data Documentation

ubyte_t fromFile

Specifies whether the effect's source is a file. If this is false, the source member below is interpreted as a code string.

str_t source

Holds either the filename of an effect file or a source code string.

uint_t numTweaks

Specifies the number of tweakable effect parameters stored.

uint_t tweaks

Specifies the file offset to the tweakable effect paramters. Tweakables in the NBF format are stored as tweak_t objects.

uint_t numSamplers

Specifies the number of sampler parameters stored.

uint_t samplers

Specifies the file offset t the sampler parameters. Samplers parameters a stored as sampler_t objects.

str_t currTech

Specifies the name of the current technique used with rendering.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


Member List

NBFCgFx Member List

This is the complete list of members for NBFCgFx, including all inherited members.
currTech | NBFCgFx
fromFile | NBFCgFx
isShared | NBFObject
numSamplers | NBFCgFx
numTweaks | NBFCgFx
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFCgFx
PADDING(4) | NBFCgFx
samplers | NBFCgFx
source | NBFCgFx
sourceObject | NBFObject
tweaks | NBFCgFx
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


NBFDepthAttribute Struct Reference

The NBFDepthAttribute structure represents depth buffer settings. More...

#include <NBF.h>

Inheritance diagram for NBFDepthAttribute:

[legend]
Collaboration diagram for NBFDepthAttribute:

[legend]
List of all members.

Public Member Functions

PADDING (5)
Padding bits to ensure size of NBFBlendAttribute is a multiple of 8.

Public Attributes

ubyte_t depthFunction
Specifies the depth function.

ubyte_t depthTestingEnabled
Specifies if depth testing is enabled.

ubyte_t depthWritingEnabled
Specifies if depth writing is enabled.

Detailed Description

The NBFDepthAttribute structure represents depth buffer settings.

The object code for a NBFDepthAttribute is NBF_DEPTH_ATTRIBUTE.

Member Function Documentation

PADDING ( 5 )

Padding bits to ensure size of NBFBlendAttribute is a multiple of 8.

Member Data Documentation

ubyte_t depthFunction

Specifies the depth function.

ubyte_t depthTestingEnabled

Specifies if depth testing is enabled.

ubyte_t depthWritingEnabled

Specifies if depth writing is enabled.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


Member List

NBFDepthAttribute Member List

This is the complete list of members for NBFDepthAttribute, including all inherited members.
depthFunction | NBFDepthAttribute
depthTestingEnabled | NBFDepthAttribute
depthWritingEnabled | NBFDepthAttribute
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(5) | NBFDepthAttribute
NBFStateAttribute::PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


NBFDirectedLight Struct Reference

#include <NBF.h>

Inheritance diagram for NBFDirectedLight:

[legend]
Collaboration diagram for NBFDirectedLight:

[legend]
List of all members.

Public Member Functions

PADDING (4)

Public Attributes

float3_t direction
Specifies the direction of the light source.

Detailed Description

The object code for a NBFDirectedLight is NBF_DIRECTED_LIGHT.

Member Data Documentation

float3_t direction

Specifies the direction of the light source.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


Member List

NBFDirectedLight Member List

This is the complete list of members for NBFDirectedLight, including all inherited members.
ambientColor | NBFLightSource
animation | NBFLightSource
castShadow | NBFLightSource
diffuseColor | NBFLightSource
direction | NBFDirectedLight
enabled | NBFLightSource
intensity | NBFLightSource
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) (defined in NBFDirectedLight) | NBFDirectedLight
NBFLightSource::PADDING(2) | NBFLightSource
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
specularColor | NBFLightSource
Generated on Tue Jan 15 10:28:36 2008 for NVSGSDK by NVIDIA


NBFDrawable Struct Reference

The NBFDrawable represents any kind of a drawable object. More...

#include <NBF.h>

Inheritance diagram for NBFDrawable:

[legend]
Collaboration diagram for NBFDrawable:

[legend]
List of all members.

Detailed Description

The NBFDrawable represents any kind of a drawable object.

A NBFDrawable serves a base class only.
Concrete object codes valid for a NBFDrawable are NBF_TRIANGLES, NBF_ANIMATED_TRIANGLES, NBF_SKINNED_TRIANGLES, NBF_TRIFANS, and NBF_TRISTRIPS. Further object codes valid for a NBFDrawable are subject to future extensions of the NBF format.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


Member List

NBFDrawable Member List

This is the complete list of members for NBFDrawable, including all inherited members.
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


NBFFaceAttribute Struct Reference

The NBFFaceAttribute structure represents a render mode. More...

#include <NBF.h>

Inheritance diagram for NBFFaceAttribute:

[legend]
Collaboration diagram for NBFFaceAttribute:

[legend]
List of all members.

Public Member Functions

PADDING (2)
Padding bits to ensure offset of polygonOffsetFactor is on a 4-byte boundary, regardless of packing.

PADDING (1)
Padding bits to ensure the size of NBFFaceAttribute is a multiple of 8, regardless of packing.

Public Attributes

ubyte_t cullMode
Specifies the face culling mode.

ubyte_t polygonOffsetEnabled
Specifies if polygon offset should be enabled for rendering.

float | polygonOffsetFactor
float | polygonOffsetUnits
ubyte_t twoSidedLighting
Specifies if two-sided lighting should be enabled for rendering.

ubyte_t frontFaceMode
Specifies the face mode (points/lines/faces) for front faces.

ubyte_t backFaceMode
Specifies the face mode (points/lines/faces) for back faces.

Detailed Description

The NBFFaceAttribute structure represents a render mode.

The object code for a NBFFaceAttribute is NBF_FACE_ATTRIBUTE.

Member Function Documentation

PADDING ( 2 )

Padding bits to ensure offset of polygonOffsetFactor is on a 4-byte boundary, regardless of packing.

PADDING ( 1 )

Padding bits to ensure the size of NBFFaceAttribute is a multiple of 8, regardless of packing.

Member Data Documentation

ubyte_t cullMode

Specifies the face culling mode.

ubyte_t polygonOffsetEnabled

Specifies if polygon offset should be enabled for rendering.

float polygonOffsetFactor

Specifies the scale factor to be used to create a variable depth offset < for a polygon.

float polygonOffsetUnits

Specifies a unit that is multiplied by a render API implementation-specific < value to create a constant depth offset.

ubyte_t twoSidedLighting

Specifies if two-sided lighting should be enabled for rendering.

ubyte_t frontFaceMode

Specifies the face mode (points/lines/faces) for front faces.

ubyte_t backFaceMode

Specifies the face mode (points/lines/faces) for back faces.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


Member List

NBFFaceAttribute Member List

This is the complete list of members for NBFFaceAttribute, including all inherited members.
backFaceMode | NBFFaceAttribute
cullMode | NBFFaceAttribute
frontFaceMode | NBFFaceAttribute
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(2) | NBFFaceAttribute
PADDING(1) | NBFFaceAttribute
NBFStateAttribute::PADDING(3) | NBFObject
polygonOffsetEnabled | NBFFaceAttribute
polygonOffsetFactor | NBFFaceAttribute
polygonOffsetUnits | NBFFaceAttribute
sourceObject | NBFObject
twoSidedLighting | NBFFaceAttribute
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


NBFFlipbookAnimation Struct Reference

The NBFFlipbookAnimation structure represents an animated group node. More...

#include <NBF.h>

Inheritance diagram for NBFFlipbookAnimation:

[legend]
Collaboration diagram for NBFFlipbookAnimation:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFFlipbookAnimation is a multiple of 8, regardless of packing.

Public Attributes

uint_t animation

Detailed Description

The NBFFlipbookAnimation structure represents an animated group node.

The object code for a NBFFlipbookAnimation is NBF_FLIPBOOK_ANIMATION.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFFlipbookAnimation is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t animation

Specifies the file offset to the NBFIndexAnimation object < to be applied to the transform group node.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


Member List

NBFFlipbookAnimation Member List

This is the complete list of members for NBFFlipbookAnimation, including all inherited members.
animation | NBFFlipbookAnimation
annotation | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
lightSources | NBFGroup
numChildren | NBFGroup
numClipPlanes | NBFGroup
numLightSource | NBFGroup
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFFlipbookAnimation
NBFGroup::PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


NBFFramedAnimation Struct Reference

The NBFFramedAnimation structure represents a framed animation. More...

#include <NBF.h>

Inheritance diagram for NBFFramedAnimation:

[legend]
Collaboration diagram for NBFFramedAnimation:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFFramedIndexAnimation is a multiple of 8, regardless of packing.

Public Attributes

uint_t numSteps

Detailed Description

The NBFFramedAnimation structure represents a framed animation.

A NBFFramedAnimation serves as base class only and needs to be considered in conjunction with either NBFIndexAnimation, NBFTrafoAnimation or NBFVertexAttributeAnimation.
Concrete object codes valid for a NBFFramedAnimation are NBF_FRAMED_INDEX_ANIMATION, NBF_FRAMED_TRAFO_ANIMATION, and NBF_FRAMED_VERTEX_ATTRIBUTE_ANIMATION. Further concrete object codes valid for NBFFramedAnimation objects are subject to future extensions of the NBF format.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFFramedIndexAnimation is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t numSteps

Specifies the number of animation steps.
< In conjunction with a NBFIndexAnimation, this corresponds to the number of < uint_t objects stored with a NBFTrafoAnimation.
< In conjunction with a NBFTrafoAnimation, this corresponds to the number of < trafo_t objects stored with a NBFTrafoAnimation.
< In conjunction with a NBFVertexAttributeAnimation, this corresponds to the number of < VertexAttribute sets stored with a NBFVertexAttributeAnimation.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


Member List

NBFFramedAnimation Member List

This is the complete list of members for NBFFramedAnimation, including all inherited members.
forward | NBFAnimation
loopCount | NBFAnimation
numSteps | NBFFramedAnimation
PADDING(4) | NBFFramedAnimation
NBFAnimation::PADDING(6) | NBFAnimation
speed | NBFAnimation
swinging | NBFAnimation
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


NBFFramedIndexAnimation Struct Reference

The NBFFramedIndexAnimation structure represents a framed animation that will be applied to uint_t objects. More...

#include <NBF.h>

Inheritance diagram for NBFFramedIndexAnimation:

[legend]
Collaboration diagram for NBFFramedIndexAnimation:

[legend]
List of all members.

Detailed Description

The NBFFramedIndexAnimation structure represents a framed animation that will be applied to uint_t objects.

A NBFFramedIndexAnimation is a concrete animation type. It publicly inherits from NBFIndexAnimation and NBFFramedAnimation. The object code for a NBFFramedIndexAnimation is NBF_FRAMED_INDEX_ANIMATION.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


Member List

NBFFramedIndexAnimation Member List

This is the complete list of members for NBFFramedIndexAnimation, including all inherited members.
forward | NBFAnimation
indices | NBFIndexAnimation
isShared | NBFObject
loopCount | NBFAnimation
numSteps | NBFFramedAnimation
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
NBFIndexAnimation::PADDING(4) | NBFIndexAnimation
NBFIndexAnimation::NBFObject::PADDING(3) | NBFObject
NBFFramedAnimation::PADDING(4) | NBFFramedAnimation
NBFAnimation::PADDING(6) | NBFAnimation
sourceObject | NBFObject
speed | NBFAnimation
swinging | NBFAnimation
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


NBFFramedTrafoAnimation Struct Reference

The NBFFramedTrafoAnimation structure represents a framed animation that will be applied to trafo_t objects. More...

#include <NBF.h>

Inheritance diagram for NBFFramedTrafoAnimation:

[legend]
Collaboration diagram for NBFFramedTrafoAnimation:

[legend]
List of all members.

Detailed Description

The NBFFramedTrafoAnimation structure represents a framed animation that will be applied to trafo_t objects.

A NBFFramedTrafoAnimation is a concrete animation type. It publicly inherits from NBFTrafoAnimation and NBFFramedAnimation. The object code for a NBFFramedTrafoAnimation is NBF_FRAMED_TRAFO_ANIMATION.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


Member List

NBFFramedTrafoAnimation Member List

This is the complete list of members for NBFFramedTrafoAnimation, including all inherited members.
forward | NBFAnimation
isShared | NBFObject
loopCount | NBFAnimation
numSteps | NBFFramedAnimation
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
NBFTrafoAnimation::PADDING(4) | NBFTrafoAnimation
NBFTrafoAnimation::NBFObject::PADDING(3) | NBFObject
NBFFramedAnimation::PADDING(4) | NBFFramedAnimation
NBFAnimation::PADDING(6) | NBFAnimation
sourceObject | NBFObject
speed | NBFAnimation
swinging | NBFAnimation
trafos | NBFTrafoAnimation
Generated on Tue Jan 15 10:28:37 2008 for NVSGSDK by NVIDIA


NBFFramedVertexAttributeAnimation Struct Reference

The NBFFramedVertexAttributeAnimation structure represents a framed animation that will be applied to vertexAttrib_t objects. More...

#include <NBF.h>

Inheritance diagram for NBFFramedVertexAttributeAnimation:

[legend]
Collaboration diagram for NBFFramedVertexAttributeAnimation:

[legend]
List of all members.

Detailed Description

The NBFFramedVertexAttributeAnimation structure represents a framed animation that will be applied to vertexAttrib_t objects.

A NBFFramedVertexAttributeAnimation is a concrete animation type. It publicly inherits from NBFVertexAttributeAnimation and NBFFramedAnimation. The object code for a NBFFramedVertexAttributeAnimation is NBF_FRAMED_VERTEX_ATTRIBUTE_ANIMATION.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


Member List

NBFFramedVertexAttributeAnimation Member List

This is the complete list of members for NBFFramedVertexAttributeAnimation, including all inherited members.
attribs | NBFVertexAttributeAnimation
forward | NBFAnimation
isShared | NBFObject
loopCount | NBFAnimation
numSteps | NBFFramedAnimation
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
NBFVertexAttributeAnimation::PADDING(4) | NBFVertexAttributeAnimation
NBFVertexAttributeAnimation::NBFObject::PADDING(3) | NBFObject
NBFFramedAnimation::PADDING(4) | NBFFramedAnimation
NBFAnimation::PADDING(6) | NBFAnimation
sourceObject | NBFObject
speed | NBFAnimation
swinging | NBFAnimation
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


NBFGeoNode Struct Reference

The NBFGeoNode structure represents a geometry node. More...

#include <NBF.h>

Inheritance diagram for NBFGeoNode:

[legend]
Collaboration diagram for NBFGeoNode:

[legend]
List of all members.

Public Attributes

uint_t numGeometrySets
Specifies the number of contained geometry sets.

uint_t geometrySets
Specifies the file offset to the geometry sets. Geometry sets are stored as geometrySet_t objects.

Detailed Description

The NBFGeoNode structure represents a geometry node.

The object code for a NBFGeoNode is NBF_GEO_NODE.

Member Data Documentation

uint_t numGeometrySets

Specifies the number of contained geometry sets.

uint_t geometrySets

Specifies the file offset to the geometry sets. Geometry sets are stored as geometrySet_t objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


Member List

NBFGeoNode Member List

This is the complete list of members for NBFGeoNode, including all inherited members.
annotation | NBFNode
geometrySets | NBFGeoNode
isShared | NBFObject
numGeometrySets | NBFGeoNode
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


NBFGroup Struct Reference

The NBFGroup structure represents a group node. More...

#include <NBF.h>

Inheritance diagram for NBFGroup:

[legend]
Collaboration diagram for NBFGroup:

[legend]
List of all members.

Public Attributes

uint_t numChildren
Specifies the number of maintained children.

uint_t children
uint_t numClipPlanes
Specifies the number of clipping planes.

uint_t clipPlanes
Specifies the file offset to the clipping planes.

uint_t numLightSource
Specifies the number of light sources.

uint_t lightSources
Specifies the fie offset to the offsets to the light sources.

Detailed Description

The NBFGroup structure represents a group node.

A NBFGroup serves as base class only. Concrete object codes valid for a NBFGroup are NBF_LOD, NBF_SWITCH, NBF_TRANSFORM, and NBF_ANIMATED_TRANSFORM. Further concrete object codes valid for a NBFGroup are subject to future extensions of the NBF format.

Member Data Documentation

uint_t numChildren

Specifies the number of maintained children.

uint_t children

Specifies the file offset to the offsets to the maintained children. < NBFGroup's children always are of NBFNode-derived types.

uint_t numClipPlanes

Specifies the number of clipping planes.

uint_t clipPlanes

Specifies the file offset to the clipping planes.

uint_t numLightSource

Specifies the number of light sources.

uint_t lightSources

Specifies the fie offset to the offsets to the light sources.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


Member List

NBFGroup Member List

This is the complete list of members for NBFGroup, including all inherited members.
annotation | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
lightSources | NBFGroup
numChildren | NBFGroup
numClipPlanes | NBFGroup
numLightSource | NBFGroup
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


NBFHeader Struct Reference

The NBFHeader structure represents the NBF header format. More...

#include <NBF.h>

List of all members.

Public Member Functions

PADDING (2)
Padding bits to ensure offset of scene is on a 4-byte boundary, regardless of packing.

Public Attributes

byte_t | signature [4]
A 4-byte signature identifying the file as a valid NBF file. The bytes are "#NBF".

ubyte_t nbfMajorVersion
Specifies the major part of the NBF version used to save the file.

ubyte_t nbfMinorVersion
Specifies the minor part (compatibility level) of the NBF version used to save the file.

ubyte_t nbfBugfixLevel
ubyte_t nvsgMajorVersion
Specifies the major part of the NVSG version the content of this file is compatible to.

ubyte_t nvsgMinorVersion
Specifies the minor part of the NVSG version the content of this file is compatible to.

ubyte_t nvsgBugfixLevel
ubyte_t | reserved [16]
Reserved bytes for future extensions.

ubyte_t dayLastModified
Specifies the day (1-31) of last modification.

ubyte_t monthLastModified
Specifies the month (1-12) of last modification.

ubyte_t | yearLastModified [2]
Specifies the year of last modification.

ubyte_t secondLastModified
Specifies the second (0-59) of last modification.

ubyte_t minuteLastModified
Specifies the minute (0-59) of last modification.

ubyte_t hourLastModified
Specifies the hour (0-23) of last modification.

ubyte_t byteOrder
uint_t scene
Specifies the file offset to the contained NBFScene object.

uint_t viewState

Detailed Description

The NBFHeader structure represents the NBF header format.

The NBFHeader structure is the primary location where NBF specifics are stored.
For a valid NBF file, the NBFHeader structure is stored at file offset 0. Note that, except for the NBFHeader object, a file offset of 0 indicates an invalid file offset!
This structure mainly serves as validation and compatibility checks for verification purposes. It also maintains the file offset to the contained NBFScene object, which represents a scene in the context of computer graphics.

Member Function Documentation

PADDING ( 2 )

Padding bits to ensure offset of scene is on a 4-byte boundary, regardless of packing.

Member Data Documentation

byte_t signature[4]

A 4-byte signature identifying the file as a valid NBF file. The bytes are "#NBF".

ubyte_t nbfMajorVersion

Specifies the major part of the NBF version used to save the file.

ubyte_t nbfMinorVersion

Specifies the minor part (compatibility level) of the NBF version used to save the file.

ubyte_t nbfBugfixLevel

Specifies the bugfix level of the NBF version used to save the file. This is optional < information, as a bugfix level does not influence compatibility issues, and hence < must not be taken into account for compatibility checks.

ubyte_t nvsgMajorVersion

Specifies the major part of the NVSG version the content of this file is compatible to.

ubyte_t nvsgMinorVersion

Specifies the minor part of the NVSG version the content of this file is compatible to.

ubyte_t nvsgBugfixLevel

Specifies the bugfix level of the NVSG version. This is optional information, as a < bugfix level does not influence compatibility issues, and hence must not be taken < into account for compatibility checks.

ubyte_t reserved[16]

Reserved bytes for future extensions.

ubyte_t dayLastModified

Specifies the day (1-31) of last modification.

ubyte_t monthLastModified

Specifies the month (1-12) of last modification.

ubyte_t yearLastModified[2]

Specifies the year of last modification.

ubyte_t secondLastModified

Specifies the second (0-59) of last modification.

ubyte_t minuteLastModified

Specifies the minute (0-59) of last modification.

ubyte_t hourLastModified

Specifies the hour (0-23) of last modification.

ubyte_t byteOrder

Specifies the byte order used to save the contained data. < A value of 0 implies little-endian byte order, a value of 1 implies big-endian byte order. < It is more convenient to use the symbolic constants NBF_LITTLE_ENDIAN and NBF_BIG_ENDIAN here.

uint_t scene

Specifies the file offset to the contained NBFScene object.

uint_t viewState

Specifies the file offset to an optional NBFViewState object. < An offset of 0 indicates that no NBFViewState object is available in this file.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


Member List

NBFHeader Member List

This is the complete list of members for NBFHeader, including all inherited members.
byteOrder | NBFHeader
dayLastModified | NBFHeader
hourLastModified | NBFHeader
minuteLastModified | NBFHeader
monthLastModified | NBFHeader
nbfBugfixLevel | NBFHeader
nbfMajorVersion | NBFHeader
nbfMinorVersion | NBFHeader
nvsgBugfixLevel | NBFHeader
nvsgMajorVersion | NBFHeader
nvsgMinorVersion | NBFHeader
PADDING(2) | NBFHeader
reserved | NBFHeader
scene | NBFHeader
secondLastModified | NBFHeader
signature | NBFHeader
viewState | NBFHeader
yearLastModified | NBFHeader
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


NBFIndependentPrimitiveSet Struct Reference

The NBFIndependentPrimitiveSet structure represents a set of independent primitives. More...

#include <NBF.h>

Inheritance diagram for NBFIndependentPrimitiveSet:

[legend]
Collaboration diagram for NBFIndependentPrimitiveSet:

[legend]
List of all members.

Public Attributes

uint_t numIndices
Specifies the number of contained indices.

uint_t indices
Specifies the file offset to the Independent objects.

Detailed Description

The NBFIndependentPrimitiveSet structure represents a set of independent primitives.

A NBFIndependentPrimitiveSet is an abstract topology class derived from NBFPrimitiveSet. It is used with NBF_LINES, NBF_POINTS, NBF_QUADS, and NBF_TRIANGLES.

Member Data Documentation

uint_t numIndices

Specifies the number of contained indices.

uint_t indices

Specifies the file offset to the Independent objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


Member List

NBFIndependentPrimitiveSet Member List

This is the complete list of members for NBFIndependentPrimitiveSet, including all inherited members.
indices | NBFIndependentPrimitiveSet
isShared | NBFObject
numIndices | NBFIndependentPrimitiveSet
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
skin | NBFPrimitiveSet
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


NBFIndexAnimation Struct Reference

The NBFIndexAnimation represents an animation that will be applied to uint_t objects. More...

#include <NBF.h>

Inheritance diagram for NBFIndexAnimation:

[legend]
Collaboration diagram for NBFIndexAnimation:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFIndexAnimation is a multiple of 8, regardless of packing.

Public Attributes

uint_t indices

Detailed Description

The NBFIndexAnimation represents an animation that will be applied to uint_t objects.

A NBFIndexAnimation serves as base class only and needs to be considered in conjunction with NBFFramedAnimation.
Valid object code for a NBFIndexAnimation is NBF_FRAMED_INDEX_ANIMATION. Further concrete object codes valid for NBFIndexAnimation objects are subject to future extensions of the NBF format.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFIndexAnimation is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t indices

Specifies the file offset to the uint_t objects the animation will be applied to. < The actual number of uint_t objects is specified by the corresponding animation < type, which is NBFFramedAnimation.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


Member List

NBFIndexAnimation Member List

This is the complete list of members for NBFIndexAnimation, including all inherited members.
indices | NBFIndexAnimation
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFIndexAnimation
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


NBFInterpolatedAnimation Struct Reference

The NBFInterpolatedAnimation structure represents a interpolated animation. More...

#include <NBF.h>

Inheritance diagram for NBFInterpolatedAnimation:

[legend]
Collaboration diagram for NBFInterpolatedAnimation:

[legend]
List of all members.

Public Attributes

uint_t numKeys
Specifies the number of key frames.

uint_t keys

Detailed Description

The NBFInterpolatedAnimation structure represents a interpolated animation.

A NBFInterpolatedAnimation serves as base class only and needs to be considered in conjunction with either NBFTrafoAnimation or NBFVertexAttributeAnimation.
Concrete object codes valid for a NBFInterpolatedAnimation are NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION and NBF_LINEAR_INTERPOLATED_VERTEX_ATTRIBUTE_ANIMATION. Further concrete object codes valid for NBFInterpolatedAnimation objects are subject to future extensions of the NBF format.

Member Data Documentation

uint_t numKeys

Specifies the number of key frames.

uint_t keys

Specifies the file offset to the key frames. As specified in the NBF format, < a key is a 32-bit unsigned integer value.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


Member List

NBFInterpolatedAnimation Member List

This is the complete list of members for NBFInterpolatedAnimation, including all inherited members.
forward | NBFAnimation
keys | NBFInterpolatedAnimation
loopCount | NBFAnimation
numKeys | NBFInterpolatedAnimation
PADDING(6) | NBFAnimation
speed | NBFAnimation
swinging | NBFAnimation
Generated on Tue Jan 15 10:28:38 2008 for NVSGSDK by NVIDIA


NBFInterpolatedTrafoAnimation Struct Reference

The NBFInterpolatedTrafoAnimation structure represents a interpolated animation that will be applied to trafo_t objects. More...

#include <NBF.h>

Inheritance diagram for NBFInterpolatedTrafoAnimation:

[legend]
Collaboration diagram for NBFInterpolatedTrafoAnimation:

[legend]
List of all members.

Detailed Description

The NBFInterpolatedTrafoAnimation structure represents a interpolated animation that will be applied to trafo_t objects.

A NBFInterpolatedTrafoAnimation is a concrete animation type. It publicly inherits from NBFTrafoAnimation and NBFInterpolatedAnimation.
The object code valid for a NBFInterpolatedTrafoAnimation is NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION. Further object codes valid for NBFInterpolatedTrafoAnimation objects are subject to future extensions of the NBF format.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


Member List

NBFInterpolatedTrafoAnimation Member List

This is the complete list of members for NBFInterpolatedTrafoAnimation, including all inherited members.
forward | NBFAnimation
isShared | NBFObject
keys | NBFInterpolatedAnimation
loopCount | NBFAnimation
numKeys | NBFInterpolatedAnimation
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
NBFTrafoAnimation::PADDING(4) | NBFTrafoAnimation
NBFTrafoAnimation::NBFObject::PADDING(3) | NBFObject
NBFInterpolatedAnimation::PADDING(6) | NBFAnimation
sourceObject | NBFObject
speed | NBFAnimation
swinging | NBFAnimation
trafos | NBFTrafoAnimation
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


NBFInterpolatedVertexAttributeAnimation Struct Reference

The NBFInterpolatedVertexAttributeAnimation structure represents a interpolated animation that will be applied to vertexAttrib_t objects. More...

#include <NBF.h>

Inheritance diagram for NBFInterpolatedVertexAttributeAnimation:

[legend]
Collaboration diagram for NBFInterpolatedVertexAttributeAnimation:

[legend]
List of all members.

Detailed Description

The NBFInterpolatedVertexAttributeAnimation structure represents a interpolated animation that will be applied to vertexAttrib_t objects.

A NBFInterpolatedVertexAttributeAnimation is a concrete animation type. It publicly inherits from NBFVertexAttributeAnimation and NBFInterpolatedAnimation.
The object code valid for a NBFInterpolatedVertexAttributeAnimation is NBF_LINEAR_INTERPOLATED_VERTEX_ATTRIBUTE_ANIMATION. Further object codes valid for NBFInterpolatedVertexAttributeAnimation objects are subject to future extensions of the NBF format.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


Member List

NBFInterpolatedVertexAttributeAnimation Member List

This is the complete list of members for NBFInterpolatedVertexAttributeAnimation, including all inherited members.
attribs | NBFVertexAttributeAnimation
forward | NBFAnimation
isShared | NBFObject
keys | NBFInterpolatedAnimation
loopCount | NBFAnimation
numKeys | NBFInterpolatedAnimation
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
NBFVertexAttributeAnimation::PADDING(4) | NBFVertexAttributeAnimation
NBFVertexAttributeAnimation::NBFObject::PADDING(3) | NBFObject
NBFInterpolatedAnimation::PADDING(6) | NBFAnimation
sourceObject | NBFObject
speed | NBFAnimation
swinging | NBFAnimation
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


NBFLightingAttribute Struct Reference

The NBFLightingAttribute structure represents a render mode. More...

#include <NBF.h>

Inheritance diagram for NBFLightingAttribute:

[legend]
Collaboration diagram for NBFLightingAttribute:

[legend]
List of all members.

Public Member Functions

PADDING (3)
Padding bits ensure offset of next elements is on a 4-byte boundary, regardless of packing.

Public Attributes

ubyte_t enabled
Specifies if lighting is enabled or disabled.

Detailed Description

The NBFLightingAttribute structure represents a render mode.

The object code for a NBFLightingAttribute is NBF_LIGHTING_ATTRIBUTE.

Member Function Documentation

PADDING ( 3 )

Padding bits ensure offset of next elements is on a 4-byte boundary, regardless of packing.

Reimplemented from NBFObject.

Member Data Documentation

ubyte_t enabled

Specifies if lighting is enabled or disabled.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


Member List

NBFLightingAttribute Member List

This is the complete list of members for NBFLightingAttribute, including all inherited members.
enabled | NBFLightingAttribute
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFLightingAttribute
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


NBFLightSource Struct Reference

The NBFLightSource structure represents a light source node. More...

#include <NBF.h>

Inheritance diagram for NBFLightSource:

[legend]
Collaboration diagram for NBFLightSource:

[legend]
List of all members.

Public Member Functions

PADDING (2)
Padding bits to ensure the offset of the next struct member is on a 4-byte boundary.

Public Attributes

float intensity
Specifies the light intensity.

float3_t ambientColor
Specifies the ambient color term of the light.

float3_t diffuseColor
Specifies the diffuse color term of the light.

float3_t specularColor
Specifies the specular color term of the light.

ubyte_t castShadow
flag that determines if this light source creates shadows.

ubyte_t enabled
flag to indicate enabled state.

uint_t animation

Detailed Description

The NBFLightSource structure represents a light source node.

A NBFLightSource serves as base class only. Concrete object codes valid for a NBFLightSource are NBF_DIRECTED_LIGHT, NBF_POINT_LIGHT, and NBF_SPOT_LIGHT.

Member Function Documentation

PADDING ( 2 )

Padding bits to ensure the offset of the next struct member is on a 4-byte boundary.

Member Data Documentation

float intensity

Specifies the light intensity.

float3_t ambientColor

Specifies the ambient color term of the light.

float3_t diffuseColor

Specifies the diffuse color term of the light.

float3_t specularColor

Specifies the specular color term of the light.

ubyte_t castShadow

flag that determines if this light source creates shadows.

ubyte_t enabled

flag to indicate enabled state.

uint_t animation

Specifies the file offset to an optional NBFTrafoAnimation object < to be applied to the light transform (orientation and translation).

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


Member List

NBFLightSource Member List

This is the complete list of members for NBFLightSource, including all inherited members.
ambientColor | NBFLightSource
animation | NBFLightSource
castShadow | NBFLightSource
diffuseColor | NBFLightSource
enabled | NBFLightSource
intensity | NBFLightSource
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(2) | NBFLightSource
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
specularColor | NBFLightSource
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


NBFLineAttribute Struct Reference

The NBFLineAttribute structure represents a render mode. More...

#include <NBF.h>

Inheritance diagram for NBFLineAttribute:

[legend]
Collaboration diagram for NBFLineAttribute:

[legend]
List of all members.

Public Member Functions

PADDING (3)
Padding bits ensure offset of next elements is on a 4-byte boundary, regardless of packing.

Public Attributes

ubyte_t antiAliasing
Specifies if the lines are anti aliased.

uint_t stippleFactor
Specifies the stipple factor.

uint_t stipplePattern
Specifies the stipple pattern.

float width
Specifies the line width.

Detailed Description

The NBFLineAttribute structure represents a render mode.

The object code for a NBFLineAttribute is NBF_LINE_ATTRIBUTE.

Member Function Documentation

PADDING ( 3 )

Padding bits ensure offset of next elements is on a 4-byte boundary, regardless of packing.

Reimplemented from NBFObject.

Member Data Documentation

ubyte_t antiAliasing

Specifies if the lines are anti aliased.

uint_t stippleFactor

Specifies the stipple factor.

uint_t stipplePattern

Specifies the stipple pattern.

float width

Specifies the line width.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


Member List

NBFLineAttribute Member List

This is the complete list of members for NBFLineAttribute, including all inherited members.
antiAliasing | NBFLineAttribute
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFLineAttribute
sourceObject | NBFObject
stippleFactor | NBFLineAttribute
stipplePattern | NBFLineAttribute
width | NBFLineAttribute
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


NBFLoader Class Reference

A Scene Loader for nbf files. More...

#include <NBFLoader.h>

Inheritance diagram for NBFLoader:

[legend]
Collaboration diagram for NBFLoader:

[legend]
List of all members.

Public Member Functions

void | deleteThis (void)
Realization of the pure virtual interface function of a PlugIn.

nvsg::SceneHandle * | load (const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState)
Realization of the pure virtual interface function of a SceneLoader.

Protected Member Functions

virtual | ~NBFLoader (void)
Protected destructor to prevent explicit creation on stack.

virtual nvsg::ObjectHandle * | loadCustomObject (uint_t objectCode, uint_t offset)
Load a custom object identified by objectCode from the file offset specified by offset.

ubyte_t * | mapOffset (uint_t offset, unsigned int numBytes)
Maps numBytes bytes at file offset offset into process memory.

void | unmapOffset (ubyte_t *offsetPtr)
Unmaps the memory that previously was mapped through mapOffset from the process' address space.

Detailed Description

A Scene Loader for nbf files.

Constructor & Destructor Documentation

virtual ~NBFLoader ( void ) [protected, virtual]

Protected destructor to prevent explicit creation on stack.

Member Function Documentation

void deleteThis ( void ) [inline, virtual]

Realization of the pure virtual interface function of a PlugIn.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

nvsg::SceneHandle* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | nvsg::ViewStateHandle *& | viewState
 | ) | [virtual]

Realization of the pure virtual interface function of a SceneLoader.

Loads a nvb file given by filename. It looks for this file and possibly referenced other files like textures or effects at the given path first, then at the current location and finally it searches through the searchPaths.

Returns:
A pointer to the loaded scene.
Parameters:
filename | file to load
searchPaths | paths to search through
viewState | If the function succeeded, this points to the optional ViewState stored with the scene.

Implements SceneLoader.

virtual nvsg::ObjectHandle* loadCustomObject | ( | uint_t | objectCode,
 |  | uint_t | offset
 | ) | [protected, virtual]

Load a custom object identified by objectCode from the file offset specified by offset.

This function is called from the loader's framework if a custom object was detected for the object stored at the particular file offset.

A custom implementation should first evaluate the passed object code. To map identified objects into memory, a custom implementation should call the member function mapOffset with the file offset and the correct byte size for the identified object as parameters. After that, the corresponding NVSG object can be initialized from the mapped data.

Returns:
A pointer to a ObjectHandle specifying the loaded NVSG object.
Note:
A custom implementation must not fall back on to the base implementation, as this simply returns a null pointer.
Parameters:
objectCode | NBF object code identifying the custom object.
offset | Specifies the file offset for the custom object.

ubyte_t * mapOffset | ( | uint_t | offset,
 |  | unsigned int | numBytes
 | ) | [inline, protected]

Maps numBytes bytes at file offset offset into process memory.

This function turns a given offset into a pointer and ensures that a minimum of numBytes bytes are mapped.

Returns:
A pointer to the mapped memory.
Parameters:
offset | File offset of the memory block to map.
numBytes | Amount of bytes to map into process memory.

void unmapOffset ( ubyte_t * offsetPtr ) [inline, protected]

Unmaps the memory that previously was mapped through mapOffset from the process' address space.

The function accepts a pointer to the mapped file offset that previously was received by a call to mapOffset.

Parameters:
offsetPtr Address where the file offset was mapped.

The documentation for this class was generated from the following file:
  • NBFLoader.h
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


Member List

NBFLoader Member List

This is the complete list of members for NBFLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | NBFLoader | [inline, virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState) | NBFLoader | [virtual]
loadCustomObject(uint_t objectCode, uint_t offset) | NBFLoader | [protected, virtual]
mapOffset(uint_t offset, unsigned int numBytes) | NBFLoader | [inline, protected]
NBFLoader() (defined in NBFLoader) | NBFLoader |
PlugIn() (defined in PlugIn) | PlugIn | [inline]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
unmapOffset(ubyte_t *offsetPtr) | NBFLoader | [inline, protected]
~NBFLoader(void) | NBFLoader | [protected, virtual]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneLoader() | SceneLoader | [protected, virtual]
Generated on Tue Jan 15 10:28:39 2008 for NVSGSDK by NVIDIA


NBFLOD Struct Reference

The NBFLOD structure represents a 'Level Of Detail' group node. More...

#include <NBF.h>

Inheritance diagram for NBFLOD:

[legend]
Collaboration diagram for NBFLOD:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFLOD is a multiple of 8, regardless of packing.

Public Attributes

float3_t center
Specifies the center point used for distance calculations.

uint_t numRanges
Specifies the number of contained ranges.

uint_t ranges

Detailed Description

The NBFLOD structure represents a 'Level Of Detail' group node.

The object code for a NBFLOD is NBF_LOD.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFLOD is a multiple of 8, regardless of packing.

Member Data Documentation

float3_t center

Specifies the center point used for distance calculations.

uint_t numRanges

Specifies the number of contained ranges.

uint_t ranges

Specifies the file offset to the ranges. < Ranges are stored as 32-bit floating point numbers.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


Member List

NBFLOD Member List

This is the complete list of members for NBFLOD, including all inherited members.
annotation | NBFNode
center | NBFLOD
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
lightSources | NBFGroup
numChildren | NBFGroup
numClipPlanes | NBFGroup
numLightSource | NBFGroup
numRanges | NBFLOD
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFLOD
NBFGroup::PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
ranges | NBFLOD
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


NBFMaterial Struct Reference

The NBFMaterial structure represents a material. More...

#include <NBF.h>

Inheritance diagram for NBFMaterial:

[legend]
Collaboration diagram for NBFMaterial:

[legend]
List of all members.

Public Attributes

float3_t frontAmbientColor
Specifies the ambient part of the front material color.

float3_t frontDiffuseColor
Specifies the diffuse part of the front material color.

float3_t frontEmissiveColor
Specifies the emissive part of the front material color.

float | frontOpacity
Specifies the opacity of the front material.

float3_t frontSpecularColor
Specifies the specular part of the front material color.

float | frontSpecularExponent
Specifies the specular exponent of the front material color.

float3_t backAmbientColor
Specifies the ambient part of the back material color.

float3_t backDiffuseColor
Specifies the diffuse part of the back material color.

float3_t backEmissiveColor
Specifies the emissive part of the back material color.

float | backOpacity
Specifies the opacity of the back material.

float3_t backSpecularColor
Specifies the specular part of the back material color.

float | backSpecularExponent
Specifies the specular exponent of the back material color.

Detailed Description

The NBFMaterial structure represents a material.

The object code for a NBFMaterial is NBF_MATERIAL.

Member Data Documentation

float3_t frontAmbientColor

Specifies the ambient part of the front material color.

float3_t frontDiffuseColor

Specifies the diffuse part of the front material color.

float3_t frontEmissiveColor

Specifies the emissive part of the front material color.

float frontOpacity

Specifies the opacity of the front material.

float3_t frontSpecularColor

Specifies the specular part of the front material color.

float frontSpecularExponent

Specifies the specular exponent of the front material color.

float3_t backAmbientColor

Specifies the ambient part of the back material color.

float3_t backDiffuseColor

Specifies the diffuse part of the back material color.

float3_t backEmissiveColor

Specifies the emissive part of the back material color.

float backOpacity

Specifies the opacity of the back material.

float3_t backSpecularColor

Specifies the specular part of the back material color.

float backSpecularExponent

Specifies the specular exponent of the back material color.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


Member List

NBFMaterial Member List

This is the complete list of members for NBFMaterial, including all inherited members.
backAmbientColor | NBFMaterial
backDiffuseColor | NBFMaterial
backEmissiveColor | NBFMaterial
backOpacity | NBFMaterial
backSpecularColor | NBFMaterial
backSpecularExponent | NBFMaterial
frontAmbientColor | NBFMaterial
frontDiffuseColor | NBFMaterial
frontEmissiveColor | NBFMaterial
frontOpacity | NBFMaterial
frontSpecularColor | NBFMaterial
frontSpecularExponent | NBFMaterial
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


NBFMeshedPrimitiveSet Struct Reference

The NBFMeshedPrimitiveSet structure represents a mesh set. More...

#include <NBF.h>

Inheritance diagram for NBFMeshedPrimitiveSet:

[legend]
Collaboration diagram for NBFMeshedPrimitiveSet:

[legend]
List of all members.

Public Attributes

uint_t numMeshes
Specifies the number of meshes.

uint_t meshes
Strips are stored as indexSet_t objects.

Detailed Description

The NBFMeshedPrimitiveSet structure represents a mesh set.

A NBFMeshedPrimitiveSet is an abstract topology class derived from NBFPrimitiveSet. Valid object codes for a NBFMeshedPrimitiveSet are NBF_QUADMESHES.

Member Data Documentation

uint_t numMeshes

Specifies the number of meshes.

uint_t meshes

Strips are stored as indexSet_t objects.

Specifies the file offset to the meshes.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


Member List

NBFMeshedPrimitiveSet Member List

This is the complete list of members for NBFMeshedPrimitiveSet, including all inherited members.
isShared | NBFObject
meshes | NBFMeshedPrimitiveSet
numMeshes | NBFMeshedPrimitiveSet
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
skin | NBFPrimitiveSet
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


NBFNode Struct Reference

The NBFNode structure represents a general node. More...

#include <NBF.h>

Inheritance diagram for NBFNode:

[legend]
Collaboration diagram for NBFNode:

[legend]
List of all members.

Public Member Functions

PADDING (6)
Padding bits to ensure the size of NBFStateAttribute is a multiple of 4, regardless of packing.

Public Attributes

str_t annotation
Specifies an optional annotation string. Unused since v61.2!

ubyte_t systemHints
Specifies the system hints on this Node.

ubyte_t userHints
Specifies the user hints on this Node.

Detailed Description

The NBFNode structure represents a general node.

A NBFNode serves as base class only. Concrete object codes valid for a NBFNode are NBF_GEO_NODE, NBF_LOD, NBF_SWITCH, NBF_TRANSFORM, NBF_ANIMATED_TRANSFORM, NBF_DIRECTED_LIGHT, NBF_POINT_LIGHT, NBF_SPOT_LIGHT, and NBF_VOLUME_NODE. Further concrete object codes valid for a NBFNode are subject to future extensions of the NBF format.

Member Function Documentation

PADDING ( 6 )

Padding bits to ensure the size of NBFStateAttribute is a multiple of 4, regardless of packing.

Member Data Documentation

str_t annotation

Specifies an optional annotation string. Unused since v61.2!

ubyte_t systemHints

Specifies the system hints on this Node.

ubyte_t userHints

Specifies the user hints on this Node.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


Member List

NBFNode Member List

This is the complete list of members for NBFNode, including all inherited members.
annotation | NBFNode
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


NBFObject Struct Reference

The NBFObject structure represents general object data. More...

#include <NBF.h>

Inheritance diagram for NBFObject:

[legend]
Collaboration diagram for NBFObject:

[legend]
List of all members.

Public Member Functions

PADDING (3)
Padding bits to ensure offset of objectDataID is on a 8-byte boundary, regardless of packing.

Public Attributes

uint_t objectCode
Specifies the object code of the actual object. The object code is unique per object type!

ubyte_t isShared
uint64_t objectDataID
A unique 64-bit value to identify shared object data while loading.

uint_t sourceObject
sstr_t objectName
Specifies an optional name for the actual object.

sstr_t objectAnno
An optional annotation that can be specified for an object.

Detailed Description

The NBFObject structure represents general object data.

Member Function Documentation

PADDING ( 3 )

Padding bits to ensure offset of objectDataID is on a 8-byte boundary, regardless of packing.

Reimplemented in NBFCamera, NBFBillboard, NBFCgFx, NBFLightingAttribute, NBFLineAttribute, and NBFPointAttribute.

Member Data Documentation

uint_t objectCode

Specifies the object code of the actual object. The object code is unique per object type!

ubyte_t isShared

Indicates whether the data of the actual object is shared among different objects. < A value of 1 indicates that this object's data is shared, whereas a value of 0 indicates < that this object's data is not shared.

uint64_t objectDataID

A unique 64-bit value to identify shared object data while loading.

uint_t sourceObject

Specifies the file offset to the source object in case of data sharing. < A file offset of 0 always indicates that no source object is available for the actual object.

sstr_t objectName

Specifies an optional name for the actual object.

sstr_t objectAnno

An optional annotation that can be specified for an object.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


Member List

NBFObject Member List

This is the complete list of members for NBFObject, including all inherited members.
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


NBFParallelCamera Struct Reference

The NBFParallelCamera represents a parallel camera. More...

#include <NBF.h>

Inheritance diagram for NBFParallelCamera:

[legend]
Collaboration diagram for NBFParallelCamera:

[legend]
List of all members.

Detailed Description

The NBFParallelCamera represents a parallel camera.

A NBFParallelCamera is a concrete camera type. The object code for a NBFParallelCamera is NBF_PARALLEL_CAMERA.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


Member List

NBFParallelCamera Member List

This is the complete list of members for NBFParallelCamera, including all inherited members.
direction | NBFCamera
farDist | NBFCamera
focusDist | NBFCamera
headLights | NBFCamera
isAutoClipPlanes | NBFCamera
isShared | NBFObject
nearDist | NBFCamera
numHeadLights | NBFCamera
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFCamera
PADDING(4) | NBFCamera
position | NBFCamera
sourceObject | NBFObject
upVector | NBFCamera
windowOffset | NBFCamera
windowSize | NBFCamera
Generated on Tue Jan 15 10:28:40 2008 for NVSGSDK by NVIDIA


NBFPerspectiveCamera Struct Reference

The NBFPerspectiveCamera represents a perspective camera. More...

#include <NBF.h>

Inheritance diagram for NBFPerspectiveCamera:

[legend]
Collaboration diagram for NBFPerspectiveCamera:

[legend]
List of all members.

Detailed Description

The NBFPerspectiveCamera represents a perspective camera.

A NBFPerspectiveCamera is a concrete camera type. The object code for a NBFPerspectiveCamera is NBF_PERSPECTIVE_CAMERA.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


Member List

NBFPerspectiveCamera Member List

This is the complete list of members for NBFPerspectiveCamera, including all inherited members.
direction | NBFCamera
farDist | NBFCamera
focusDist | NBFCamera
headLights | NBFCamera
isAutoClipPlanes | NBFCamera
isShared | NBFObject
nearDist | NBFCamera
numHeadLights | NBFCamera
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFCamera
PADDING(4) | NBFCamera
position | NBFCamera
sourceObject | NBFObject
upVector | NBFCamera
windowOffset | NBFCamera
windowSize | NBFCamera
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


NBFPointAttribute Struct Reference

The NBFPointAttribute structure represents a render mode. More...

#include <NBF.h>

Inheritance diagram for NBFPointAttribute:

[legend]
Collaboration diagram for NBFPointAttribute:

[legend]
List of all members.

Public Member Functions

PADDING (3)
Padding bits ensure offset of next elements is on a 4-byte boundary, regardless of packing.

Public Attributes

ubyte_t antiAliasing
Specifies if the points are anti aliased.

float size
Specifies the point size.

Detailed Description

The NBFPointAttribute structure represents a render mode.

The object code for a NBFPointAttribute is NBF_POINT_ATTRIBUTE.

Member Function Documentation

PADDING ( 3 )

Padding bits ensure offset of next elements is on a 4-byte boundary, regardless of packing.

Reimplemented from NBFObject.

Member Data Documentation

ubyte_t antiAliasing

Specifies if the points are anti aliased.

float size

Specifies the point size.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


Member List

NBFPointAttribute Member List

This is the complete list of members for NBFPointAttribute, including all inherited members.
antiAliasing | NBFPointAttribute
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFPointAttribute
size | NBFPointAttribute
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


NBFPointLight Struct Reference

#include <NBF.h>

Inheritance diagram for NBFPointLight:

[legend]
Collaboration diagram for NBFPointLight:

[legend]
List of all members.

Public Attributes

float3_t position
Specifies the position of the light source.

float3_t attenuation

Detailed Description

The object code for a NBFPointLight is NBF_POINT_LIGHT.

Member Data Documentation

float3_t position

Specifies the position of the light source.

float3_t attenuation

Specifies the attenuation factors of the point light. < The x-component of the vector specifies the constant term of the attenuation, < the y-component of the vector specifies the linear term of the attenuation, and < the z-component of the vector specifies the quadratic term of the attenuation.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


Member List

NBFPointLight Member List

This is the complete list of members for NBFPointLight, including all inherited members.
ambientColor | NBFLightSource
animation | NBFLightSource
attenuation | NBFPointLight
castShadow | NBFLightSource
diffuseColor | NBFLightSource
enabled | NBFLightSource
intensity | NBFLightSource
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(2) | NBFLightSource
NBFObject::PADDING(3) | NBFObject
position | NBFPointLight
sourceObject | NBFObject
specularColor | NBFLightSource
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


NBFPrimitiveSet Struct Reference

The NBFPrimitiveSet structure represents a geometry with an NBFVertexAttributeSet. More...

#include <NBF.h>

Inheritance diagram for NBFPrimitiveSet:

[legend]
Collaboration diagram for NBFPrimitiveSet:

[legend]
List of all members.

Public Attributes

uint_t vertexAttributeSet
Specifies the file offset to the vertex attribute set.

uint_t skin
Specifies the file offset to the skin (from version 0x3e on!).

Detailed Description

The NBFPrimitiveSet structure represents a geometry with an NBFVertexAttributeSet.

A NBFPrimitiveSet holds the offset to an NBFVertexAttributeSet.

Member Data Documentation

uint_t vertexAttributeSet

Specifies the file offset to the vertex attribute set.

uint_t skin

Specifies the file offset to the skin (from version 0x3e on!).

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


Member List

NBFPrimitiveSet Member List

This is the complete list of members for NBFPrimitiveSet, including all inherited members.
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
skin | NBFPrimitiveSet
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


NBFSaver Class Reference

A scene saver capable to save a NVSG scene to a "NBF" (Nvsg Binary File format) file. More...

#include <NBFSaver.h>

Inheritance diagram for NBFSaver:

[legend]
Collaboration diagram for NBFSaver:

[legend]
List of all members.

Public Member Functions

NBFSaver ()
constructor

void | deleteThis (void)
PlugIn interface.

bool | save (nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState, const std::string &filename)
Realization of the pure virtual interface function of a SceneSaver.

Protected Attributes

NBFSaveTraverser * m_traverser
Save traverser to be used with saving.

Detailed Description

A scene saver capable to save a NVSG scene to a "NBF" (Nvsg Binary File format) file.

Constructor & Destructor Documentation

NBFSaver ( )

constructor

Member Function Documentation

void deleteThis ( void ) [inline, virtual]

PlugIn interface.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

bool save | ( | nvsg::SceneHandle * | scene,
 |  | nvsg::ViewStateHandle * | viewState,
 |  | const std::string & | filename
 | ) | [virtual]

Realization of the pure virtual interface function of a SceneSaver.

Saves the scene and the viewState to filename.

Parameters:
scene | scene to save
viewState | view state to save
filename | file name to save to

Implements SceneSaver.

Member Data Documentation

NBFSaveTraverser* m_traverser [protected]

Save traverser to be used with saving.

The documentation for this class was generated from the following file:
  • NBFSaver.h
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


Member List

NBFSaver Member List

This is the complete list of members for NBFSaver, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | NBFSaver | [inline, virtual]
m_traverser | NBFSaver | [protected]
NBFSaver() | NBFSaver |
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState, const std::string &filename) | NBFSaver | [virtual]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~NBFSaver() (defined in NBFSaver) | NBFSaver | [protected, virtual]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneSaver() | SceneSaver | [protected, virtual]
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


NBFSaveTraverser Class Reference

A Traverser to traverse a scene on saving to "NBF" binary file format. More...

#include <NBFSaver.h>

Inheritance diagram for NBFSaveTraverser:

[legend]
Collaboration diagram for NBFSaveTraverser:

[legend]
List of all members.

Public Member Functions

NBFSaveTraverser ()
Default constructor.

void | preCalculateFileSize (nvsg::SceneHandle *scene)
Calculate the expected file size.

void | setFileName (const std::string &fileName)
Set the file name to save the scene in.

void | setPlugInCallback (const nvutil::PlugInCallback *pic)
Set the PlugInCallback used for warnings and error messages.

bool | getSuccess () const
Get the success state of the latest saving operation.

Protected Member Functions

bool | calculatingStorageRequirements () const
Determine whether the current traverser pass is calculating storage requirements.

uint_t | alloc (void *&offsetPtr, unsigned int numBytes)
Allocate a portion of the currently mapped file into the process' address space.

void | dealloc (void *offsetPtr)
Deallocate a portion of memory that is currently mapped to a file.

uint_t | pseudoAlloc (unsigned int numBytes)
Add numBytes to the currently calculated file size.

virtual void | doApply (nvsg::NodeHandle *root)
Override of the traversal initiating interface.

virtual void | handleParallelCamera (const nvsg::ParallelCamera *camera)
Save a ParallelCamera.

virtual void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *camera)
Save a PerspectiveCamera.

virtual void | handleBillboard (const nvsg::Billboard *billboard)
Save a Billboard.

virtual void | handleGeoNode (const nvsg::GeoNode *gnode)
Save a GeoNode.

virtual void | handleVolumeNode (const nvsg::VolumeNode *vnode)
Save a VolumeNode.

virtual void | handleGroup (const nvsg::Group *group)
Save a Group.

virtual void | handleFlipbookAnimation (const nvsg::FlipbookAnimation *anim)
Save a FlipbookAnimation.

virtual void | handleTransform (const nvsg::Transform *trafo)
Save a Transform.

virtual void | handleAnimatedTransform (const nvsg::AnimatedTransform *trafo)
Save a AnimatedTransform.

virtual void | handleLOD (const nvsg::LOD *lod)
Save a LOD.

virtual void | handleSwitch (const nvsg::Switch *swtch)
Save a Switch.

virtual void | handleDirectedLight (const nvsg::DirectedLight *light)
Save a DirectedLight.

virtual void | handlePointLight (const nvsg::PointLight *light)
Save a PointLight.

virtual void | handleSpotLight (const nvsg::SpotLight *light)
Save a SpotLight.

virtual void | handleStateSet (const nvsg::StateSet *stateSet)
Save a StateSet.

virtual void | handleStateVariant (const nvsg::StateVariant *variant)
Save a StateVariant.

virtual void | handleStatePass (const nvsg::StatePass *pass)
Save a StatePass.

virtual void | handleAlphaTestAttribute (const nvsg::AlphaTestAttribute *alphaTestAttrib)
Save an AlphaTestAttribute.

virtual void | handleBlendAttribute (const nvsg::BlendAttribute *blendAttrib)
Save a BlendAttribute.

virtual void | handleCgFx (const nvsg::CgFx *cgfx)
Save a CgFx.

virtual void | handleDepthAttribute (const nvsg::DepthAttribute *depthAttrib)
Save a DepthAttribute.

virtual void | handleFaceAttribute (const nvsg::FaceAttribute *faceAttrib)
Save a FaceAttribute.

virtual void | handleLightingAttribute (const nvsg::LightingAttribute *lightingAttrib)
Save a LightingAttribute.

virtual void | handleLineAttribute (const nvsg::LineAttribute *lineAttrib)
Save a LineAttribute.

virtual void | handleMaterial (const nvsg::Material *material)
Save a Material.

virtual void | handlePointAttribute (const nvsg::PointAttribute *pointAttrib)
Save a PointAttribute.

virtual void | handleTextureAttribute (const nvsg::TextureAttribute *texAttrib)
Save a TextureAttribute.

virtual void | handleTextureAttributeItem (const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu)
Save a TextureAttributeItem.

virtual void | handleTriangles (const nvsg::Triangles *triangles)
Save a Triangles.

virtual void | handleSkinnedTriangles (const nvsg::SkinnedTriangles *triangles)
Save a SkinnedTriangles.

virtual void | handleTriFans (const nvsg::TriFans *fans)
Save a TriFans.

virtual void | handleTriStrips (const nvsg::TriStrips *strips)
Save a TriStrips.

virtual void | handleQuadMeshes (const nvsg::QuadMeshes *meshes)
Save a QuadMeshes.

virtual void | handleQuads (const nvsg::Quads *quads)
Save a Quads.

virtual void | handleQuadStrips (const nvsg::QuadStrips *strips)
Save a QuadStrips.

virtual void | handleLines (const nvsg::Lines *lines)
Save a Lines.

virtual void | handleLineStrips (const nvsg::LineStrips *strips)
Save a LineStrips.

virtual void | handlePoints (const nvsg::Points *points)
Save a Points.

virtual void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *vas)
Save a VertexAttributeSet.

virtual void | handleAnimatedVertexAttributeSet (const nvsg::AnimatedVertexAttributeSet *avas)
Save an AnimatedVertexAttributeSet.

virtual void | handleSkin (const nvsg::Skin *skin)
Save a Skin.

virtual void | handleFramedIndexAnimation (const nvsg::FramedAnimation< unsigned int > *trafo)
Save a FramedAnimation<unsigned int>.

virtual void | handleFramedTrafoAnimation (const nvsg::FramedAnimation< nvmath::Trafo > *trafo)
Save a FramedAnimation<Trafo>.

virtual void | handleFramedVertexAttributeAnimation (const nvsg::FramedAnimation< nvsg::VertexAttribute > *p)
Save a FramedAnimation<VertexAttribute>.

virtual void | handleLinearInterpolatedTrafoAnimation (const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo)
Save a LinearInterpolatedAnimation<Trafo>.

virtual void | handleLinearInterpolatedVertexAttributeAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p)
Save a LinearInterpolatedAnimation<VertexAttribute>.

virtual void | handleUnlitColorAttribute (const nvsg::UnlitColorAttribute *unlitColor)
Save an UnlitColorAttribute.

Detailed Description

A Traverser to traverse a scene on saving to "NBF" binary file format.

Remarks:
For each Object in the tree, the handle<Object> function is called twice from the NBFSaver framework. The first time it is called to calculate storage requirements, and the second time it is called to store the specified object to a file.
The implementation calls calculatingStorageRequirements to determine whether the storage requirement calculation is active or not. During storage requirement calculation no file mapping is available, and therefore no file offsets may be allocated. Within this calculation pass, the implementation uses pseudoAlloc instead of alloc. pseudoAlloc simply adds up the number of bytes required for the corresponding NBF structure and attached data The implementation uses alloc in the second pass to map the required amount of memory from the file mapping maintained by the NBFSaver. alloc returns a pointer to the file offset which is then used to write the corresponding NBF data to the file.

Constructor & Destructor Documentation

NBFSaveTraverser ( )

Default constructor.

Member Function Documentation

void preCalculateFileSize ( nvsg::SceneHandle * scene )

Calculate the expected file size.

Parameters:
scene A pointer to the SceneHandle to use in file size calculation.
Remarks:
In this function the complete scene is traversed once to determine the required file size.

void setFileName ( const std::string & fileName ) [inline]

Set the file name to save the scene in.

Parameters:
fileName The name of the file to save in.

void setPlugInCallback ( const nvutil::PlugInCallback * pic ) [inline]

Set the PlugInCallback used for warnings and error messages.

Parameters:
pic A pointer to the PlugInCallback object to use.
Remarks:
The PlugInCallback has a number of functions that are called in case an error or warning is to be reported while saving.

bool getSuccess ( ) const [inline]

Get the success state of the latest saving operation.

Returns:
true if the latest saving was successful, otherwise false.

bool calculatingStorageRequirements ( ) const [inline, protected]

Determine whether the current traverser pass is calculating storage requirements.

Returns:
true if the current pass is to calculate storage requirements, false if the current pass is to write the scene to a file that has been mapped into the process' address space by the framework.
Remarks:
While saving a scene, the scene graph will be traversed twice. The first pass is to calculate storage requirements. The second pass writes the scene data to a file that has been mapped into the process' address space by the framework.
Handler routines should call this function to determine what the current pass is intended for.
See also:
pseudoAlloc

uint_t alloc | ( | void *& | offsetPtr,
 |  | unsigned int | numBytes
 | ) | [protected]

Allocate a portion of the currently mapped file into the process' address space.

Parameters:
offsetPtr | A reference to the pointer to get the address of the mapped memory block.
numBytes | The number of bytes to be mapped into the process' address space.
Returns:
The file offset of the mapped memory block
Remarks:
The function maps the amount of numBytes bytes of the currently mapped file into the process' address space. The start address of the mapped memory block will be assigned to ptr.
Note:
The behavior is undefined if called while the current traverser pass is calculating storage requirements.
See also:
calculatingStorageRequirements, dealloc

void dealloc ( void * offsetPtr ) [protected]

Deallocate a portion of memory that is currently mapped to a file.

Parameters:
offsetPtr A mapped memory address, previously allocated with alloc.
Note:
: The memory, which is part of a potentially larger file mapping, actually won't be freed until that file mapping is unused (unreferenced).
See also:
alloc

uint_t pseudoAlloc ( unsigned int numBytes ) [protected]

Add numBytes to the currently calculated file size.

Parameters:
numBytes The number of bytes to add to the currently calculated file size.
Returns:
This function always returns zero.
Remarks:
The function does not allocate anything, it just adds numBytes to the currently calculated file size.
See also:
calculatingStorageRequirements

virtual void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Override of the traversal initiating interface.

Parameters:
root A pointer to the NodeHandle to use as the root of the save operation.
Remarks:
The framework calls this method to perform the file save operation. If a Scene and ViewState have been provided, they are locked before this function is called.

Reimplemented from SharedTraverser.

virtual void handleParallelCamera ( const nvsg::ParallelCamera * camera ) [protected, virtual]

Save a ParallelCamera.

Parameters:
camera A pointer to the read-locked ParallelCamera to save.
See also:
calculatingStorageRequirements, pseudoAlloc, handleParallelCamera

Reimplemented from SharedTraverser.

virtual void handlePerspectiveCamera ( const nvsg::PerspectiveCamera * camera ) [protected, virtual]

Save a PerspectiveCamera.

Parameters:
camera A pointer to the read-locked PerspectiveCamera to save.
See also:
calculatingStorageRequirements, pseudoAlloc, handlePerspectiveCamera

Reimplemented from SharedTraverser.

virtual void handleBillboard ( const nvsg::Billboard * billboard ) [protected, virtual]

Save a Billboard.

Parameters:
billboard A pointer to the read-locked Billboard to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleGeoNode ( const nvsg::GeoNode * gnode ) [protected, virtual]

Save a GeoNode.

Parameters:
gnode A pointer to the read-locked GeoNode to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleVolumeNode ( const nvsg::VolumeNode * vnode ) [protected, virtual]

Save a VolumeNode.

Parameters:
vnode A pointer to the read-locked VolumeNode to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleGroup ( const nvsg::Group * group ) [protected, virtual]

Save a Group.

Parameters:
group A pointer to the read-locked Group to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleFlipbookAnimation ( const nvsg::FlipbookAnimation * anim ) [protected, virtual]

Save a FlipbookAnimation.

Parameters:
anim A pointer to the read-locked FlipbookAnimation to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleTransform ( const nvsg::Transform * trafo ) [protected, virtual]

Save a Transform.

Parameters:
trafo A pointer to the read-locked Transform to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleAnimatedTransform ( const nvsg::AnimatedTransform * trafo ) [protected, virtual]

Save a AnimatedTransform.

Parameters:
trafo A pointer to the read-locked AnimatedTransform to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleLOD ( const nvsg::LOD * lod ) [protected, virtual]

Save a LOD.

Parameters:
lod A pointer to the read-locked LOD to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleSwitch ( const nvsg::Switch * swtch ) [protected, virtual]

Save a Switch.

Parameters:
swtch A pointer to the read-locked Switch to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleDirectedLight ( const nvsg::DirectedLight * light ) [protected, virtual]

Save a DirectedLight.

Parameters:
light A pointer to the read-locked DirectedLight to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handlePointLight ( const nvsg::PointLight * light ) [protected, virtual]

Save a PointLight.

Parameters:
light A pointer to the read-locked PointLight to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleSpotLight ( const nvsg::SpotLight * light ) [protected, virtual]

Save a SpotLight.

Parameters:
light A pointer to the read-locked SpotLight to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleStateSet ( const nvsg::StateSet * stateSet ) [protected, virtual]

Save a StateSet.

Parameters:
stateSet A pointer to the read-locked StateSet to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleStateVariant ( const nvsg::StateVariant * variant ) [protected, virtual]

Save a StateVariant.

Parameters:
variant A pointer to the read-locked StateVariant to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleStatePass ( const nvsg::StatePass * pass ) [protected, virtual]

Save a StatePass.

Parameters:
pass A pointer to the read-locked StatePass to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleAlphaTestAttribute ( const nvsg::AlphaTestAttribute * alphaTestAttrib ) [protected, virtual]

Save an AlphaTestAttribute.

Parameters:
alphaTestAttrib A pointer to the read-locked AlphaTestAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleBlendAttribute ( const nvsg::BlendAttribute * blendAttrib ) [protected, virtual]

Save a BlendAttribute.

Parameters:
blendAttrib A pointer to the read-locked BlendAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleCgFx ( const nvsg::CgFx * cgfx ) [protected, virtual]

Save a CgFx.

Parameters:
cgfx A pointer to the read-locked CgFx to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleDepthAttribute ( const nvsg::DepthAttribute * depthAttrib ) [protected, virtual]

Save a DepthAttribute.

Parameters:
depthAttrib A pointer to the read-locked DepthAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleFaceAttribute ( const nvsg::FaceAttribute * faceAttrib ) [protected, virtual]

Save a FaceAttribute.

Parameters:
faceAttrib A pointer to the read-locked FaceAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleLightingAttribute ( const nvsg::LightingAttribute * lightingAttrib ) [protected, virtual]

Save a LightingAttribute.

Parameters:
lightingAttrib A pointer to the read-locked LightingAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleLineAttribute ( const nvsg::LineAttribute * lineAttrib ) [protected, virtual]

Save a LineAttribute.

Parameters:
lineAttrib A pointer to the read-locked LineAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleMaterial ( const nvsg::Material * material ) [protected, virtual]

Save a Material.

Parameters:
material A pointer to the read-locked Material to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handlePointAttribute ( const nvsg::PointAttribute * pointAttrib ) [protected, virtual]

Save a PointAttribute.

Parameters:
pointAttrib A pointer to the read-locked PointAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleTextureAttribute ( const nvsg::TextureAttribute * texAttrib ) [protected, virtual]

Save a TextureAttribute.

Parameters:
texAttrib A pointer to the read-locked TextureAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | texAttribItem,
 |  | unsigned int | tu
 | ) | [protected, virtual]

Save a TextureAttributeItem.

Parameters:
texAttribItem | A pointer to the read-locked TextureAttributeItem to save.
tu | The texture unit this TextureAttributeItem is assigned to.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleTriangles ( const nvsg::Triangles * triangles ) [protected, virtual]

Save a Triangles.

Parameters:
triangles A pointer to the read-locked Triangles to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * triangles ) [protected, virtual]

Save a SkinnedTriangles.

Parameters:
triangles A pointer to the read-locked SkinnedTriangles to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleTriFans ( const nvsg::TriFans * fans ) [protected, virtual]

Save a TriFans.

Parameters:
fans A pointer to the read-locked TriFans to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleTriStrips ( const nvsg::TriStrips * strips ) [protected, virtual]

Save a TriStrips.

Parameters:
strips A pointer to the read-locked TriStrips to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleQuadMeshes ( const nvsg::QuadMeshes * meshes ) [protected, virtual]

Save a QuadMeshes.

Parameters:
meshes A pointer to the read-locked QuadMeshes to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleQuads ( const nvsg::Quads * quads ) [protected, virtual]

Save a Quads.

Parameters:
quads A pointer to the read-locked Quads to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleQuadStrips ( const nvsg::QuadStrips * strips ) [protected, virtual]

Save a QuadStrips.

Parameters:
strips A pointer to the read-locked QuadStrips to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleLines ( const nvsg::Lines * lines ) [protected, virtual]

Save a Lines.

Parameters:
lines A pointer to the read-locked Lines to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleLineStrips ( const nvsg::LineStrips * strips ) [protected, virtual]

Save a LineStrips.

Parameters:
strips A pointer to the read-locked LineStrips to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handlePoints ( const nvsg::Points * points ) [protected, virtual]

Save a Points.

Parameters:
points A pointer to the read-locked Points to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * vas ) [protected, virtual]

Save a VertexAttributeSet.

Parameters:
vas A pointer to the read-locked VertexAttributeSet to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleAnimatedVertexAttributeSet ( const nvsg::AnimatedVertexAttributeSet * avas ) [protected, virtual]

Save an AnimatedVertexAttributeSet.

Parameters:
avas A pointer to the read-locked AnimatedVertexAttributeSet to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleSkin ( const nvsg::Skin * skin ) [protected, virtual]

Save a Skin.

Parameters:
skin A pointer to the read-locked Skin to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleFramedIndexAnimation ( const nvsg::FramedAnimation< unsigned int > * trafo ) [protected, virtual]

Save a FramedAnimation<unsigned int>.

Parameters:
trafo A pointer to the read-locked FramedAnimation<unsigned int> to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleFramedTrafoAnimation ( const nvsg::FramedAnimation< nvmath::Trafo > * trafo ) [protected, virtual]

Save a FramedAnimation<Trafo>.

Parameters:
trafo A pointer to the read-locked FramedAnimation<Trafo> to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleFramedVertexAttributeAnimation ( const nvsg::FramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Save a FramedAnimation<VertexAttribute>.

Parameters:
p A pointer to the read-locked FramedAnimation<VertexAttribute> to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleLinearInterpolatedTrafoAnimation ( const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > * trafo ) [protected, virtual]

Save a LinearInterpolatedAnimation<Trafo>.

Parameters:
trafo A pointer to the read-locked LinearInterpolatedAnimation<Trafo> to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleLinearInterpolatedVertexAttributeAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Save a LinearInterpolatedAnimation<VertexAttribute>.

Parameters:
p A pointer to the read-locked LinearInterpolatedAnimation<VertexAttribute> to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

virtual void handleUnlitColorAttribute ( const nvsg::UnlitColorAttribute * unlitColor ) [protected, virtual]

Save an UnlitColorAttribute.

Parameters:
unlitColor A pointer to the read-locked UnlitColorAttribute to save.
See also:
calculatingStorageRequirements, pseudoAlloc

Reimplemented from SharedTraverser.

The documentation for this class was generated from the following file:
  • NBFSaver.h
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


Member List

NBFSaveTraverser Member List

This is the complete list of members for NBFSaveTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
alloc(void *&offsetPtr, unsigned int numBytes) | NBFSaveTraverser | [protected]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
calculatingStorageRequirements() const | NBFSaveTraverser | [inline, protected]
dealloc(void *offsetPtr) | NBFSaveTraverser | [protected]
doApply(nvsg::NodeHandle *root) | NBFSaveTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
getSuccess() const | NBFSaveTraverser | [inline]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | NBFSaveTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *trafo) | NBFSaveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | NBFSaveTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *billboard) | NBFSaveTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | NBFSaveTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | NBFSaveTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | NBFSaveTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | NBFSaveTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | NBFSaveTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *anim) | NBFSaveTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *trafo) | NBFSaveTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | NBFSaveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | NBFSaveTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *gnode) | NBFSaveTraverser | [protected, virtual]
handleGroup(const nvsg::Group *group) | NBFSaveTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *lightingAttrib) | NBFSaveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | NBFSaveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | NBFSaveTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | NBFSaveTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | NBFSaveTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | NBFSaveTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *lod) | NBFSaveTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | NBFSaveTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | NBFSaveTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | NBFSaveTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | NBFSaveTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | NBFSaveTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | NBFSaveTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | NBFSaveTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | NBFSaveTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | NBFSaveTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | NBFSaveTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | NBFSaveTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | NBFSaveTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | NBFSaveTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | NBFSaveTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *variant) | NBFSaveTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *swtch) | NBFSaveTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | NBFSaveTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | NBFSaveTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *trafo) | NBFSaveTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | NBFSaveTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | NBFSaveTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | NBFSaveTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | NBFSaveTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | NBFSaveTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *vnode) | NBFSaveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NBFSaveTraverser() | NBFSaveTraverser |
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preCalculateFileSize(nvsg::SceneHandle *scene) | NBFSaveTraverser |
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
pseudoAlloc(unsigned int numBytes) | NBFSaveTraverser | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setFileName(const std::string &fileName) | NBFSaveTraverser | [inline]
setPlugInCallback(const nvutil::PlugInCallback *pic) | NBFSaveTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


NBFScene Struct Reference

The NBFScene structure represents a scene in the context of computer graphics. More...

#include <NBF.h>

List of all members.

Public Attributes

float3_t ambientColor
Specifies the global ambient color to be used for rendering.

float4_t backColor
Specifies the scene's RGBA background color used with rendering.

uint_t backImg
Specifies the file offset to the back image object.

uint_t numCameras
Specifies the number of the scene's NBFCamera objects.

uint_t cameras
Specifies the file offset to the offsets of the scene's NBFCamera objects.

uint_t numCameraAnimations
Specifies the number of the scene's NBFTrafoAnimation objects (camera animations).

uint_t cameraAnimations
Specifies the offset to the offsets of the scene's NBFTrafoAnimation objects (camera animations).

uint_t numberOfAnimationFrames
For animated scenes, this specifies the number of animation frames.

uint_t root
Specifies the file offset to the scene's root node, which always is of a NBFNode derived type.

Detailed Description

The NBFScene structure represents a scene in the context of computer graphics.

A valid NBF file always contains one - and only one - NBFScene object. The file offset to this NBFScene object is specified within the NBFHeader structure.

Member Data Documentation

float3_t ambientColor

Specifies the global ambient color to be used for rendering.

float4_t backColor

Specifies the scene's RGBA background color used with rendering.

uint_t backImg

Specifies the file offset to the back image object.

uint_t numCameras

Specifies the number of the scene's NBFCamera objects.

uint_t cameras

Specifies the file offset to the offsets of the scene's NBFCamera objects.

uint_t numCameraAnimations

Specifies the number of the scene's NBFTrafoAnimation objects (camera animations).

uint_t cameraAnimations

Specifies the offset to the offsets of the scene's NBFTrafoAnimation objects (camera animations).

uint_t numberOfAnimationFrames

For animated scenes, this specifies the number of animation frames.

uint_t root

Specifies the file offset to the scene's root node, which always is of a NBFNode derived type.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


Member List

NBFScene Member List

This is the complete list of members for NBFScene, including all inherited members.
ambientColor | NBFScene
backColor | NBFScene
backImg | NBFScene
cameraAnimations | NBFScene
cameras | NBFScene
numberOfAnimationFrames | NBFScene
numCameraAnimations | NBFScene
numCameras | NBFScene
root | NBFScene
Generated on Tue Jan 15 10:28:41 2008 for NVSGSDK by NVIDIA


NBFSkin Struct Reference

The NBFSkin structure represents a set of skin information for a vertex attribute. More...

#include <NBF.h>

Inheritance diagram for NBFSkin:

[legend]
Collaboration diagram for NBFSkin:

[legend]
List of all members.

Public Member Functions

PADDING (4)

Public Attributes

float44_t bindShapeMatrix
Specifies the bindShapeMatrix.

uint_t numCounts
Specifies the number of influences (counts).

uint_t counts
Specifies the file offset to the indices/weights per vertex.

uint_t indices
Specifies the file offset to the indices.

uint_t weights
Specifies the file offset to the weights.

ubyte_t skinningType [16]
Specifies the skinning type for each vertex attribute.

uint_t numJoints
Specifies the number of joints.

uint_t inverseBindMatrices
Specifies the file offset to the inverseBindMatrices.

uint_t joints
Specifies the file offset to the joints.

Detailed Description

The NBFSkin structure represents a set of skin information for a vertex attribute.

Remarks:
An NBFSkin derives from NBFObject, and holds the bindShapeMatrix, the number of influences (numCounts), the number of indices/weights per influence (counts), the indices into the array of joints and the corresponding weights, the skinning types for each vertex attribute, the number of joints, and the offsets to the inverseBindMatrices and the joints.

Member Data Documentation

float44_t bindShapeMatrix

Specifies the bindShapeMatrix.

uint_t numCounts

Specifies the number of influences (counts).

uint_t counts

Specifies the file offset to the indices/weights per vertex.

uint_t indices

Specifies the file offset to the indices.

uint_t weights

Specifies the file offset to the weights.

ubyte_t skinningType[16]

Specifies the skinning type for each vertex attribute.

uint_t numJoints

Specifies the number of joints.

uint_t inverseBindMatrices

Specifies the file offset to the inverseBindMatrices.

uint_t joints

Specifies the file offset to the joints.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


Member List

NBFSkin Member List

This is the complete list of members for NBFSkin, including all inherited members.
bindShapeMatrix | NBFSkin
counts | NBFSkin
indices | NBFSkin
inverseBindMatrices | NBFSkin
isShared | NBFObject
joints | NBFSkin
numCounts | NBFSkin
numJoints | NBFSkin
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) (defined in NBFSkin) | NBFSkin
NBFObject::PADDING(3) | NBFObject
skinningType | NBFSkin
sourceObject | NBFObject
weights | NBFSkin
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


NBFSkinnedTriangles Struct Reference

The NBFSkinnedTriangles structure represents skin animated triangles. More...

#include <NBF.h>

Inheritance diagram for NBFSkinnedTriangles:

[legend]
Collaboration diagram for NBFSkinnedTriangles:

[legend]
List of all members.

Public Attributes

uint_t numSkins
Specifies the number of contained skins.

uint_t skins
Specifies the file offset to the corresponding skin_t objects.

Detailed Description

The NBFSkinnedTriangles structure represents skin animated triangles.

A NBFSkinnedTriangles is a concrete topology class derived from NBFIndependentPrimitiveSet. The object code for a NBFSkinnedTriangles is NBF_SKINNED_TRIANGLES.

Member Data Documentation

uint_t numSkins

Specifies the number of contained skins.

uint_t skins

Specifies the file offset to the corresponding skin_t objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


Member List

NBFSkinnedTriangles Member List

This is the complete list of members for NBFSkinnedTriangles, including all inherited members.
indices | NBFIndependentPrimitiveSet
isShared | NBFObject
numIndices | NBFIndependentPrimitiveSet
numSkins | NBFSkinnedTriangles
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
skin | NBFPrimitiveSet
skins | NBFSkinnedTriangles
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


NBFSpotLight Struct Reference

#include <NBF.h>

Inheritance diagram for NBFSpotLight:

[legend]
Collaboration diagram for NBFSpotLight:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFSpotLight is a multiple of 8, regardless of packing.

Public Attributes

float3_t position
Specifies the position of the light source.

float3_t direction
Specifies the direction of the light source.

float3_t attenuation
float | cutoffAngle
float | falloffExponent
Controls the intensity distribution inside the cone, the light is mitted to.

Detailed Description

The object code for a NBFSpotLight is NBF_SPOT_LIGHT.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFSpotLight is a multiple of 8, regardless of packing.

Member Data Documentation

float3_t position

Specifies the position of the light source.

float3_t direction

Specifies the direction of the light source.

float3_t attenuation

Specifies the attenuation factors of the spot light. < The x-component of the vector specifies the constant term of the attenuation, < the y-component of the vector specifies the linear term of the attenuation, and < the z-component of the vector specifies the quadratic term of the attenuation.

float cutoffAngle

Specifies the angle between the axis of the cone, the light is emitted to, and < a ray along the edge of the cone.

float falloffExponent

Controls the intensity distribution inside the cone, the light is mitted to.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


Member List

NBFSpotLight Member List

This is the complete list of members for NBFSpotLight, including all inherited members.
ambientColor | NBFLightSource
animation | NBFLightSource
attenuation | NBFSpotLight
castShadow | NBFLightSource
cutoffAngle | NBFSpotLight
diffuseColor | NBFLightSource
direction | NBFSpotLight
enabled | NBFLightSource
falloffExponent | NBFSpotLight
intensity | NBFLightSource
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFSpotLight
NBFLightSource::PADDING(2) | NBFLightSource
NBFObject::PADDING(3) | NBFObject
position | NBFSpotLight
sourceObject | NBFObject
specularColor | NBFLightSource
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


NBFStateAttribute Struct Reference

The NBFStateAttribute structure represents a state attribute. More...

#include <NBF.h>

Inheritance diagram for NBFStateAttribute:

[legend]
Collaboration diagram for NBFStateAttribute:

[legend]
List of all members.

Detailed Description

The NBFStateAttribute structure represents a state attribute.

A NBFStateAttribute serves a base class only. Concrete object codes valid for a NBFStateAttribute are NBF_BLEND_ATTRIBUTE, NBF_CGFX, NBF_MATERIAL, NBF_FACE_ATTRIBUTE, and NBF_TEXTURE_ATTRIBUTE.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


Member List

NBFStateAttribute Member List

This is the complete list of members for NBFStateAttribute, including all inherited members.
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


NBFStatePass Struct Reference

The NBFStatePass structure represents a set of heterogeneous NBFStateAttributes. More...

#include <NBF.h>

Inheritance diagram for NBFStatePass:

[legend]
Collaboration diagram for NBFStatePass:

[legend]
List of all members.

Public Attributes

uint_t numStateAttribs
Specifies the number of contained state attributes.

uint_t stateAttribs
Specifies the file offset to the offsets to the NBFStateAttribute objects.

Detailed Description

The NBFStatePass structure represents a set of heterogeneous NBFStateAttributes.

The object code for a NBFStatePass is NBF_STATE_PASS.

Member Data Documentation

uint_t numStateAttribs

Specifies the number of contained state attributes.

uint_t stateAttribs

Specifies the file offset to the offsets to the NBFStateAttribute objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


Member List

NBFStatePass Member List

This is the complete list of members for NBFStatePass, including all inherited members.
isShared | NBFObject
numStateAttribs | NBFStatePass
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
stateAttribs | NBFStatePass
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


NBFStateSet Struct Reference

The NBFStateSet structure represents a set of pairs of VariantKeys and StateVariants. More...

#include <NBF.h>

Inheritance diagram for NBFStateSet:

[legend]
Collaboration diagram for NBFStateSet:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFStateSet is a multiple of 8, regardless of packing.

Public Attributes

uint_t activeKey
Specifies the currently active VariantKey.

uint_t numStateVariants
Specifies the number of contained pairs of VariantKey and StateVariant.

uint_t keyStateVariantPairs
Specifies the file offset to the offsets to the keyVariant_t objects.

Detailed Description

The NBFStateSet structure represents a set of pairs of VariantKeys and StateVariants.

The object code for a NBFStateSet is NBF_STATE_SET.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFStateSet is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t activeKey

Specifies the currently active VariantKey.

uint_t numStateVariants

Specifies the number of contained pairs of VariantKey and StateVariant.

uint_t keyStateVariantPairs

Specifies the file offset to the offsets to the keyVariant_t objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


Member List

NBFStateSet Member List

This is the complete list of members for NBFStateSet, including all inherited members.
activeKey | NBFStateSet
isShared | NBFObject
keyStateVariantPairs | NBFStateSet
numStateVariants | NBFStateSet
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFStateSet
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:42 2008 for NVSGSDK by NVIDIA


NBFStateVariant Struct Reference

The NBFStateVariant structure represents a set of StatePasses. More...

#include <NBF.h>

Inheritance diagram for NBFStateVariant:

[legend]
Collaboration diagram for NBFStateVariant:

[legend]
List of all members.

Public Attributes

uint_t numStatePasses
Specifies the number of contained state passes.

uint_t statePasses
Specifies the file offset to the offsets to the NBFStatePass objects.

Detailed Description

The NBFStateVariant structure represents a set of StatePasses.

The object code for a NBFStateVariant is NBF_STATE_VARIANT.

Member Data Documentation

uint_t numStatePasses

Specifies the number of contained state passes.

uint_t statePasses

Specifies the file offset to the offsets to the NBFStatePass objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


Member List

NBFStateVariant Member List

This is the complete list of members for NBFStateVariant, including all inherited members.
isShared | NBFObject
numStatePasses | NBFStateVariant
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
statePasses | NBFStateVariant
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


NBFStrippedPrimitiveSet Struct Reference

The NBFStrippedPrimitiveSet structure represents a strip set. More...

#include <NBF.h>

Inheritance diagram for NBFStrippedPrimitiveSet:

[legend]
Collaboration diagram for NBFStrippedPrimitiveSet:

[legend]
List of all members.

Public Attributes

uint_t numStrips
Specifies the number of strips.

uint_t strips

Detailed Description

The NBFStrippedPrimitiveSet structure represents a strip set.

A NBFStrippedPrimitiveSet is an abstract topology class derived from NBFPrimitiveSet. Valid object codes for a NBFStrippedPrimitiveSet are NBF_TRIFANS, NBF_TRISTRIPS, and NBF_QUADSTRIPS.

Member Data Documentation

uint_t numStrips

Specifies the number of strips.

uint_t strips

Specifies the file offset to the strips. < Strips are stored as indexSet_t objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


Member List

NBFStrippedPrimitiveSet Member List

This is the complete list of members for NBFStrippedPrimitiveSet, including all inherited members.
isShared | NBFObject
numStrips | NBFStrippedPrimitiveSet
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
skin | NBFPrimitiveSet
sourceObject | NBFObject
strips | NBFStrippedPrimitiveSet
vertexAttributeSet | NBFPrimitiveSet
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


NBFSwitch Struct Reference

The NBFSwitch structure represents a switch group node. More...

#include <NBF.h>

Inheritance diagram for NBFSwitch:

[legend]
Collaboration diagram for NBFSwitch:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFSwitch is a multiple of 8, regardless of packing.

Public Attributes

uint_t activeMaskKey
Specifies the key of the active mask.

uint_t numMasks
Specifies the number of masks stored at offset masks.

uint_t masks
Specifies the file offset to the masks stored as switchMask_t objects.

Detailed Description

The NBFSwitch structure represents a switch group node.

The object code for a NBFSwitch is NBF_SWITCH.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFSwitch is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t activeMaskKey

Specifies the key of the active mask.

uint_t numMasks

Specifies the number of masks stored at offset masks.

uint_t masks

Specifies the file offset to the masks stored as switchMask_t objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


Member List

NBFSwitch Member List

This is the complete list of members for NBFSwitch, including all inherited members.
activeMaskKey | NBFSwitch
annotation | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
lightSources | NBFGroup
masks | NBFSwitch
numChildren | NBFGroup
numClipPlanes | NBFGroup
numLightSource | NBFGroup
numMasks | NBFSwitch
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFSwitch
NBFGroup::PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


NBFTextureAttribute Struct Reference

The NBFTextureAttribute structure represents a texture attribute. More...

#include <NBF.h>

Inheritance diagram for NBFTextureAttribute:

[legend]
Collaboration diagram for NBFTextureAttribute:

[legend]
List of all members.

Public Attributes

uint_t numBindings
Specifies the number of contained texture bindings.

uint_t bindings

Detailed Description

The NBFTextureAttribute structure represents a texture attribute.

The object code for a NBFTextureAttribute is NBF_TEXTURE_ATTRIBUTE.

Member Data Documentation

uint_t numBindings

Specifies the number of contained texture bindings.

uint_t bindings

Specifies the file offset to the texture bindings. Texture bindings in < the NBF format are stored as texBinding_t objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


Member List

NBFTextureAttribute Member List

This is the complete list of members for NBFTextureAttribute, including all inherited members.
bindings | NBFTextureAttribute
isShared | NBFObject
numBindings | NBFTextureAttribute
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


NBFTextureAttributeItem Struct Reference

The NBFTextureAttributeItem structure represents a single texture object. More...

#include <NBF.h>

Inheritance diagram for NBFTextureAttributeItem:

[legend]
Collaboration diagram for NBFTextureAttributeItem:

[legend]
List of all members.

Public Attributes

uint_t texImg
Specifies the file offset to the texture image object.

uint_t texTarget
Specifies the texture target.

float4_t texEnvColor
Specifies the texture environment color.

uint_t texEnvMode
uint_t texEnvScale
Specifies the texture environment scale used with rasterization.

uint_t texWrapS
Specifies the wrap parameter for texture coordinate s.

uint_t texWrapT
Specifies the wrap parameter for texture coordinate t.

uint_t texWrapR
Specifies the wrap parameter for texture coordinate r.

uint_t minFilter
uint_t magFilter
float4_t texBorderColor
Specifies the texture border RGBA color.

trafo_t trafo
Specifies the texture transformation.

uint_t | texGenMode [4]
Specifies the texture coordinate generation modes.

float4_t | texGenPlane [2][4]
Specifies the texture coordinate generation planes.

Detailed Description

The NBFTextureAttributeItem structure represents a single texture object.

The object code for a NBFTextureAttributeItem is NBF_TEXTURE_ATTRIBUTE_ITEM. A NBFTextureAttributeItem needs to be consider in conjunction with a NBFTextureAttribute, which specifies the binding of texture objects.

Member Data Documentation

uint_t texImg

Specifies the file offset to the texture image object.

uint_t texTarget

Specifies the texture target.

float4_t texEnvColor

Specifies the texture environment color.

uint_t texEnvMode

Specifies the texture environment mode for the actual texture object. < Valid modes are TEM_REPLACE, TEM_MODULATE, TEM_DECAL, TEM_BLEND, and TEM_ADD.

uint_t texEnvScale

Specifies the texture environment scale used with rasterization.

uint_t texWrapS

Specifies the wrap parameter for texture coordinate s.

uint_t texWrapT

Specifies the wrap parameter for texture coordinate t.

uint_t texWrapR

Specifies the wrap parameter for texture coordinate r.

uint_t minFilter

Specifies the filter used with minimizing. < Valid values are TFM_MIN_NEAREST, TFM_MIN_LINEAR, TFM_MIN_LINEAR_MIPMAP_LINEAR, < TFM_MIN_NEAREST_MIPMAP_NEAREST, TFM_MIN_NEAREST_MIPMAP_LINEAR, TFM_MIN_LINEAR_MIPMAP_NEAREST.

uint_t magFilter

Specifies the filter used with magnifying. < Valid values are TFM_MAG_NEAREST, and TFM_MAG_LINEAR.

float4_t texBorderColor

Specifies the texture border RGBA color.

trafo_t trafo

Specifies the texture transformation.

uint_t texGenMode[4]

Specifies the texture coordinate generation modes.

float4_t texGenPlane[2][4]

Specifies the texture coordinate generation planes.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


Member List

NBFTextureAttributeItem Member List

This is the complete list of members for NBFTextureAttributeItem, including all inherited members.
isShared | NBFObject
magFilter | NBFTextureAttributeItem
minFilter | NBFTextureAttributeItem
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
texBorderColor | NBFTextureAttributeItem
texEnvColor | NBFTextureAttributeItem
texEnvMode | NBFTextureAttributeItem
texEnvScale | NBFTextureAttributeItem
texGenMode | NBFTextureAttributeItem
texGenPlane | NBFTextureAttributeItem
texImg | NBFTextureAttributeItem
texTarget | NBFTextureAttributeItem
texWrapR | NBFTextureAttributeItem
texWrapS | NBFTextureAttributeItem
texWrapT | NBFTextureAttributeItem
trafo | NBFTextureAttributeItem
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


NBFTrafoAnimation Struct Reference

The NBFTrafoAnimation represents an animation that will be applied to trafo_t objects. More...

#include <NBF.h>

Inheritance diagram for NBFTrafoAnimation:

[legend]
Collaboration diagram for NBFTrafoAnimation:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFTrafoAnimation is a multiple of 8, regardless of packing.

Public Attributes

uint_t trafos

Detailed Description

The NBFTrafoAnimation represents an animation that will be applied to trafo_t objects.

A NBFTrafoAnimation serves as base class only and needs to be considered in conjunction with either NBFFramedAnimation or NBFInterpolatedAnimation.
Valid object codes for a NBFTrafoAnimation are NBF_FRAMED_TRAFO_ANIMATION, and NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION. Further concrete object codes valid for NBFTrafoAnimation objects are subject to future extensions of the NBF format.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFTrafoAnimation is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t trafos

Specifies the file offset to the trafo_t objects the animation will be applied to. < The actual number of trafo_t objects is specified by the corresponding animation < type, which is either NBFFramedAnimation or NBFInterpolatedAnimation.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


Member List

NBFTrafoAnimation Member List

This is the complete list of members for NBFTrafoAnimation, including all inherited members.
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFTrafoAnimation
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
trafos | NBFTrafoAnimation
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


NBFTransform Struct Reference

The NBFTransform structure represents a transform group node. More...

#include <NBF.h>

Inheritance diagram for NBFTransform:

[legend]
Collaboration diagram for NBFTransform:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFTransform is a multiple of 8, regardless of packing.

Public Attributes

trafo_t trafo
Specifies the transformation of the NBFTransform.

Detailed Description

The NBFTransform structure represents a transform group node.

The object code for a NBFTransform is NBF_TRANSFORM.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFTransform is a multiple of 8, regardless of packing.

Reimplemented in NBFAnimatedTransform.

Member Data Documentation

trafo_t trafo

Specifies the transformation of the NBFTransform.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


Member List

NBFTransform Member List

This is the complete list of members for NBFTransform, including all inherited members.
annotation | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
lightSources | NBFGroup
numChildren | NBFGroup
numClipPlanes | NBFGroup
numLightSource | NBFGroup
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFTransform
NBFGroup::PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
trafo | NBFTransform
userHints | NBFNode
Generated on Tue Jan 15 10:28:43 2008 for NVSGSDK by NVIDIA


NBFUnlitColorAttribute Struct Reference

The NBFUnlitColorAttribute structure represents the color for unlit objects. More...

#include <NBF.h>

Inheritance diagram for NBFUnlitColorAttribute:

[legend]
Collaboration diagram for NBFUnlitColorAttribute:

[legend]
List of all members.

Public Attributes

float4_t color
Specifies the color for unlit objects.

Detailed Description

The NBFUnlitColorAttribute structure represents the color for unlit objects.

Remarks:
The object code for a NBFUnlitColorAttribute is NBF_UNLIT_COLOR_ATTRIBUTE.

Member Data Documentation

float4_t color

Specifies the color for unlit objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


Member List

NBFUnlitColorAttribute Member List

This is the complete list of members for NBFUnlitColorAttribute, including all inherited members.
color | NBFUnlitColorAttribute
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


NBFVertexAttributeAnimation Struct Reference

The NBFVertexAttributeAnimation represents an animation that will be applied to vertexAttrib_t objects. More...

#include <NBF.h>

Inheritance diagram for NBFVertexAttributeAnimation:

[legend]
Collaboration diagram for NBFVertexAttributeAnimation:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFVertexAttributeAnimation is a multiple of 8, regardless of packing.

Public Attributes

uint_t attribs

Detailed Description

The NBFVertexAttributeAnimation represents an animation that will be applied to vertexAttrib_t objects.

A NBFVertexAttributeAnimation serves as base class only and needs to be considered in conjunction with either NBFFramedAnimation or NBFInterpolatedAnimation.
Valid object codes for a NBFVertexAttributeAnimation are NBF_FRAMED_VERTEX_ATTRIBUTE_ANIMATION, and NBF_LINEAR_INTERPOLATED_VERTEX_ATTRIBUTE_ANIMATION. Further concrete object codes valid for NBFVertexAttributeAnimation objects are subject to future extensions of the NBF format.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFVertexAttributeAnimation is a multiple of 8, regardless of packing.

Member Data Documentation

uint_t attribs

Specifies the file offset to the vertexAttrib_t objects the animation will be applied to. < The actual number of vertexAttrib_t objects is specified by the corresponding animation < type, which is either NBFFramedAnimation or NBFInterpolatedAnimation.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


Member List

NBFVertexAttributeAnimation Member List

This is the complete list of members for NBFVertexAttributeAnimation, including all inherited members.
attribs | NBFVertexAttributeAnimation
isShared | NBFObject
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFVertexAttributeAnimation
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


NBFVertexAttributeSet Struct Reference

The NBFVertexAttributeSet structure represents a set of vertex attributes. More...

#include <NBF.h>

Inheritance diagram for NBFVertexAttributeSet:

[legend]
Collaboration diagram for NBFVertexAttributeSet:

[legend]
List of all members.

Public Attributes

uint_t enableFlags
Specifies which of the 16 vertex attributes is enabled.

uint_t normalizeEnableFlags
Specifies for which of the 16 vertex attributes normalization is enabled.

vertexAttrib_t vattribs [16]
Specifies the 16 vertex attributes.

Detailed Description

The NBFVertexAttributeSet structure represents a set of vertex attributes.

A NBFVertexAttributeSet maintains a full set of geometry data (vertex attributes) that is used by all topology classes.

Member Data Documentation

uint_t enableFlags

Specifies which of the 16 vertex attributes is enabled.

uint_t normalizeEnableFlags

Specifies for which of the 16 vertex attributes normalization is enabled.

vertexAttrib_t vattribs[16]

Specifies the 16 vertex attributes.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


Member List

NBFVertexAttributeSet Member List

This is the complete list of members for NBFVertexAttributeSet, including all inherited members.
enableFlags | NBFVertexAttributeSet
isShared | NBFObject
normalizeEnableFlags | NBFVertexAttributeSet
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
sourceObject | NBFObject
vattribs | NBFVertexAttributeSet
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


NBFViewState Struct Reference

The NBFViewState represents an optional view state used to render the scene. More...

#include <NBF.h>

List of all members.

Public Member Functions

PADDING (2)
Padding bits to ensure offset of jitters is on a 4-byte boundary, regardless of packing.

Public Attributes

uint_t objectCode
Specifies the object code of the actual object. The object code is unique per object type!

uint_t camera
Specifies the offset to the NBFCamera object to be used for viewing.

ubyte_t isStereo
Indicates whether the view is in stereo mode.

ubyte_t isStereoAutomatic
Indicates whether eye distance is automatically adjusted in stereo mode.

uint_t combineMethod
Specifies how to combine the FSAA and DoF jitters to generate the resulting jitter.

uint_t numFSAAJitters
Specified number of FSAA jitter values.

uint_t fsaaJitters
Specifies the offset to FSAA jitter values.

uint_t numDoFJitters
Specifies the number of DoF jitter values.

uint_t dofJitters
Specifies the offset to DoF jitter values.

float | stereoAutomaticFactor
Specifies the automatic eye distance adjustment factor in stereo mode.

float | stereoEyeDistance
Specifies the stereo eye distance used if the view is in stereo mode.

float | targetDistance
Specifies the target distance to the projection plane.

Detailed Description

The NBFViewState represents an optional view state used to render the scene.

The file offset to an optional NBFViewState object is specified within the NBFHeader structure.

Member Function Documentation

PADDING ( 2 )

Padding bits to ensure offset of jitters is on a 4-byte boundary, regardless of packing.

Member Data Documentation

uint_t objectCode

Specifies the object code of the actual object. The object code is unique per object type!

uint_t camera

Specifies the offset to the NBFCamera object to be used for viewing.

ubyte_t isStereo

Indicates whether the view is in stereo mode.

ubyte_t isStereoAutomatic

Indicates whether eye distance is automatically adjusted in stereo mode.

uint_t combineMethod

Specifies how to combine the FSAA and DoF jitters to generate the resulting jitter.

uint_t numFSAAJitters

Specified number of FSAA jitter values.

uint_t fsaaJitters

Specifies the offset to FSAA jitter values.

uint_t numDoFJitters

Specifies the number of DoF jitter values.

uint_t dofJitters

Specifies the offset to DoF jitter values.

float stereoAutomaticFactor

Specifies the automatic eye distance adjustment factor in stereo mode.

float stereoEyeDistance

Specifies the stereo eye distance used if the view is in stereo mode.

float targetDistance

Specifies the target distance to the projection plane.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


Member List

NBFViewState Member List

This is the complete list of members for NBFViewState, including all inherited members.
camera | NBFViewState
combineMethod | NBFViewState
dofJitters | NBFViewState
fsaaJitters | NBFViewState
isStereo | NBFViewState
isStereoAutomatic | NBFViewState
numDoFJitters | NBFViewState
numFSAAJitters | NBFViewState
objectCode | NBFViewState
PADDING(2) | NBFViewState
stereoAutomaticFactor | NBFViewState
stereoEyeDistance | NBFViewState
targetDistance | NBFViewState
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


NBFVolumeNode Struct Reference

The NBFVolumeNode structure represents a volume node. More...

#include <NBF.h>

Inheritance diagram for NBFVolumeNode:

[legend]
Collaboration diagram for NBFVolumeNode:

[legend]
List of all members.

Public Attributes

str_t bricksName
Specifies the name of the top level brick.

uint_t levelToDisplay
Specifies the level to display.

uint_t shader
Specifies the file offset to the shader.

str_t volumeName
Specifies the name of the volume dataset.

float voxelLimitFraction
Specifies the voxel limit fraction.

Detailed Description

The NBFVolumeNode structure represents a volume node.

The object code for a NBFVolumeNode is NBF_VOLUME_NODE.

Member Data Documentation

str_t bricksName

Specifies the name of the top level brick.

uint_t levelToDisplay

Specifies the level to display.

uint_t shader

Specifies the file offset to the shader.

str_t volumeName

Specifies the name of the volume dataset.

float voxelLimitFraction

Specifies the voxel limit fraction.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


Member List

NBFVolumeNode Member List

This is the complete list of members for NBFVolumeNode, including all inherited members.
annotation | NBFNode
bricksName | NBFVolumeNode
isShared | NBFObject
levelToDisplay | NBFVolumeNode
objectAnno | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
shader | NBFVolumeNode
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
volumeName | NBFVolumeNode
voxelLimitFraction | NBFVolumeNode
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


Node Class Reference

Serves as base class for all tree nodes. More...

#include <Node.h>

Inheritance diagram for Node:

[legend]
Collaboration diagram for Node:

[legend]
List of all members.

Public Types

enum NodeHints {
NH_CULL_MASK = BIT0 | BIT1, NH_CULL_NEVER = BIT0, NH_CULL_ALWAYS = BIT1, NH_NO_SHADOW_CASTER = BIT2,
NH_NO_SHADOW_RECEIVER = BIT3, NH_OVERLAY = BIT4, NH_MODIFY_FREQUENCY_MASK = BIT5 | BIT6, NH_MODIFY_FREQUENCY_LOW = BIT5,
NH_MODIFY_FREQUENCY_HIGH = BIT6, NH_RESERVED_BITS = 0x80, NH_CUSTOM_BITS = 0xFF00
}
Hints to give to a Node. More...

Public Member Functions

NVSG_API | Node ()
Default-constructs a Node.

NVSG_API | Node (const Node &rhs)
Constructs a Node as a copy of another Node.

virtual NVSG_API | ~Node ()
Destructs a Node.

NVSG_API unsigned int | getNumberOfParents () const
Returns the number of parent Group nodes for this Node.

NVSG_API GroupHandle * | getParent (unsigned int index) const
Returns a parent Group by index.

NVSG_API const nvmath::Box3f & | getBoundingBox () const
Returns the bounding box of this Node.

NVSG_API const nvmath::Sphere3f & | getBoundingSphere () const
Returns the Node's bounding sphere.

NVSG_API void | invalidateBoundingVolumes ()
Invalidates the bounding volumes of the Node.

NVSG_API bool | containsTransparentGeometry () const
Tests whether the Node contains transparent geometry.

NVSG_API void | invalidateTransparencyContainment ()
Invalidates the transparency containment cache.

NVSG_API bool | containsCgFx () const
Retrieves the CgFx containment status of the Node.

NVSG_API void | invalidateCgFxContainment ()
Invalidates the CgFx containment cache.

NVSG_API bool | containsLight () const
Retrieves the LightSource containment status of the Node.

NVSG_API void | invalidateLightContainment ()
Invalidates the LightSource containment cache.

NVSG_API bool | containsLOD () const
Retrieves the LOD containment status of the Node.

NVSG_API void | invalidateLODContainment ()
Invalidates the LOD containment cache.

NVSG_API bool | containsVolumeNode () const
Retrieves the VolumeNode containment status of the Node.

NVSG_API void | invalidateVolumeNodeContainment ()
Invalidates the VolumeNode containment cache.

NVSG_API bool | containsAnimation () const
Retrieves the Animation containment status of the Node.

NVSG_API void | invalidateAnimationContainment ()
Invalidates the Animation containment cache.

NVSG_API unsigned short | getHints (unsigned short mask=0xFFFF) const
Get the hints to use on this Node.

NVSG_API void | setHints (unsigned short hints)
Set the hints to use on this Node.

NVSG_API void | addHints (unsigned short hints)
Convenience function to add some hints to the current set of hints.

NVSG_API void | removeHints (unsigned short hints)
Convenience function to remove some hints from the current set of hints.

NVSG_API bool | containsHints (unsigned short hints) const
Query if this Node or something beneath contains the given hints.

NVSG_API unsigned short | getHintsContainment (unsigned short hints) const
Evaluate hints for this Node and all Nodes beneath for this set of hints.

NVSG_API void | invalidateHintsContainment (unsigned short hints)
Invalidates the containment flags for a set of hints.

virtual NVSG_API bool | invalidateIncarnation ()
Overrides Object::invalidateIncarnation.

virtual NVSG_API bool | validateIncarnation () const
Overrides Object::validateIncarnation.

NVSG_API void | invalidateContainment (unsigned int mask)
Invalidates containment for the indicated states.

NVSG_API unsigned int | getContainmentFlags () const
Get the containment flags of this Node.

NVSG_API unsigned int | getContainmentValidFlags () const
Get the containment valid flags of this Node.

NVSG_API void | assertInvalidBoundingSphere () const
Prompts an assertion failed message if the Node's bounding box is valid.

Protected Types

enum {
NF_CONTAINS_CGFX = BIT0, NF_CONTAINS_CGFX_VALID = BIT1, NF_CONTAINS_TRANSPARENCY = BIT2, NF_CONTAINS_TRANSPARENCY_VALID = BIT3,
NF_BOUNDING_BOX_VALID = BIT4, NF_BOUNDING_SPHERE_VALID = BIT5, NF_BOUNDING_VOLUMES_VALID = NF_BOUNDING_BOX_VALID | NF_BOUNDING_SPHERE_VALID, NF_CONTAINS_LIGHT = BIT6,
NF_CONTAINS_LIGHT_VALID = BIT7, NF_CONTAINS_VOLUME_NODE = BIT8, NF_CONTAINS_VOLUME_NODE_VALID = BIT9, NF_CONTAINS_LOD = BIT0,
NF_CONTAINS_LOD_VALID = BIT11, NF_CONTAINS_ANIMATION = BIT12, NF_CONTAINS_ANIMATION_VALID = BIT13, NF_CONTAINS_MASK,
NF_CONTAINS_VALID_MASK = NF_CONTAINS_MASK << 1
}

Protected Member Functions

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const=0
Called from the framework if re-calculation of the Node's bounding box is required.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const=0
Called from the framework if re-calculation of the Node's bounding sphere is required.

virtual NVSG_API bool | determineCgFxContainment () const
Called from the framework if re-determination of CgFx containment is required.

virtual NVSG_API bool | determineLightContainment () const
Called from the framework if re-determination of LightSource containment is required.

virtual NVSG_API bool | determineLODContainment () const
Called from the framework if re-determination of LOD containment is required.

virtual NVSG_API bool | determineVolumeNodeContainment () const
Called from the framework if re-determination of VolumeNode containment is required.

virtual NVSG_API unsigned
short 		determineHintsContainment (unsigned short hints) const
Determine the hints containment status of this Node.

virtual NVSG_API bool | determineTransparencyContainment () const=0
Called from the framework if re-determination of the transparency containment cache is required.

virtual NVSG_API bool | determineAnimationContainment () const
Called from the framework if re-determination of the transparency containment cache is required.

NVSG_API Node & | operator= (const Node &rhs)
Assigns new content from another Node.

NVSG_API void | addAsParentTo (NodeHandle *child)
Adds this Node as a parent to child.

NVSG_API void | removeAsParentFrom (NodeHandle *child)
Removes this Node as a parent from child.

Protected Attributes

unsigned int | m_flags

Detailed Description

Serves as base class for all tree nodes.

Namespace: nvsg

Member Enumeration Documentation

enum NodeHints

Hints to give to a Node.

Remarks:
There is a hint system part of Node. It allows to add some hinting information to that Node. This information might be considered by any Traverser, but it does not have to. A number of hints are predefined, some space for further hints is reserved for future use within NVSG, and some space is available to customer hints.
All hints should be treated as some kind of exceptional behavior. That is, if the corresponding bit is set, the Node might be handled somewhat different than is the default. If it is not set, it is handled as usual.
Example
To prevent a Node from being culled (maybe because there's a CgFx effect attached that changes it's vertices) do the following:
    NodeHandle * hNode = [...]
    {
      WritableObject< Node > pNode( hNode );
      pNode->addHints( NH_CULL_NEVER );
    }
Example
To change the culling hint back to the default state, do the following:
    NodeHandle * hNode = [...]
    {
      WritableObject< Node > pNode( hNode );
      pNode->removeHints( NH_CULL_MASK );
    }
Note:
With the hint NH_OVERLAY, a Node is placed in the overlay part of the scene. A Node in the overlay part of the scene is drawn after and above all other objects. Currently, to make sure that it's visible, the depth compare is off, and can not be changed for this Node and beneath. The Node objects marked to be in the overlay part are drawn from back to front, to make sure that the spatial relationship between them (but not with the rest of the scene!) is correct.
See also:
Node
Enumeration values:
NH_CULL_MASK | Mask for culling hints.
NH_CULL_NEVER | Never cull this Node, it's always inside.
NH_CULL_ALWAYS | Always cull this Node, it's always outside.
NH_NO_SHADOW_CASTER | This Node does not cast shadows.
NH_NO_SHADOW_RECEIVER | This Node does not receive shadows.
NH_OVERLAY | This Node is to be placed in the overlay list.
NH_MODIFY_FREQUENCY_MASK | Not yet used! Mask for modifying frequency hints.
NH_MODIFY_FREQUENCY_LOW | Not yet used! This Node is rarely modified; aggressive optimization is allowed here.
NH_MODIFY_FREQUENCY_HIGH | Not yet used! This Node is often modified; no time consuming operations allowed here.
NH_RESERVED_BITS | These bits are reserved for future use.
NH_CUSTOM_BITS | These bits are free for custom use.

Constructor & Destructor Documentation

NVSG_API Node ( )

Default-constructs a Node.

NVSG_API Node ( const Node & rhs )

Constructs a Node as a copy of another Node.

virtual NVSG_API ~Node ( ) [virtual]

Destructs a Node.

Member Function Documentation

unsigned int getNumberOfParents ( ) const [inline]

Returns the number of parent Group nodes for this Node.

Returns:
The actual number of Group nodes that have this Node as child node.

GroupHandle * getParent ( unsigned int index ) const [inline]

Returns a parent Group by index.

Parameters:
index Zero-based index of the parent Group to retrieve.
Returns:
The function returns a pointer to the index-th parent Group.
Remarks:
The function together with Node::getNumberOfParents lets you iterate through all parent Group of the Node.

The behavior is undefined if the function is called with an invalid index - that is, an index greater than or equal to whatever Node::getNumberOfParents returns.

NVSG_API const nvmath::Box3f& getBoundingBox ( ) const

Returns the bounding box of this Node.

Returns:
Returns the axis-aligned bounding box of the Node.

NVSG_API const nvmath::Sphere3f& getBoundingSphere ( ) const

Returns the Node's bounding sphere.

Returns:
The function returns a reference to a nvmath::Sphere3f that represents the Node's bounding sphere.
Remarks:
If the current bounding sphere turns out to be invalid, the function first calculates the bounding sphere from the containing geometry.
See also:
Node::calculateBoundingSphere

NVSG_API void invalidateBoundingVolumes ( )

Invalidates the bounding volumes of the Node.

Remarks:
The function invalidates the bounding volumes and that of all nodes up the hierarchy. This forces a re-calculation of the concrete bounding volumes with the next queries.
See also:
getBoundingBox, getBoundingShere

NVSG_API bool containsTransparentGeometry ( ) const

Tests whether the Node contains transparent geometry.

Returns:
The function returns true if the Node contains transparent geometry. Otherwise, the function returns false.
Remarks:
The function iterates through the underlying hierarchy to detect transparent geometry. Dependent on how complex the underlying hierarchy is, this could be an expensive operation. The result of this determination will be cached to make subsequent queries much faster as long as the cache remains valid. The cache might become invalid as geometry will be added to or removed from the Node.
See also:
Node::invalidateTransparencyContainment

void invalidateTransparencyContainment ( ) [inline]

Invalidates the transparency containment cache.

Remarks:
The function invalidates this Node's transparency containment cache and that of all nodes up the hierarchy. This forces a re-calculation of these caches with the very next query through Node::containsTransparentGeometry.

NVSG_API bool containsCgFx ( ) const

Retrieves the CgFx containment status of the Node.

Returns:
true if a CgFx is contained in the underlying sub-tree. false otherwise.
See also:
Node::invalidateCgFxContainment

void invalidateCgFxContainment ( ) [inline]

Invalidates the CgFx containment cache.

Remarks:
Querying the CgFx containment status from the underlying sub-tree could be an expensive task. For this reason the CgFx containment status is cached (lazy evaluation). For this mechanism to work properly, the particular cache needs to be invalidated whenever the CgFx containment status changes. This could be the case if a CgFx is added to, or removed from the tree. invalidateCgFxContainment invalidates the CgFx containment cache up the tree, forcing the very next query through containsCgFx to re-determine the actual CgFx containment status.

Normally you don't need to call invalidateCgFxContainment directly, since the function will be automatically invoked by the framework of CgFx managing core classes like StateSet and VolumeNode. However, if you intend to introduce a new CgFx managing Node or Node component, you need to call this function for every owning Node of your new class object, whenever the CgFx containment status changes.
See also:
containsCgFx

NVSG_API bool containsLight ( ) const

Retrieves the LightSource containment status of the Node.

Returns:
true if a LightSource is contained in the underlying sub-tree. false otherwise.
See also:
Node::invalidateLightContainment

void invalidateLightContainment ( ) [inline]

Invalidates the LightSource containment cache.

Remarks:
Querying the LightSource containment status from the underlying sub-tree could be an expensive task. For this reason the LightSource containment status is cached (lazy evaluation). For this mechanism to work properly, the particular cache needs to be invalidated whenever the LightSource containment status changes. This could be the case if a LightSource is added to, or removed from the tree. invalidateLightContainment invalidates the CgFx containment cache up the tree, forcing the very next query through containsLight to re-determine the actual LightSource containment status.

Normally you don't need to call invalidateLightContainment directly, since the function will be automatically invoked by the framework of LightSource managing core classes like Group. However, if you intend to introduce a new LightSource managing Node or Node component, you need to call this function for every owning Node of your new class object, whenever the LightSource containment status changes.
See also:
containsLight

NVSG_API bool containsLOD ( ) const

Retrieves the LOD containment status of the Node.

Returns:
true if a LOD is contained in the underlying sub-tree. false otherwise.
See also:
invalidateLODContainment

void invalidateLODContainment ( ) [inline]

Invalidates the LOD containment cache.

Remarks:
Querying the LOD containment status from the underlying sub-tree could be an expensive task. For this reason the LOD containment status is cached (lazy evaluation). For this mechanism to work properly, the particular cache needs to be invalidated whenever the LOD containment status changes. This could be the case if a LOD is added to, or removed from the tree. invalidateLODContainment invalidates the LOD containment cache up the tree, forcing the very next query through containsLOD to re-determine the actual LOD containment status.

Normally you don't need to call invalidateLODContainment directly, since the function will be automatically invoked by the framework of LOD managing core classes like StateSet and VolumeNode. However, if you intend to introduce a new LOD managing Node or Node component, you need to call this function for every owning Node of your new class object, whenever the LOD containment status changes.
See also:
containsLOD

NVSG_API bool containsVolumeNode ( ) const

Retrieves the VolumeNode containment status of the Node.

Returns:
true if a VolumeNode is contained in the underlying sub-tree. false otherwise.
See also:
invalidateVolumeNodeContainment

void invalidateVolumeNodeContainment ( ) [inline]

Invalidates the VolumeNode containment cache.

Remarks:
Querying the VolumeNode containment status from the underlying sub-tree could be an expensive task. For this reason the VolumeNode containment status is cached (lazy evaluation). For this mechanism to work properly, the particular cache needs to be invalidated whenever the LOD containment status changes. This could be the case if a LOD is added to, or removed from the tree. invalidateLODContainment invalidates the LOD containment cache up the tree, forcing the very next query through containsLOD to re-determine the actual LOD containment status.

Normally you don't need to call invalidateVolumeNodeContainment directly, since the function will be automatically invoked by the framework of VolumeNode managing core classes like Group. However, if you intend to introduce a new VolumeNode managing Node or Node component, you need to call this function for every owning Node of your new class object, whenever the VolumeNode containment status changes.
See also:
containsVolumeNode

NVSG_API bool containsAnimation ( ) const

Retrieves the Animation containment status of the Node.

Returns:
true if an Animation is contained in the underlying sub-tree. false otherwise.
See also:
invalidateAnimationContainment

void invalidateAnimationContainment ( ) [inline]

Invalidates the Animation containment cache.

Remarks:
Querying the Animation containment status from the underlying sub-tree could be an expensive task. For this reason the Animation containment status is cached (lazy evaluation). For this mechanism to work properly, the particular cache needs to be invalidated whenever the Animation containment status changes. This could be the case if an Animation is added to, or removed from the tree. invalidateAnimationContainment invalidates the Animation containment cache up the tree, forcing the very next query through containsAnimation to re-determine the actual Animation containment status.

Normally you don't need to call invalidateAnimationContainment directly, since the function will be automatically invoked by the framework of Animation managing core classes like Group. However, if you intend to introduce a new Animation managing Node or Node component, you need to call this function for every owning Node of your new class object, whenever the Animation containment status changes.
See also:
containsAnimation

unsigned short getHints ( unsigned short mask = 0xFFFF ) const [inline]

Get the hints to use on this Node.

Parameters:
mask An optional unsigned short to mask the hints to get. With the default mask every hint is returned.
Returns:
An unsigned short whose bits encode the hints on this Node.
See also:
setHints, addHints, removeHints, containsHints, invalidateHintsContainment

void setHints ( unsigned short hints ) [inline]

Set the hints to use on this Node.

Parameters:
hints An unsigned short whose bits encode the hints on this Node.
See also:
NodeHints

void addHints ( unsigned short hints ) [inline]

Convenience function to add some hints to the current set of hints.

Parameters:
hints An unsigned short whose bits encode the hints to add to the set of hints on this Node.
Remarks:
The current set of hints is bitwise or'ed with hints.
See also:
getHints, setHints, removeHints, containsHints, invalidateHintsContainment

void removeHints ( unsigned short hints ) [inline]

Convenience function to remove some hints from the current set of hints.

Parameters:
hints An unsigned short whose bits encode the hints to remove from the set of hints on this Node.
Remarks:
The current set of hints is bitwise and'ed with the bitwise complement of hints.
See also:
getHints, setHints, addHints, containsHints, invalidateHintsContainment

NVSG_API bool containsHints ( unsigned short hints ) const

Query if this Node or something beneath contains the given hints.

Parameters:
hints An unsigned short whose bits encode the hints that are queried.
Returns:
true, if each hint in hints is marked on this Node or somewhere beneath, Otherwise false.
Remarks:
Internally calls getHintsContainment
See also:
getHints, setHints, addHints, removeHints, invalidateHintsContainment, getHintsContainment

NVSG_API unsigned short getHintsContainment ( unsigned short hints ) const

Evaluate hints for this Node and all Nodes beneath for this set of hints.

Parameters:
hints An unsigned short whose bits encode the hints that are queried.
Returns:
An unsigned short that encodes the hints evaluated for the set of hints queried
Remarks:
This function is also called by containsHints to determine if a set of hints is contained by a node or its children
See also:
getHints, setHints, addHints, removeHints, invalidateHintsContainment, containsHints

NVSG_API void invalidateHintsContainment ( unsigned short hints )

Invalidates the containment flags for a set of hints.

Parameters:
hints An unsigned short whose bits encode the hints to invalidate the hint containment for.
Remarks:
If at least one hint in hints is valid in this Node, all the hints in hints are marked as invalid, and invalidateHintsContainment is called on each parent.
See also:
getHints, setHints, addHints, removeHints, containsHints

virtual NVSG_API bool invalidateIncarnation ( ) [virtual]

Overrides Object::invalidateIncarnation.

Remarks:
The function invalidates this Node's incarnation and that of the Node's parents. That is, it invalidates all incarnations of the Nodes up the hierarchy (bottom to top).

Reimplemented from Object.

Reimplemented in AnimatedTransform.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Overrides Object::validateIncarnation.

Remarks:
The function validates all caches maintained by the Node and then calls the base class implementation.
See also:
Object::getIncarnation, Node::invalidateIncarnation

Reimplemented from Object.

Reimplemented in AnimatedTransform, FlipbookAnimation, GeoNode, Group, and VolumeNode.

NVSG_API void invalidateContainment ( unsigned int mask )

Invalidates containment for the indicated states.

Parameters:
mask A bit mask indicating all containment states to be invalidated.
Remarks:
The function invalidate all containment states indicated by mask up the tree. Symbolic constants are used to set bits in the mask. mask is typically constructed by ORing several of these constants together. Allowed constants are NF_CONTAINS_TRANSPARENCY, NF_CONTAINS_CGFX, NF_CONTAINS_LIGHT, NF_CONTAINS_LOD, NF_CONTAINS_NUMBER_OF_FRAMES, and NF_CONTAINS_VOLUME_NODE. The special mask NF_CONTAINS_MASK can be used if all available containment states should be invalidated.

unsigned int getContainmentFlags ( ) const [inline]

Get the containment flags of this Node.

Returns:
A bit mask indicating all containment states in this Node.
See also:
getContainmentValidFlags

unsigned int getContainmentValidFlags ( ) const [inline]

Get the containment valid flags of this Node.

Returns:
A bit mask indicating all valid containment states in this Node.
See also:
getContainmentFlags

NVSG_API void assertInvalidBoundingSphere ( ) const

Prompts an assertion failed message if the Node's bounding box is valid.

Remarks:
This function is available only in the NVSG debug build.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, pure virtual]

Called from the framework if re-calculation of the Node's bounding box is required.

Returns:
The function returns a nvmath::Box3f that represents the actual bounding box of this Node.
Remarks:
The function is required to be implemented by concrete Node-derived classes to provide proper bounding box calculation.
See also:
nvmath::Box3f

Implemented in GeoNode, Group, Switch, Transform, and VolumeNode.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, pure virtual]

Called from the framework if re-calculation of the Node's bounding sphere is required.

Returns:
The function returns a nvmath::Sphere3f that represents the actual bounding sphere of this Node.
Remarks:
The function is required to be implemented by concrete Node-derived classes to provide proper bounding sphere calculation.
See also:
nvmath::Sphere3f

Implemented in GeoNode, Group, Switch, Transform, and VolumeNode.

virtual NVSG_API bool determineCgFxContainment ( ) const [protected, virtual]

Called from the framework if re-determination of CgFx containment is required.

Returns:
The default implementation always returns false, indicating that no CgFx is contained in the underlying sub-tree.
Remarks:
This function is called from the framework whenever re-determination of CgFx containment is required for the underlying sub-tree. Node-derived classes that can contain a CgFx should override this function to return the correct result.

Reimplemented in GeoNode, Group, Switch, and VolumeNode.

virtual NVSG_API bool determineLightContainment ( ) const [protected, virtual]

Called from the framework if re-determination of LightSource containment is required.

Returns:
The default implementation always returns false, indicating that no LightSource is contained in the underlying sub-tree.
Remarks:
This function is called from the framework whenever re-determination of LightSource containment is required for the underlying sub-tree. Node-derived classes that can contain a LightSource should override this function to return the correct result.

Reimplemented in Group, and Switch.

virtual NVSG_API bool determineLODContainment ( ) const [protected, virtual]

Called from the framework if re-determination of LOD containment is required.

Returns:
The default implementation always returns false, indicating that no LOD is contained in the underlying sub-tree.
Remarks:
This function is called from the framework whenever re-determination of LOD containment is required for the underlying sub-tree. Node-derived classes that can contain a LOD should override this function to return the correct result.

Reimplemented in Group, LOD, and Switch.

virtual NVSG_API bool determineVolumeNodeContainment ( ) const [protected, virtual]

Called from the framework if re-determination of VolumeNode containment is required.

Returns:
The default implementation always returns false, indicating that no VolumeNode is contained in the underlying sub-tree.
Remarks:
This function is called from the framework whenever re-determination of VolumeNode containment is required for the underlying sub-tree. Node-derived classes that can contain a VolumeNode should override this function to return the correct result.

Reimplemented in Group, Switch, and VolumeNode.

virtual NVSG_API unsigned short determineHintsContainment ( unsigned short hints ) const [protected, virtual]

Determine the hints containment status of this Node.

Parameters:
hints An unsigned short whose bits encode the hints containment to determine.
Returns:
An unsigned short whose bits encode the hints on this Node or'ed with the hints.
Remarks:
This function is called by the framework, if getHintsContainment is called while the hint containment flags mark that information as invalid.
See also:
containsHints, invalidateHintsContainment, getHintsContainment

Reimplemented in Group, and Switch.

virtual NVSG_API bool determineTransparencyContainment ( ) const [protected, pure virtual]

Called from the framework if re-determination of the transparency containment cache is required.

Returns:
The function returns true if the Node contains transparent geometry. Otherwise, the function returns false.
Remarks:
The function is required to be implemented by concrete Node-derived classes to provide proper determination of transparency containment.
See also:
Node::containsTransparentGeometry, Node::invalidateTransparencyContainment

Implemented in GeoNode, Group, Switch, and VolumeNode.

virtual NVSG_API bool determineAnimationContainment ( ) const [protected, virtual]

Called from the framework if re-determination of the transparency containment cache is required.

Returns:
true, if the Node contains at least one Animation, otherwise false.
Remarks:
The function is required to be implemented by concrete Node-derived classes to provide proper determination of Animation containment.
See also:
Node::containsAnimation, Node::invalidateAnimationContainment

Reimplemented in AnimatedTransform, FlipbookAnimation, GeoNode, and Group.

NVSG_API Node& operator= ( const Node & rhs ) [protected]

Assigns new content from another Node.

Parameters:
rhs Reference to a Node from which to assign the new content.
Returns:
A reference to this object.
Remarks:
The assignment operator unreferences the old content before assigning the new content. The new content will be a deep-copy of the content of right-hand-sided object.

NVSG_API void addAsParentTo ( NodeHandle * child ) [protected]

Adds this Node as a parent to child.

Parameters:
child A pointer to a NodeHandle to add this Node as a parent to.
See also:
removeAsParentFrom

NVSG_API void removeAsParentFrom ( NodeHandle * child ) [protected]

Removes this Node as a parent from child.

Parameters:
child A pointer to the NodeHandle to remove this Node as a parent from.
See also:
addAsParentTo

The documentation for this class was generated from the following file:
  • Node.h
Generated on Tue Jan 15 10:29:10 2008 for NVSGSDK by NVIDIA


Member List

Node Member List

This is the complete list of members for Node, including all inherited members.
addAsParentTo(NodeHandle *child) | Node | [protected]
addHints(unsigned short hints) | Node | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const=0 | Node | [protected, pure virtual]
calculateBoundingSphere() const=0 | Node | [protected, pure virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
determineAnimationContainment() const | Node | [protected, virtual]
determineCgFxContainment() const | Node | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineLightContainment() const | Node | [protected, virtual]
determineLODContainment() const | Node | [protected, virtual]
determineTransparencyContainment() const=0 | Node | [protected, pure virtual]
determineVolumeNodeContainment() const | Node | [protected, virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getName() const | Object |
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getUserData() const | Object | [inline]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
removeAsParentFrom(NodeHandle *child) | Node | [protected]
removeHints(unsigned short hints) | Node | [inline]
setAnnotation(const std::string &anno) | Object |
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Node | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:10 2008 for NVSGSDK by NVIDIA


NodeHintsCullTraverser Class Reference

CullTraverser that culls based on NodeHints information. More...

#include <NodeHintsCullTraverser.h>

Inheritance diagram for NodeHintsCullTraverser:

[legend]
Collaboration diagram for NodeHintsCullTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | NodeHintsCullTraverser (unsigned short uisNodeHints=nvsg::Node::NH_CULL_NEVER)
Default Constructor.

NVSG_API unsigned short | getHints (unsigned short mask=0xFFFF) const
Get the current hints which determinine the culling.

NVSG_API void | setHints (unsigned short hints)
Set the hints which determine the culling.

NVSG_API void | addHints (unsigned short hints)
Convenience function to add hints to the current set of hints.

NVSG_API void | removeHints (unsigned short hints)
Convenience function to remove some hints from the current set of hints.

Protected Member Functions

virtual NVSG_API | ~NodeHintsCullTraverser (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API nvsg::CullCode | cullCode (const nvmath::Sphere3f &bs) const
Re-implementation of the cullCode method.

Protected Attributes

unsigned short | m_NodeHints

Detailed Description

CullTraverser that culls based on NodeHints information.

Namespace: nvtraverser
Remarks:
The NodeHintsCullTraverser determines the nvsg::CullCode of nvsg::Node objects in a nvsg::Scene with respect to the NodeHints specified for that node. Specifically, if the NodeHints of a node under consideration match those of this traverser (specified at construction, or using setHints, addHints, removeHints), cullCode returns CC_OUT.

As a CullTraverser, it creates a tree of nvsg::CullData from these nvsg::CullCode's.

NodeHintsCullTraverser needs a valid ViewState, therefore use setViewState() prior to apply().
See also:
CullTraverser, nvsg::CullCode, nvsg::CullData, FrustumCullTraverser

Constructor & Destructor Documentation

NVSG_API NodeHintsCullTraverser ( unsigned short uisNodeHints = nvsg::Node::NH_CULL_NEVER )

Default Constructor.

Parameters:
uisNodeHints NodeHints information on the basis of which to cull.
Remarks:
NodeHintsCullTraverser does not modify the scene.

virtual NVSG_API ~NodeHintsCullTraverser ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the NodeHintsCullTraverser is decremented to zero.

Member Function Documentation

unsigned short getHints ( unsigned short mask = 0xFFFF ) const [inline]

Get the current hints which determinine the culling.

Parameters:
mask An optional unsigned short to mask the hints to get. With the default mask, every hint is returned.
Returns:
An unsigned short whose bits encode the hints determining containment.
See also:
setHints, addHints, removeHints, nvsg::Node::NodeHints

void setHints ( unsigned short hints ) [inline]

Set the hints which determine the culling.

Parameters:
hints An unsigned short whose bits encode the hints determining containment.
See also:
getHints, addHints, removeHints, nvsg::Node::NodeHints

void addHints ( unsigned short hints ) [inline]

Convenience function to add hints to the current set of hints.

Parameters:
hints An unsigned short whose bits encode the hints to add to the existin set of hints.
See also:
getHints, setHints, removeHints, nvsg::Node::NodeHints

void removeHints ( unsigned short hints ) [inline]

Convenience function to remove some hints from the current set of hints.

Parameters:
hints An unsigned short whose bits encode the hints to remove from the set of hints of this traverser.
Remarks:
The current set of hints is bitwise and'ed with the bitwise complement of the existing hints.
See also:
getHints, setHints, addHints, nvsg::Node::NodeHints

virtual NVSG_API nvsg::CullCode cullCode ( const nvmath::Sphere3f & bs ) const [protected, virtual]

Re-implementation of the cullCode method.

Parameters:
bs A constant reference to the bounding sphere of wich the nvsg::CullCode is to be computed.
Returns:
The nvsg::CullCode of the bounding sphere bs wrt the NodeHints.
See also:
CullTraverser

Reimplemented from CullTraverser.

The documentation for this class was generated from the following file:
  • NodeHintsCullTraverser.h
Generated on Tue Jan 15 10:29:32 2008 for NVSGSDK by NVIDIA


Member List

NodeHintsCullTraverser Member List

This is the complete list of members for NodeHintsCullTraverser, including all inherited members.
addHints(unsigned short hints) | NodeHintsCullTraverser | [inline]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
cullCode(const nvmath::Sphere3f &bs) const | NodeHintsCullTraverser | [protected, virtual]
CullTraverser() | CullTraverser | [protected]
doApply(nvsg::NodeHandle *root) | CullTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
getCurrentHints() const | CullTraverser | [inline, protected]
getCurrentHintsContainment() const | CullTraverser | [inline, protected]
getHints(unsigned short mask=0xFFFF) const | NodeHintsCullTraverser | [inline]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SharedModelViewTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | SharedTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | CullTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *p) | CullTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | CullTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | CullTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | SharedTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | SharedTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | CullTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | SharedTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | SharedTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | SharedTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | SharedTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | CullTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *variant) | SharedTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | CullTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | CullTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | SharedTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | SharedTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | SharedTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SharedTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *p) | CullTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedModelViewTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedCamera | SharedModelViewTraverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_NodeHints (defined in NodeHintsCullTraverser) | NodeHintsCullTraverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | SharedModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NodeHintsCullTraverser(unsigned short uisNodeHints=nvsg::Node::NH_CULL_NEVER) | NodeHintsCullTraverser |
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | CullTraverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | SharedModelViewTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | SharedModelViewTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeHints(unsigned short hints) | NodeHintsCullTraverser | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setHints(unsigned short hints) | NodeHintsCullTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedModelViewTraverser() | SharedModelViewTraverser | [protected]
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | CullTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~CullTraverser(void) | CullTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~NodeHintsCullTraverser(void) | NodeHintsCullTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedModelViewTraverser() | SharedModelViewTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:32 2008 for NVSGSDK by NVIDIA


NormalizeTraverser Class Reference

Traverser that normalizes all normals. More...

#include <NormalizeTraverser.h>

Inheritance diagram for NormalizeTraverser:

[legend]
Collaboration diagram for NormalizeTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | NormalizeTraverser (void)
Constructor.

NVSG_API unsigned int | getVertexAttributeIndex () const
Get the index of the VertexAttributeSet that is to be normalized.

NVSG_API void | setVertexAttributeIndex (unsigned int attrib)
Set the index of the VertexAttributeSet that is to be normalized.

Protected Member Functions

virtual NVSG_API | ~NormalizeTraverser (void)
Protected destructor to prevent instantiation of a NormalizeTraverser on stack.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Initiate traversal of the scene.

virtual NVSG_API void | handleVertexAttributeSet (nvsg::VertexAttributeSet *p)
Normalize VertexAttributeSets.

virtual NVSG_API void | handleAnimatedVertexAttributeSet (nvsg::AnimatedVertexAttributeSet *p)
Normalize AnimatedVertexAttributeSet.

virtual NVSG_API void | handleFramedVertexAttributeAnimation (nvsg::FramedAnimation< nvsg::VertexAttribute > *p)
Normalize FramedAnimation<VertexAttribute>.

virtual NVSG_API void | handleLinearInterpolatedVertexAttributeAnimation (nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p)
Normalize LinearInterpolatedAnimation<VertexAttribute>.

Detailed Description

Traverser that normalizes all normals.

Constructor & Destructor Documentation

NVSG_API NormalizeTraverser ( void )

Constructor.

virtual NVSG_API ~NormalizeTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a NormalizeTraverser on stack.

Member Function Documentation

unsigned int getVertexAttributeIndex ( ) const [inline]

Get the index of the VertexAttributeSet that is to be normalized.

The default index for normalizing is NORMAL.

void setVertexAttributeIndex ( unsigned int attrib ) [inline]

Set the index of the VertexAttributeSet that is to be normalized.

The default index for normalizing is NORMAL.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Initiate traversal of the scene.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleVertexAttributeSet ( nvsg::VertexAttributeSet * p ) [protected, virtual]

Normalize VertexAttributeSets.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleAnimatedVertexAttributeSet ( nvsg::AnimatedVertexAttributeSet * p ) [protected, virtual]

Normalize AnimatedVertexAttributeSet.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleFramedVertexAttributeAnimation ( nvsg::FramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Normalize FramedAnimation<VertexAttribute>.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLinearInterpolatedVertexAttributeAnimation ( nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Normalize LinearInterpolatedAnimation<VertexAttribute>.

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • NormalizeTraverser.h
Generated on Tue Jan 15 10:29:32 2008 for NVSGSDK by NVIDIA


Member List

NormalizeTraverser Member List

This is the complete list of members for NormalizeTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | NormalizeTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getVertexAttributeIndex() const | NormalizeTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *p) | NormalizeTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | NormalizeTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | ExclusiveTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | NormalizeTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *p) | NormalizeTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NormalizeTraverser(void) | NormalizeTraverser |
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setVertexAttributeIndex(unsigned int attrib) | NormalizeTraverser | [inline]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~NormalizeTraverser(void) | NormalizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:32 2008 for NVSGSDK by NVIDIA


NullNormalsResult Class Reference

AnalyzeResult indicating a VertexAttributeSet with null normals. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for NullNormalsResult:

[legend]
Collaboration diagram for NullNormalsResult:

[legend]
List of all members.

Public Member Functions

virtual | ~NullNormalsResult ()
Virtual Destructor.

Public Attributes

unsigned int | nullNormalsCount
The number of objects with null normals.

unsigned int | nullNormalsNumber
The number of null normals in those objects.

Detailed Description

AnalyzeResult indicating a VertexAttributeSet with null normals.

Namespace: nvsg
Remarks:
Reports if there is a VertexAttributeSet with null normals.
See also:
AnalyzeResult, AnalyzeTraverser

Constructor & Destructor Documentation

virtual ~NullNormalsResult ( ) [inline, virtual]

Virtual Destructor.

Member Data Documentation

unsigned int nullNormalsCount

The number of objects with null normals.

unsigned int nullNormalsNumber

The number of null normals in those objects.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


Member List

NullNormalsResult Member List

This is the complete list of members for NullNormalsResult, including all inherited members.
nullNormalsCount | NullNormalsResult |
nullNormalsNumber | NullNormalsResult |
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~NullNormalsResult() | NullNormalsResult | [inline, virtual]
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


NVBLoader Class Reference

A Scene Loader for nvb files. More...

#include <NVBLoader.h>

Inheritance diagram for NVBLoader:

[legend]
Collaboration diagram for NVBLoader:

[legend]
List of all members.

Public Member Functions

void | deleteThis (void)
Realization of the pure virtual interface function of a PlugIn.

nvsg::SceneHandle * | load (const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState)
Realization of the pure virtual interface function of a SceneLoader.

Protected Member Functions

virtual | ~NVBLoader (void)
Protected destructor to prevent explicit creation on stack.

Detailed Description

A Scene Loader for nvb files.

NVB files can be produced with a special exporter tool with 3D Studio MAX. They can include cgfx effects.

Note:
The Textures of a scene file are given with absolute code pathes they had when creating the nvb file. The loader first searches them first at these absolute positions, and later in the search paths given.

Constructor & Destructor Documentation

~NVBLoader ( void ) [inline, protected, virtual]

Protected destructor to prevent explicit creation on stack.

Member Function Documentation

void deleteThis ( void ) [inline, virtual]

Realization of the pure virtual interface function of a PlugIn.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

nvsg::SceneHandle* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | nvsg::ViewStateHandle *& | viewState
 | ) | [virtual]

Realization of the pure virtual interface function of a SceneLoader.

Loads a nvb file given by filename. It looks for this file and possibly referenced other files like textures or effects at the given path first, then at the current location and finally it searches through the searchPaths.

Returns:
A pointer to the loaded scene.
Parameters:
filename | file to load
searchPaths | paths to search through
viewState | If the function succeeded, this points to the optional ViewState stored with the scene.

Implements SceneLoader.

The documentation for this class was generated from the following file:
  • NVBLoader.h
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


Member List

NVBLoader Member List

This is the complete list of members for NVBLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | NVBLoader | [inline, virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState) | NVBLoader | [virtual]
NVBLoader() (defined in NVBLoader) | NVBLoader | [inline]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~NVBLoader(void) | NVBLoader | [inline, protected, virtual]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneLoader() | SceneLoader | [protected, virtual]
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


NVBLoadTraverser Class Reference

Internally used traverser for post-processing a just loaded NVB file. More...

#include <NVBLoadTraverser.h>

Inheritance diagram for NVBLoadTraverser:

[legend]
Collaboration diagram for NVBLoadTraverser:

[legend]
List of all members.

Public Member Functions

NVBLoadTraverser (std::vector< nvsg::MaterialHandle * > &faceMappedMaterials)
Constructor.

virtual | ~NVBLoadTraverser (void)
Destructor.

Protected Member Functions

virtual void | handleCgFx (nvsg::CgFx *p)
Postprocessing on CgFx.

virtual void | handleGeoNode (nvsg::GeoNode *p)
Postprocessing on GeoNode.

virtual void | handleLOD (nvsg::LOD *p)
Postprocessing on LOD: Shouldn't be called at any time !

virtual void | handleMaterial (nvsg::Material *p, bool reset)
Postprocessing on Material.

virtual void | handleStateSet (nvsg::StateSet *p)
Postprocessing on StateSet.

virtual void | handleSwitch (nvsg::Switch *p)
Postprocessing on Switch: Shouldn't be called at any time !

virtual void | handleTriangles (nvsg::Triangles *p)
Postprocessig on Triangles.

Detailed Description

Internally used traverser for post-processing a just loaded NVB file.

Constructor & Destructor Documentation

NVBLoadTraverser ( std::vector< nvsg::MaterialHandle * > & faceMappedMaterials )

Constructor.

virtual ~NVBLoadTraverser ( void ) [virtual]

Destructor.

Member Function Documentation

virtual void handleCgFx ( nvsg::CgFx * p ) [protected, virtual]

Postprocessing on CgFx.

Just stores that a StateAttribute of type CgFx is encountered.

Reimplemented from ExclusiveTraverser.

virtual void handleGeoNode ( nvsg::GeoNode * p ) [protected, virtual]

Postprocessing on GeoNode.

Traverses the GeoNode p and clears the state of encountering a CgFx.

Reimplemented from ExclusiveTraverser.

virtual void handleLOD ( nvsg::LOD * p ) [inline, protected, virtual]

Postprocessing on LOD: Shouldn't be called at any time !

Reimplemented from ExclusiveTraverser.

virtual void handleMaterial | ( | nvsg::Material * | p,
 |  | bool | reset
 | ) | [protected, virtual]

Postprocessing on Material.

Stores the current Material for later references in a GeoSet.

virtual void handleStateSet ( nvsg::StateSet * p ) [protected, virtual]

Postprocessing on StateSet.

Clears the current Material and traverses the StateSet p.

Reimplemented from ExclusiveTraverser.

virtual void handleSwitch ( nvsg::Switch * p ) [inline, protected, virtual]

Postprocessing on Switch: Shouldn't be called at any time !

Reimplemented from ExclusiveTraverser.

virtual void handleTriangles ( nvsg::Triangles * p ) [protected, virtual]

Postprocessig on Triangles.

For Triangles with a face mapped material on it the texture coordinates are remapped. For Triangles with a CgFx on it Texture coordinates as well as tangents and binormals are created.

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • NVBLoadTraverser.h
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


Member List

NVBLoadTraverser Member List

This is the complete list of members for NVBLoadTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | ExclusiveTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *p) | NVBLoadTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *p) | NVBLoadTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *p) | NVBLoadTraverser | [inline, protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *p, bool reset) | NVBLoadTraverser | [protected, virtual]
nvtraverser::ExclusiveTraverser::handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *p) | NVBLoadTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *p) | NVBLoadTraverser | [inline, protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *p) | NVBLoadTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVBLoadTraverser(std::vector< nvsg::MaterialHandle * > &faceMappedMaterials) | NVBLoadTraverser |
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~NVBLoadTraverser(void) | NVBLoadTraverser | [virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:28:44 2008 for NVSGSDK by NVIDIA


NVNVB Class Reference

Internally used class for loading NVB files. More...

#include <NVNVB.h>

Collaboration diagram for NVNVB:

[legend]
List of all members.

Public Member Functions

nvsg::SceneHandle * | load (const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState)
Interface function to load a file.

virtual bool | NewScene (const NVBRenderManager::NVBSceneInfo &scene)
Handler called after loading a new Scene info.

virtual bool | NewCamera (const NVBRenderManager::NVBCameraInfo &camera)
Handler called after loading a new Camera info.

virtual bool | NewLight (const NVBRenderManager::NVBLightInfo &light)
Handler called after loading a new Light info.

virtual bool | NewMaterial (const NVBRenderManager::NVBMaterialInfo &material)
Handler called after loading a new Material info.

virtual bool | NewTexture (const NVBRenderManager::NVBTextureInfo &texture)
Handler called after loading a new Texture info.

virtual bool | NewMesh (const NVBRenderManager::NVBMeshInfo &mesh)
Handler called after loading a new Mesh info.

virtual bool | NewShape (const NVBRenderManager::NVBShapeInfo &shape)
Handler called after loading a new Shape info.

virtual bool | NewHelper (const NVBRenderManager::NVBHelperInfo &helper)
Handler called after loading a new Helper info.

virtual bool | NewController (const NVBRenderManager::NVBControllerInfo &controller)
Handler called after loading a new Controller info.

virtual bool | NewMotion (const NVBRenderManager::NVBMotionInfo &motion)
Handler called after loading a new Motion info.

virtual bool | EndImport (void)
Handler called at end of loading for post-processing.

virtual bool | NVBImportError (const char *errortext, udword errorcode)
Application-dependent error handler.

virtual void | NVBLog (NVBRenderManager::TLogLevel level, LPSTR fmt,...)
Application-dependent log method.

virtual void | SetLogCallback (NVBRenderManager::TloggingCB cbfn, unsigned long userparam=0)
For setting the Application-dependent log method.

Detailed Description

Internally used class for loading NVB files.

Member Function Documentation

nvsg::SceneHandle* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | nvsg::ViewStateHandle *& | viewState
 | ) |

Interface function to load a file.

Returns:
pointer to the scene in the file.
Parameters:
filename | name of file to load
searchPaths | array of paths to use for searching

virtual bool NewScene ( const NVBRenderManager::NVBSceneInfo & scene ) [virtual]

Handler called after loading a new Scene info.

virtual bool NewCamera ( const NVBRenderManager::NVBCameraInfo & camera ) [virtual]

Handler called after loading a new Camera info.

virtual bool NewLight ( const NVBRenderManager::NVBLightInfo & light ) [virtual]

Handler called after loading a new Light info.

virtual bool NewMaterial ( const NVBRenderManager::NVBMaterialInfo & material ) [virtual]

Handler called after loading a new Material info.

virtual bool NewTexture ( const NVBRenderManager::NVBTextureInfo & texture ) [virtual]

Handler called after loading a new Texture info.

virtual bool NewMesh ( const NVBRenderManager::NVBMeshInfo & mesh ) [virtual]

Handler called after loading a new Mesh info.

virtual bool NewShape ( const NVBRenderManager::NVBShapeInfo & shape ) [virtual]

Handler called after loading a new Shape info.

virtual bool NewHelper ( const NVBRenderManager::NVBHelperInfo & helper ) [virtual]

Handler called after loading a new Helper info.

virtual bool NewController ( const NVBRenderManager::NVBControllerInfo & controller ) [virtual]

Handler called after loading a new Controller info.

virtual bool NewMotion ( const NVBRenderManager::NVBMotionInfo & motion ) [virtual]

Handler called after loading a new Motion info.

virtual bool EndImport ( void ) [virtual]

Handler called at end of loading for post-processing.

virtual bool NVBImportError | ( | const char * | errortext,
 |  | udword | errorcode
 | ) | [virtual]

Application-dependent error handler.

virtual void NVBLog | ( | NVBRenderManager::TLogLevel | level,
 |  | LPSTR | fmt,
 |  | ... |
 | ) | [virtual]

Application-dependent log method.

virtual void SetLogCallback | ( | NVBRenderManager::TloggingCB | cbfn,
 |  | unsigned long | userparam = 0
 | ) | [virtual]

For setting the Application-dependent log method.

The documentation for this class was generated from the following file:
  • NVNVB.h
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

NVNVB Member List

This is the complete list of members for NVNVB, including all inherited members.
EndImport(void) | NVNVB | [virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState) | NVNVB |
NewCamera(const NVBRenderManager::NVBCameraInfo &camera) | NVNVB | [virtual]
NewController(const NVBRenderManager::NVBControllerInfo &controller) | NVNVB | [virtual]
NewHelper(const NVBRenderManager::NVBHelperInfo &helper) | NVNVB | [virtual]
NewLight(const NVBRenderManager::NVBLightInfo &light) | NVNVB | [virtual]
NewMaterial(const NVBRenderManager::NVBMaterialInfo &material) | NVNVB | [virtual]
NewMesh(const NVBRenderManager::NVBMeshInfo &mesh) | NVNVB | [virtual]
NewMotion(const NVBRenderManager::NVBMotionInfo &motion) | NVNVB | [virtual]
NewScene(const NVBRenderManager::NVBSceneInfo &scene) | NVNVB | [virtual]
NewShape(const NVBRenderManager::NVBShapeInfo &shape) | NVNVB | [virtual]
NewTexture(const NVBRenderManager::NVBTextureInfo &texture) | NVNVB | [virtual]
NVBImportError(const char *errortext, udword errorcode) | NVNVB | [virtual]
NVBLog(NVBRenderManager::TLogLevel level, LPSTR fmt,...) | NVNVB | [virtual]
NVNVB(void) (defined in NVNVB) | NVNVB |
SetLogCallback(NVBRenderManager::TloggingCB cbfn, unsigned long userparam=0) | NVNVB | [virtual]
~NVNVB(void) (defined in NVNVB) | NVNVB |
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


NVSGException Class Reference

#include <ErrorHandling.h>

List of all members.

Public Member Functions

NVSGException (bool critical, const std::string &errMsg)
NVSGException (bool critical, unsigned int errMsgID)
virtual bool | isCritical () const
virtual const std::string & | getErrorMessage () const

Detailed Description

Exception base class. Derive from this class if you intend to provide more specific exceptions.

Constructor & Destructor Documentation

NVSGException | ( | bool | critical,
 |  | const std::string & | errMsg
 | ) | [inline]

Constructs a NVSGExeption object

Parameters

  • critical Assigns whether this will be treated as a critical or noncritical exception.
  • errMsg The related error message to be displayed with subsequent error handling.

NVSGException | ( | bool | critical,
 |  | unsigned int | errMsgID
 | ) | [inline]

Constructs a NVSGExeption object

Parameters

  • critical Assigns whether this will be treated as a critical or noncritical exception.
  • errMsgID Identifies a string resource whithin a string table that holds the related error message to be displayed with subsequent error handling.

Note This is not implemented yet. Use the NVSGException(bool, const string&) variant instead.

Member Function Documentation

bool isCritical ( ) const [inline, virtual]

Tests whether this exception is critical to the execution of subsequent code. For example, an error handler routine can query the critical status of an exception, and then decide to either throw the exception (if it is critical) or pop up a message box and then resume execution.

Return value true if this is a critical exception and execution of subsequent code is not possible; false if this exception is noncritical.

const std::string & getErrorMessage ( ) const [inline, virtual]

Receive the exception's error message.

Return value A reference to a const string object holding the exception's error message.

The documentation for this class was generated from the following file:
  • ErrorHandling.h
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


Member List

NVSGException Member List

This is the complete list of members for NVSGException, including all inherited members.
getErrorMessage() const | NVSGException | [inline, virtual]
isCritical() const | NVSGException | [inline, virtual]
NVSGException(bool critical, const std::string &errMsg) | NVSGException | [inline]
NVSGException(bool critical, unsigned int errMsgID) | NVSGException | [inline]
~NVSGException() (defined in NVSGException) | NVSGException | [inline, virtual]
Generated on Tue Jan 15 10:29:03 2008 for NVSGSDK by NVIDIA


NVSGLight Struct Reference

The NVSGLight structure specifies the data layout for an effect light parameter. More...

List of all members.

Public Attributes

float4 | ambient
Specifies the ambient RGBA intensity of the light.

float4 | diffuse
Specifies the diffuse RGBA intensity of the light.

float4 | specular
Specifies the specular RGBA intensity of the light.

float4 | position
Specifies the light position in world coordinates.

float4 | direction
Specifies the light direction in world coordinates.

float | spotExponent
Specifies the intensity distribution of the light.

float | spotCutoff
Specifies the maximum spread angle of the light.

float | constantAttenuation
Specifies the constant light attenuation factor.

float | linearAttenuation
Specifies the linear light attenuation factor.

float | quadraticAttenuation
Specifies the quadratic light attenuation factor.

Detailed Description

The NVSGLight structure specifies the data layout for an effect light parameter.

A parameter of type NVSGLight will be automatic bound to a tree light in NVSG.

Member Data Documentation

float4 ambient

Specifies the ambient RGBA intensity of the light.

float4 diffuse

Specifies the diffuse RGBA intensity of the light.

float4 specular

Specifies the specular RGBA intensity of the light.

float4 position

Specifies the light position in world coordinates.

float4 direction

Specifies the light direction in world coordinates.

float spotExponent

Specifies the intensity distribution of the light.

float spotCutoff

Specifies the maximum spread angle of the light.

float constantAttenuation

Specifies the constant light attenuation factor.

float linearAttenuation

Specifies the linear light attenuation factor.

float quadraticAttenuation

Specifies the quadratic light attenuation factor.

The documentation for this struct was generated from the following file:
  • NVSGLight.cg
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

NVSGLight Member List

This is the complete list of members for NVSGLight, including all inherited members.
ambient | NVSGLight
constantAttenuation | NVSGLight
diffuse | NVSGLight
direction | NVSGLight
linearAttenuation | NVSGLight
position | NVSGLight
quadraticAttenuation | NVSGLight
specular | NVSGLight
spotCutoff | NVSGLight
spotExponent | NVSGLight
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


NVSGLoader Class Reference

A Scene Loader for nvsg files. More...

#include <NVSGLoader.h>

Inheritance diagram for NVSGLoader:

[legend]
Collaboration diagram for NVSGLoader:

[legend]
List of all members.

Public Member Functions

void | deleteThis (void)
Realization of the pure virtual interface function of a PlugIn.

nvsg::SceneHandle * | load (const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState)
Realization of the pure virtual interface function of a SceneLoader.

Detailed Description

A Scene Loader for nvsg files.

NVSG files can be produced with the sample ViewerVR. They are text files that represent a Scene and a ViewState.

Member Function Documentation

void deleteThis ( void ) [inline, virtual]

Realization of the pure virtual interface function of a PlugIn.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

nvsg::SceneHandle* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | nvsg::ViewStateHandle *& | viewState
 | ) | [virtual]

Realization of the pure virtual interface function of a SceneLoader.

Loads a nvsg file given by filename. It looks for this file and possibly referenced other files like textures or effects at the given path first, then at the current location and finally it searches through the searchPaths.

Returns:
A pointer to the loaded scene.
Parameters:
filename | file to load
searchPaths | paths to search through
viewState | If the function succeeded, this points to the optional ViewState stored with the scene.

Implements SceneLoader.

The documentation for this class was generated from the following file:
  • NVSGLoader.h
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

NVSGLoader Member List

This is the complete list of members for NVSGLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | NVSGLoader | [inline, virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState) | NVSGLoader | [virtual]
NVSGLoader() (defined in NVSGLoader) | NVSGLoader |
PlugIn() (defined in PlugIn) | PlugIn | [inline]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~NVSGLoader() (defined in NVSGLoader) | NVSGLoader |
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneLoader() | SceneLoader | [protected, virtual]
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


NVSGMaterial Struct Reference

The NVSGMaterial structure specifies the data layout for an effect material parameter. More...

List of all members.

Public Attributes

float4 | ambient
Specifies the ambient RGBA reflectance of the material.

float4 | diffuse
Specifies the diffuse RGBA reflectance of the material.

float4 | specular
Specifies the specular RGBA reflectance of the material.

float4 | emission
Specifies the RGBA emitted light intensity of the material.

float | shininess
Specifies the RGBA specular exponent of the material.

Detailed Description

The NVSGMaterial structure specifies the data layout for an effect material parameter.

A parameter of type NVSGMaterial will be automatic bound to a NVSG material.

Member Data Documentation

float4 ambient

Specifies the ambient RGBA reflectance of the material.

float4 diffuse

Specifies the diffuse RGBA reflectance of the material.

float4 specular

Specifies the specular RGBA reflectance of the material.

float4 emission

Specifies the RGBA emitted light intensity of the material.

float shininess

Specifies the RGBA specular exponent of the material.

The documentation for this struct was generated from the following file:
  • NVSGMaterial.cg
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

NVSGMaterial Member List

This is the complete list of members for NVSGMaterial, including all inherited members.
ambient | NVSGMaterial
diffuse | NVSGMaterial
emission | NVSGMaterial
shininess | NVSGMaterial
specular | NVSGMaterial
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


NVSGSaver Class Reference

A Scene Saver for nvsg files. More...

#include <NVSGSaver.h>

Inheritance diagram for NVSGSaver:

[legend]
Collaboration diagram for NVSGSaver:

[legend]
List of all members.

Public Member Functions

void | deleteThis (void)
PlugIn interface.

bool | save (nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState, const std::string &filename)
Realization of the pure virtual interface function of a SceneSaver.

Detailed Description

A Scene Saver for nvsg files.

NVSG files can be produced with the sample ViewerVR. They are text files that represent a Scene and a ViewState.

Member Function Documentation

void deleteThis ( void ) [inline, virtual]

PlugIn interface.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

bool save | ( | nvsg::SceneHandle * | scene,
 |  | nvsg::ViewStateHandle * | viewState,
 |  | const std::string & | filename
 | ) | [virtual]

Realization of the pure virtual interface function of a SceneSaver.

Saves the scene and the viewState to filename.

Parameters:
scene | scene to save
viewState | view state to save
filename | file name to save to

Implements SceneSaver.

The documentation for this class was generated from the following file:
  • NVSGSaver.h
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

NVSGSaver Member List

This is the complete list of members for NVSGSaver, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | NVSGSaver | [inline, virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState, const std::string &filename) | NVSGSaver | [virtual]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneSaver() | SceneSaver | [protected, virtual]
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


NVSGSaveTraverser Class Reference

A Traverser to traverse a scene on saving to nvsg file format. More...

#include <NVSGSaver.h>

Inheritance diagram for NVSGSaveTraverser:

[legend]
Collaboration diagram for NVSGSaveTraverser:

[legend]
List of all members.

Public Member Functions

NVSGSaveTraverser ()
Default constructor.

void | setFILE (FILE *fh)
Sets the FILE where the scene is to be saved to.

Protected Member Functions

bool | preApply (nvsg::NodeHandle *root)
Notifier called from the framework directly before traversal starts.

void | doApply (nvsg::NodeHandle *root)
Controls saving of the scene together with a ViewState.

virtual void | handleParallelCamera (const nvsg::ParallelCamera *p)
Save a ParallelCamera.

virtual void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *p)
Save a PerspectiveCamera.

virtual void | handleBillboard (const nvsg::Billboard *p)
Save a Billboard.

virtual void | handleGeoNode (const nvsg::GeoNode *p)
Save a GeoNode.

virtual void | handleVolumeNode (const nvsg::VolumeNode *p)
Save a VolumeNode.

virtual void | handleGroup (const nvsg::Group *p)
Save a Group.

virtual void | handleFlipbookAnimation (const nvsg::FlipbookAnimation *p)
Save a FlipbookAnimation.

virtual void | handleTransform (const nvsg::Transform *p)
Save a Transform.

virtual void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Save an AnimatedTransform.

virtual void | handleLOD (const nvsg::LOD *p)
Save a LOD.

virtual void | handleSwitch (const nvsg::Switch *p)
Save a Switch.

virtual void | handleDirectedLight (const nvsg::DirectedLight *p)
Save a DirectedLight.

virtual void | handlePointLight (const nvsg::PointLight *p)
Save a PointLight.

virtual void | handleSpotLight (const nvsg::SpotLight *p)
Save a SpotLight.

virtual void | handleStateSet (const nvsg::StateSet *p)
Save a StateSet.

virtual void | handleStateVariant (const nvsg::StateVariant *p)
Save a StateVariant.

virtual void | handleStatePass (const nvsg::StatePass *p)
Save a StatePass.

virtual void | handleBlendAttribute (const nvsg::BlendAttribute *p)
Save a BlendAttribute.

virtual void | handleCgFx (const nvsg::CgFx *p)
Save a CgFx.

virtual void | handleDepthAttribute (const nvsg::DepthAttribute *p)
Save a DepthAttribute.

virtual void | handleFaceAttribute (const nvsg::FaceAttribute *p)
Save a FaceAttribute.

virtual void | handleLineAttribute (const nvsg::LineAttribute *p)
Save a LineAttribute.

virtual void | handleAlphaTestAttribute (const nvsg::AlphaTestAttribute *p)
Save a AlphaTestAttribute.

virtual void | handleLightingAttribute (const nvsg::LightingAttribute *p)
Save a LightingAttribute.

virtual void | handleMaterial (const nvsg::Material *p)
Save a Material.

virtual void | handlePointAttribute (const nvsg::PointAttribute *p)
Save a PointAttribute.

virtual void | handleTextureAttribute (const nvsg::TextureAttribute *p)
Save a TextureAttribute.

virtual void | handleTextureAttributeItem (const nvsg::TextureAttributeItem *p, unsigned int tu)
Save a TextureAttributeItem.

virtual void | handleUnlitColorAttribute (const nvsg::UnlitColorAttribute *p)
Save an UnlitColorAttribute.

virtual void | handleTriangles (const nvsg::Triangles *p)
Save a Triangles.

virtual void | handleSkinnedTriangles (const nvsg::SkinnedTriangles *p)
Save a SkinnedTriangles.

virtual void | handleTriFans (const nvsg::TriFans *p)
Save a TriFans.

virtual void | handleTriStrips (const nvsg::TriStrips *p)
Save a TriStrips.

virtual void | handleQuadMeshes (const nvsg::QuadMeshes *p)
Save a QuadMeshes.

virtual void | handleQuads (const nvsg::Quads *p)
Save a Quads.

virtual void | handleQuadStrips (const nvsg::QuadStrips *p)
Save a QuadStrips.

virtual void | handleLines (const nvsg::Lines *p)
Save a Lines.

virtual void | handleLineStrips (const nvsg::LineStrips *p)
Save a LineStrips.

virtual void | handlePoints (const nvsg::Points *p)
Save a Points.

virtual void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *p)
Save a VertexAttributeSet.

virtual void | handleAnimatedVertexAttributeSet (const nvsg::AnimatedVertexAttributeSet *p)
Save an AnimatedVertexAttributeSet.

virtual void | handleSkin (const nvsg::Skin *p)
Save a SkinnedVertexAttributeSet.

virtual void | handleFramedIndexAnimation (const nvsg::FramedAnimation< unsigned int > *p)
Save a FramedIndexAnimation.

virtual void | handleFramedTrafoAnimation (const nvsg::FramedAnimation< nvmath::Trafo > *p)
Save a FramedTrafoAnimation.

virtual void | handleFramedVertexAttributeAnimation (const nvsg::FramedAnimation< nvsg::VertexAttribute > *p)
Save a FramedAnimation<VertexAttribute>.

virtual void | handleLinearInterpolatedTrafoAnimation (const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p)
Save a LinearInterpolatedTrafoAnimation.

virtual void | handleLinearInterpolatedVertexAttributeAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p)
Save a LinearInterpolatedAnimation<VertexAttribute>.

Detailed Description

A Traverser to traverse a scene on saving to nvsg file format.

Note:
Needs a valid ViewState. Call setViewState prior to apply().

Constructor & Destructor Documentation

NVSGSaveTraverser ( )

Default constructor.

Member Function Documentation

void setFILE ( FILE * fh )

Sets the FILE where the scene is to be saved to.

Parameters:
fh FILE to save to

bool preApply ( nvsg::NodeHandle * root ) [protected, virtual]

Notifier called from the framework directly before traversal starts.

Parameters:
root A pointer to NodeHandle to be traversed.
Returns:
The default implementation always return true in order to continue traversal of root to proceed.
Remarks:
Custom traversers might override this notifier to process some pre-traversal work. A customized preApply notifier should return true to force the traversal of the specified root node to proceed. Returning false prevents the specified root node from being traversed.
At the time of call, a custom override can rely on the optional Scene and the optional ViewState both _not_ being locked for read or write access by the calling thread.
Note:
If the function returns false, traversal of root is skipped.

Not calling the base implementation might result in undefined runtime behavior.

Example:
    MyTraverser::doApply( nvsg::NodeHandle * root )
    {
      //  Do some pre-traversal bookholding or whatever
      //  ...

      //  call the base implementation and return
      return( Traverser::preApply( root ) );
    }
See also:
postApply

Reimplemented from Traverser.

void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Controls saving of the scene together with a ViewState.

Note:
This version ignores the ViewState and the Tweakables of the CgFx objects.

Reimplemented from SharedTraverser.

virtual void handleParallelCamera ( const nvsg::ParallelCamera * p ) [protected, virtual]

Save a ParallelCamera.

If the ParallelCarmera p is encountered on saving the first time, it is traversed with root and then it's saved.

Reimplemented from SharedTraverser.

virtual void handlePerspectiveCamera ( const nvsg::PerspectiveCamera * p ) [protected, virtual]

Save a PerspectiveCamera.

If the PerspectiveCamera p is encountered on saving the first time, it is traversed with root and then it's saved.

Reimplemented from SharedTraverser.

virtual void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Save a Billboard.

If the Billboard p is encountered on saving the first time, it is traversed and then saved.

Reimplemented from SharedTraverser.

virtual void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Save a GeoNode.

If the GeoNode p is encountered on saving the first time, it is traversed and then saved.

Reimplemented from SharedTraverser.

virtual void handleVolumeNode ( const nvsg::VolumeNode * p ) [protected, virtual]

Save a VolumeNode.

If the VolumeNode p is encountered on saving the first time, it is traversed and then saved.

Reimplemented from SharedTraverser.

virtual void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Save a Group.

If the Group p is encountered on saving the first time, it is traversed and then saved.

Reimplemented from SharedTraverser.

virtual void handleFlipbookAnimation ( const nvsg::FlipbookAnimation * p ) [protected, virtual]

Save a FlipbookAnimation.

If the FlipbookAnimation p is encountered on saving the first time, it first is traversed as a Group, then it's associated Animation is traversed, and finally it is saved.

Reimplemented from SharedTraverser.

virtual void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Save a Transform.

If the Transform p is encountered on saving the first time, it is traversed and then saved.

Reimplemented from SharedTraverser.

virtual void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Save an AnimatedTransform.

If the AnimatedTransform p is encountered on saving the first time, it first is traversed as a Transform, then it's associated Animation is traversed, and finally it is saved.

Reimplemented from SharedTraverser.

virtual void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Save a LOD.

If the LOD p is encountered on saving the first time, all it's children are traversed, no matter which might be currently active, then it is saved.

Reimplemented from SharedTraverser.

virtual void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Save a Switch.

If the Switch p is encountered on saving the first time, all it's children are traversed, no matter which might be currently active, then it is saved.

Reimplemented from SharedTraverser.

virtual void handleDirectedLight ( const nvsg::DirectedLight * p ) [protected, virtual]

Save a DirectedLight.

If the DirectedLight p is encountered on saving the first time, first any associated Animation is traversed, then it is saved.

Reimplemented from SharedTraverser.

virtual void handlePointLight ( const nvsg::PointLight * p ) [protected, virtual]

Save a PointLight.

If the PointLight p is encountered on saving the first time, first any associated Animation is traversed, then it is saved.

Reimplemented from SharedTraverser.

virtual void handleSpotLight ( const nvsg::SpotLight * p ) [protected, virtual]

Save a SpotLight.

If the SpotLight p is encountered on saving the first time, first any associated Animation is traversed, then it is saved.

Reimplemented from SharedTraverser.

virtual void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Save a StateSet.

If the StateSet p is encountered on saving, it is stored as the current one. Then, if it's the first time, it is traversed and then saved.

Reimplemented from SharedTraverser.

virtual void handleStateVariant ( const nvsg::StateVariant * p ) [protected, virtual]

Save a StateVariant.

If the StateVariant p is encountered on saving, it is stored as the current one. Then, if it is the first time, it is traversed and then saved.

Reimplemented from SharedTraverser.

virtual void handleStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Save a StatePass.

If the \ StatePass p is encountered on saving, it is stored as the current one. Then, if is is the first time, it is traversed and then saved.

Reimplemented from SharedTraverser.

virtual void handleBlendAttribute ( const nvsg::BlendAttribute * p ) [protected, virtual]

Save a BlendAttribute.

If the BlendAttribute p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Save a CgFx.

If the CgFx p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleDepthAttribute ( const nvsg::DepthAttribute * p ) [protected, virtual]

Save a DepthAttribute.

If the DepthAttribute p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleFaceAttribute ( const nvsg::FaceAttribute * p ) [protected, virtual]

Save a FaceAttribute.

If the FaceAttribute p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleLineAttribute ( const nvsg::LineAttribute * p ) [protected, virtual]

Save a LineAttribute.

If the LineAttribute p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleAlphaTestAttribute ( const nvsg::AlphaTestAttribute * p ) [protected, virtual]

Save a AlphaTestAttribute.

If the AlphaTestAttribute p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleLightingAttribute ( const nvsg::LightingAttribute * p ) [protected, virtual]

Save a LightingAttribute.

If the LightingAttribute p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleMaterial ( const nvsg::Material * p ) [protected, virtual]

Save a Material.

If the Material p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handlePointAttribute ( const nvsg::PointAttribute * p ) [protected, virtual]

Save a PointAttribute.

If the PointAttribute p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleTextureAttribute ( const nvsg::TextureAttribute * p ) [protected, virtual]

Save a TextureAttribute.

If the TextureAttribute p is encountered on saving the first time, it is traversed and then saved .

Reimplemented from SharedTraverser.

virtual void handleTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | p,
 |  | unsigned int | tu
 | ) | [protected, virtual]

Save a TextureAttributeItem.

If the TextureAttributeItem p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleUnlitColorAttribute ( const nvsg::UnlitColorAttribute * p ) [protected, virtual]

Save an UnlitColorAttribute.

If the UnlitColorAttribute p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Save a Triangles.

If the Triangles p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Save a SkinnedTriangles.

If the SkinnedTriangles p is encountered on saving the first time, any associated Animations are traversed, then it is saved.

Reimplemented from SharedTraverser.

virtual void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Save a TriFans.

If the TriFans p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Save a TriStrips.

If the TriStrips p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Save a QuadMeshes.

If the QuadMeshes p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Save a Quads.

If the Quads p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Save a QuadStrips.

If the QuadStrips p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Save a Lines.

If the Lines p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Save a LineStrips.

If the LineStrips p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Save a Points.

If the Points p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

Save a VertexAttributeSet.

If the VertexAttributeSet p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleAnimatedVertexAttributeSet ( const nvsg::AnimatedVertexAttributeSet * p ) [protected, virtual]

Save an AnimatedVertexAttributeSet.

If the AnimatedVertexAttributeSet p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleSkin ( const nvsg::Skin * p ) [protected, virtual]

Save a SkinnedVertexAttributeSet.

If the SkinnedVertexAttributeSet p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleFramedIndexAnimation ( const nvsg::FramedAnimation< unsigned int > * p ) [protected, virtual]

Save a FramedIndexAnimation.

If the FramedIndexAnimation p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleFramedTrafoAnimation ( const nvsg::FramedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Save a FramedTrafoAnimation.

If the FramedTrafoAnimation p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleFramedVertexAttributeAnimation ( const nvsg::FramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Save a FramedAnimation<VertexAttribute>.

If the FramedAnimation<VertexAttribute> p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleLinearInterpolatedTrafoAnimation ( const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Save a LinearInterpolatedTrafoAnimation.

If the LinearInterpolatedTrafoAnimation p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

virtual void handleLinearInterpolatedVertexAttributeAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Save a LinearInterpolatedAnimation<VertexAttribute>.

If the LinearInterpolatedAnimation<VertexAttribute> p is encountered on saving the first time, it is saved.

Reimplemented from SharedTraverser.

The documentation for this class was generated from the following file:
  • NVSGSaver.h
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

NVSGSaveTraverser Member List

This is the complete list of members for NVSGSaveTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | NVSGSaveTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | NVSGSaveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *p) | NVSGSaveTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | NVSGSaveTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | NVSGSaveTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | NVSGSaveTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *p) | NVSGSaveTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *p) | NVSGSaveTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | NVSGSaveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | NVSGSaveTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | NVSGSaveTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | NVSGSaveTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | NVSGSaveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | NVSGSaveTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | NVSGSaveTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | NVSGSaveTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | NVSGSaveTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | NVSGSaveTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p) | NVSGSaveTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p) | NVSGSaveTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | NVSGSaveTraverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | NVSGSaveTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | NVSGSaveTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | NVSGSaveTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | NVSGSaveTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *p) | NVSGSaveTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | NVSGSaveTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | NVSGSaveTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | NVSGSaveTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | NVSGSaveTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | NVSGSaveTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | NVSGSaveTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, unsigned int tu) | NVSGSaveTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | NVSGSaveTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | NVSGSaveTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | NVSGSaveTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | NVSGSaveTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *p) | NVSGSaveTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | NVSGSaveTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *p) | NVSGSaveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSGSaveTraverser() | NVSGSaveTraverser |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | NVSGSaveTraverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setFILE(FILE *fh) | NVSGSaveTraverser |
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


NVSGScene Struct Reference

The NVSGScene structure specifies some global scene relevant data. More...

List of all members.

Public Attributes

float4 | ambient
Specifies the ambient RGBA intensity of the scene.

int | frameNumber
Number of elapsed frames.

Detailed Description

The NVSGScene structure specifies some global scene relevant data.

A parameter of type NVSGScene will be automatically bound to NVSG scene parameters: global ambient from Scene::ambientColor, and the Scene's current frame number.

Member Data Documentation

float4 ambient

Specifies the ambient RGBA intensity of the scene.

int frameNumber

Number of elapsed frames.

The documentation for this struct was generated from the following file:
  • NVSGScene.cg
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

NVSGScene Member List

This is the complete list of members for NVSGScene, including all inherited members.
ambient | NVSGScene
frameNumber | NVSGScene
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


NVSGTexImageFmt Struct Reference

Internal data structure used to describe formats. More...

#include <GLContext.h>

List of all members.

Public Attributes

GLint | fixedPtFmt
The OpenGL internal format for fixed point.

GLint | floatFmt
The OpenGL internal format for floating point.

GLint | integerFmt
The OpenGL internal format integer textures.

GLint | compressedFmt
The OpenGL internal format for compressed textures.

GLint | nonLinearFmt
The OpenGL internal format SRGB textures.

GLint | usrFmt
The 'typical' OpenGL user format of a texture (integer textures excluded).

GLint | type
The OpenGL type of a texture.

GLint | uploadHint
An upload hint for the texture: 0=glTexImage, 1=PBO.

Detailed Description

Internal data structure used to describe formats.

Member Data Documentation

GLint fixedPtFmt

The OpenGL internal format for fixed point.

GLint floatFmt

The OpenGL internal format for floating point.

GLint integerFmt

The OpenGL internal format integer textures.

GLint compressedFmt

The OpenGL internal format for compressed textures.

GLint nonLinearFmt

The OpenGL internal format SRGB textures.

GLint usrFmt

The 'typical' OpenGL user format of a texture (integer textures excluded).

GLint type

The OpenGL type of a texture.

GLint uploadHint

An upload hint for the texture: 0=glTexImage, 1=PBO.

The documentation for this struct was generated from the following file:
  • GLContext.h
Generated on Tue Jan 15 10:28:50 2008 for NVSGSDK by NVIDIA


Member List

NVSGTexImageFmt Member List

This is the complete list of members for NVSGTexImageFmt, including all inherited members.
compressedFmt | NVSGTexImageFmt
fixedPtFmt | NVSGTexImageFmt
floatFmt | NVSGTexImageFmt
integerFmt | NVSGTexImageFmt
nonLinearFmt | NVSGTexImageFmt
type | NVSGTexImageFmt
uploadHint | NVSGTexImageFmt
usrFmt | NVSGTexImageFmt
Generated on Tue Jan 15 10:28:50 2008 for NVSGSDK by NVIDIA


Object Class Reference

Serves as base class for all traversable objects. More...

#include <Object.h>

Inheritance diagram for Object:

[legend]
Collaboration diagram for Object:

[legend]
List of all members.

Public Member Functions

NVSG_API | Object ()
Constructs an Object.

NVSG_API | Object (const Object &rhs)
Constructs an Object as a copy of another Object.

virtual NVSG_API | ~Object ()
Destructs an Object.

unsigned int | getObjectCode () const
Returns the object code, which is unique per object type.

virtual NVSG_API unsigned int | getHigherLevelObjectCode (unsigned int oc) const
Returns the higher-level object code for a given object code.

virtual NVSG_API bool | isDataShared () const
Returns whether this object shares its embedded data with other objects.

virtual NVSG_API DataID | getDataID () const
Returns the unique data identifier for this object.

NVSG_API const nvutil::Incarnation & | getIncarnation () const
Returns the current incarnation count of this object.

virtual NVSG_API bool | validateIncarnation () const
Mark the Incarnation of this Object as valid.

virtual NVSG_API bool | invalidateIncarnation ()
Mark the incarnation of this Object as invalid.

NVSG_API void | setName (const std::string &name)
Specifies the name for an object.

NVSG_API const std::string & | getName () const
Returns the name of the object.

NVSG_API void | setAnnotation (const std::string &anno)
Lets you append an annotation to this Object.

NVSG_API const std::string & | getAnnotation () const
Retrieves the Object's annotation.

virtual NVSG_API bool | isEquivalent (const Object *object, bool ignoreNames=true, bool deepCompare=false) const
Tests whether this object is equivalent to another object.

NVSG_API void | setUserData (const void *userData)
Attaches arbitrary user data to the object.

NVSG_API const void * | getUserData () const
Returns a pointer to the attached arbitrary user data.

Protected Member Functions

NVSG_API Object & | operator= (const Object &rhs)
Assigns new content from another Object.

NVSG_API void | enterCS () const
Provides exclusive access to mutable members.

NVSG_API void | leaveCS () const

Protected Attributes

unsigned int | m_objectCode
Per-object type identifier.

Detailed Description

Serves as base class for all traversable objects.

Namespace: nvsg
Remarks:
Besides being reference counted, providing the read/write locking interface, and being host for DAL data, an Object has an object code that identifies its concrete class type. Every concrete class derived from Object has to set an unique object code in its constructors. This object code is used in the Traverser to determine the concrete type of the Object. If there is a handler function registered for that specific object code, this handler is called. Otherwise, a higher level object code is queried, that also has to be provided by the concrete classes derived from Object, until an object code is encountered a handler function is registered for.

Constructor & Destructor Documentation

NVSG_API Object ( )

Constructs an Object.

NVSG_API Object ( const Object & rhs )

Constructs an Object as a copy of another Object.

virtual NVSG_API ~Object ( ) [virtual]

Destructs an Object.

Member Function Documentation

unsigned int getObjectCode ( ) const [inline]

Returns the object code, which is unique per object type.

Returns:
The function returns the object code enum for this object.
Remarks:
The object code, which is unique per object type, is used for fast object type identification at runtime. A nvtraverser::Traverser, for example, uses the object code to fast lookup the handler function for a particular object type.

Object-derived classes must override the protected member m_objectCode , with the correct value for the respective type. It is recommended to do this at instantiation time of the customized object.
See also:
How to Derive an NVSG Object, Object::getHigherLevelObjectCode

virtual NVSG_API unsigned int getHigherLevelObjectCode ( unsigned int oc ) const [virtual]

Returns the higher-level object code for a given object code.

Parameters:
oc Object code for which to retrieve the associated higher-level object code.
Returns:
The default implementation returns OC_INVALID, which causes the traverser framework to immediately proceed without handling the object when it comes across an unknown object code.
Remarks:
This function will be called from the object traverser framework if the object code oc is unknown. This would be the case if for a custom object a certain traverser did not register an appropriate handler function.

The framework expects this function to return a higher-level object code in terms of a custom object hierarchy. The function will be repeatedly called with the returned higher-level object code, until either a known object code or OC_INVALID will be returned. That is - by repeatedly calling this function, the traverser framework moves up the custom object hierarchy to find an object for which a handler function was registered. If the traverser framework recognizes a known object code, it calls the appropriate handler function and proceeds. If OC_INVALID was returned, the traverser framework proceeds without handling the object.

The runtime behaviour is undefined if the function returns an object code of an object that is not part of the object hierarchy of the primary object!

The framework might end up in a deadlock if the function never returns either OC_INVALID or an object code of a concrete object known by the traverser!
See also:
Object::getObjectCode

virtual NVSG_API bool isDataShared ( ) const [virtual]

Returns whether this object shares its embedded data with other objects.

Returns:
The function should return true if the object shares its embedded data with other objects. Otherwise, the function should return false.

The default implementation always returns false.
Remarks:
For Object-derived classes that are capable of sharing their embedded data with other objects, it is recommended to override this function. For all other objects, the default implementation will be sufficient.

An object, capable of data sharing, shares its data with another object if it was either instantiated as a copy of the other object, or if its content was re-assigned to by the content of the other object using the appropriate assignment operator.

Only a few classes of the NVSG core implement data sharing. These mainly are classes where data sharing probably could save a lot of memory because of the large amount of data these classes might contain. VertexAttributeSet, IndependentPrimitiveSet, and StrippedPrimitiveSet are examples of nvsgcoreclasses that implement data sharing.
See also:
Object::getDataID

Reimplemented in CgFx, IndependentPrimitiveSet, Material, MeshedPrimitiveSet, SkinnedTriangles, StrippedPrimitiveSet, TextureAttributeItem, and VertexAttributeSet.

virtual NVSG_API DataID getDataID ( ) const [virtual]

Returns the unique data identifier for this object.

Returns:
The function returns a 64-bit value which uniquely identifies the embedded data.
Remarks:
This function in particular is useful to identify different objects that share their embedded data. Two objects that share the same data always have the same DataID.

Identifying objects that share their data with other objects is useful for saving objects to a file and later reloading it without losing the data sharing.
See also:
Object::isDataShared

Reimplemented in CgFx, IndependentPrimitiveSet, Material, MeshedPrimitiveSet, SkinnedTriangles, StrippedPrimitiveSet, TextureAttributeItem, and VertexAttributeSet.

NVSG_API const nvutil::Incarnation& getIncarnation ( ) const

Returns the current incarnation count of this object.

Returns:
The function returns a reference to an Incarnation object which is intended to be compared to a previously stored Incarnation count for this object.
Remarks:
An altered incarnation generally implies that some related object data has changed. The ability to test an object Incarnation enables user code to do some conditional evaluation.
See also:
invalidateIncarnation, validateIncarnation

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Mark the Incarnation of this Object as valid.

Returns:
true, if the incarnation was invalid before, otherwise false.
Remarks:
If the Incarnation was invalid before, it is incremented and set as valid.

For Object-derived classes that maintain a kind of parent-child relationship, the particular implementation need to validate the Incarnations from top to bottom.
See also:
getIncarnation, invalidateIncarnation

Reimplemented in AnimatedTransform, AnimatedVertexAttributeSet, Camera, Drawable, FlipbookAnimation, GeoNode, Group, HighlightBox, LightSource, MapList, Node, PrimitiveSet, Shape, SkinnedTriangles, StatePass, StateSet, StateVariant, TextureAttribute, and VolumeNode.

virtual NVSG_API bool invalidateIncarnation ( ) [virtual]

Mark the incarnation of this Object as invalid.

Returns:
true, if the incarnation was valid before, otherwise false.
Remarks:
The incarnation of the object is marked as invalid.

For Object-derived classes that maintain a kind of parent-child relationship, the particular implementation need to invalidate the Incarnations from bottom to top.
See also:
getIncarnation, validateIncarnation

Reimplemented in AnimatedTransform, AnimatedVertexAttributeSet, Node, OwnedObject, OwnedObject< NodeHandle >, OwnedObject< TextureAttributeHandle >, OwnedObject< StatePassHandle >, OwnedObject< ObjectHandle >, OwnedObject< PrimitiveSetHandle >, OwnedObject< StateVariantHandle >, OwnedObject< GroupHandle >, and OwnedObject< StateSetHandle >.

NVSG_API void setName ( const std::string & name )

Specifies the name for an object.

Parameters:
name Reference to a STL sting holding the name to specify.
Remarks:
A previously specified name gets lost when specifying a new name using this function.

Use Object::getName to retrieve the actual name of an Object.

NVSG_API const std::string& getName ( ) const

Returns the name of the object.

Returns:
A reference to a STL string holding the name of the object. The function returns a reference to an empty string if no name was previously specified for the object.
Remarks:
The function retrieves the object's name previously specified through Object::setName.

NVSG_API void setAnnotation ( const std::string & anno )

Lets you append an annotation to this Object.

Parameters:
* anno Annotation to append to this Object.
Remarks:
The function lets you append an optional annotation. A previously appended annotation gets lost.
See also:
Object::getAnnotation

NVSG_API const std::string& getAnnotation ( ) const

Retrieves the Object's annotation.

Returns:
The function returns the annotation as last specified through setAnnotation. If no annotation was specified before, the function returns an empty string.
See also:
Object::setAnnotation

virtual NVSG_API bool isEquivalent | ( | const Object * | object,
 |  | bool | ignoreNames = true,
 |  | bool | deepCompare = false
 | ) | const [virtual]

Tests whether this object is equivalent to another object.

Parameters:
object | Pointer to the object to test for equivalence with this object.
ignoreNames | Object names will be ignored while testing if this is true.
deepCompare | The function performs a deep-compare if this is true. Otherwise the function only performs a shallow compare.
Returns:
The function returns true if the object pointed to by object is detected to be equivalent to this object. Otherwise the function returns false.
Remarks:
The test will be performed considering the optional control parameters ignoreNames and deepCompare. If you omit these two, the function ignores object names and performs a shallow compare only.

Reimplemented in AlphaTestAttribute, AnimatedTransform, AnimatedVertexAttributeSet, Billboard, BlendAttribute, CgFx, DepthAttribute, FaceAttribute, FlipbookAnimation, GeoNode, Group, IndependentPrimitiveSet, LightingAttribute, LightSource, LineAttribute, LOD, Material, MeshedPrimitiveSet, PointAttribute, PointLight, PrimitiveSet, Shape, Skin, SkinnedTriangles, SpotLight, StatePass, StateSet, StateVariant, StrippedPrimitiveSet, Switch, TextureAttributeItem, TextureAttribute, Transform, VertexAttributeSet, and VolumeNode.

void setUserData ( const void * userData ) [inline]

Attaches arbitrary user data to the object.

Parameters:
userData Specifies the address of the arbitrary user data.
Remarks:
Use setUserData to store the address to arbitrary user data with the object. The object does not interpret the data, nor does it take over responsibility for managing the memory occupied by the data behind userData. It just keeps the address to the user data until the address will be overwritten by a subsequent call to setUserData.

User data will not be considered for storing to a file!

Use getUserData to get back the address to the user data that was last specified through setUserData.
See also:
getUserData

const void * getUserData ( ) const [inline]

Returns a pointer to the attached arbitrary user data.

Returns:
The function returns the pointer to the arbitrary user data that was last specified by a call to setUserData.
See also:
setUserData

NVSG_API Object& operator= ( const Object & rhs ) [protected]

Assigns new content from another Object.

Parameters:
rhs Reference to an Object from which to assign the new content.
Returns:
A reference to this object.
Remarks:
The assignment operator unreferences the old content before assigning the new content. The new content will be a deep-copy of the content of right-hand-sided object.

void enterCS ( ) const [inline, protected]

Provides exclusive access to mutable members.

Member Data Documentation

unsigned int m_objectCode [protected]

Per-object type identifier.

Remarks:
Concrete derived objects must initialize this object code with an identifier, which must be a unique per-object type. It is recommended to do this at object instantiation.

NVSG uses this object code for fast object type identification at runtime.

Codes from 0x00 to 0xBF are reserved for NVSG core objects, and may not be used for custom object types!

Codes for custom objects should start at OC_CUSTOMOBJECT:

 // example for custom object code initialization

 enum
 {
   OC_MYFIRSTOBJECT = nvsg::OC_CUSTOMOBJECT,
   OC_MYSECONDOBJECT, // = OC_MYFIRSTOBJECT + 1
   OC_MYTHIRDOBJECT.  // = OC_MYFIRSTOBJECT + 2
 // ... further codes
 };

The documentation for this class was generated from the following file:
  • Object.h
Generated on Tue Jan 15 10:29:11 2008 for NVSGSDK by NVIDIA


Member List

Object Member List

This is the complete list of members for Object, including all inherited members.
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getObjectCode() const | Object | [inline]
getUserData() const | Object | [inline]
invalidateIncarnation() | Object | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Object &rhs) | Object | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~Object() | Object | [virtual]
Generated on Tue Jan 15 10:29:11 2008 for NVSGSDK by NVIDIA


OBJSaver Class Reference

A Scene Saver for obj files. More...

#include <OBJSaver.h>

Inheritance diagram for OBJSaver:

[legend]
Collaboration diagram for OBJSaver:

[legend]
List of all members.

Public Member Functions

void | deleteThis (void)
PlugIn interface.

bool | save (nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState, const std::string &filename)
Realization of the pure virtual interface function of a SceneSaver.

Detailed Description

A Scene Saver for obj files.

NVSG files can be produced with the sample ViewerVR. They are text files that represent a Scene and a ViewState.

Member Function Documentation

void deleteThis ( void ) [inline, virtual]

PlugIn interface.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

bool save | ( | nvsg::SceneHandle * | scene,
 |  | nvsg::ViewStateHandle * | viewState,
 |  | const std::string & | filename
 | ) | [virtual]

Realization of the pure virtual interface function of a SceneSaver.

Saves the scene and the viewState to filename.

Parameters:
scene | scene to save
viewState | view state to save
filename | file name to save to

Implements SceneSaver.

The documentation for this class was generated from the following file:
  • OBJSaver.h
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

OBJSaver Member List

This is the complete list of members for OBJSaver, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | OBJSaver | [inline, virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState, const std::string &filename) | OBJSaver | [virtual]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneSaver() | SceneSaver | [protected, virtual]
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


OptimizeTraverser Class Reference

Base for Traversers that perform some optimizations on a scene. More...

#include <OptimizeTraverser.h>

Inheritance diagram for OptimizeTraverser:

[legend]
Collaboration diagram for OptimizeTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | OptimizeTraverser (void)
Constructor.

NVSG_API bool | getIgnoreNames (void) const
Get the 'ignore names' flag.

NVSG_API void | setIgnoreNames (bool ignore)
Set the 'ignore names' flags.

NVSG_API bool | getTreeModified (void) const
Query if the latest traversal did modify the tree.

Protected Member Functions

virtual NVSG_API | ~OptimizeTraverser (void)
Protected destructor to prevent instantiation of a TreeOptimizeTraverser on stack.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
doApply override

NVSG_API void | setTreeModified (void)

Detailed Description

Base for Traversers that perform some optimizations on a scene.

Constructor & Destructor Documentation

NVSG_API OptimizeTraverser ( void )

Constructor.

virtual NVSG_API ~OptimizeTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a TreeOptimizeTraverser on stack.

Member Function Documentation

bool getIgnoreNames ( void ) const [inline]

Get the 'ignore names' flag.

If the 'ignore names' flag is set, the names of the GeoNodes are ignored.

Returns:
true if the names will be ignored, otherwise false

void setIgnoreNames ( bool ignore ) [inline]

Set the 'ignore names' flags.

If the 'ignore names' flag is set, the names of the GeoNodes are ignored.

Parameters:
ignore set true to ignore names on comparison

bool getTreeModified ( void ) const [inline]

Query if the latest traversal did modify the tree.

Returns:
true if the tree was modified, otherwise false

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

doApply override

Reimplemented from ExclusiveTraverser.

Reimplemented in EliminateTraverser, UnifyTraverser, and VertexUnifyTraverser.

The documentation for this class was generated from the following file:
  • OptimizeTraverser.h
Generated on Tue Jan 15 10:29:33 2008 for NVSGSDK by NVIDIA


Member List

OptimizeTraverser Member List

This is the complete list of members for OptimizeTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | OptimizeTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | ExclusiveTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setIgnoreNames(bool ignore) | OptimizeTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:33 2008 for NVSGSDK by NVIDIA


TemplateOwnedObject class Reference

OwnedObject Class Template Reference

Helper class to hold a vector of owners of an Object. More...

#include <OwnedObject.h>

Inheritance diagram for OwnedObject:

[legend]
Collaboration diagram for OwnedObject:

[legend]
List of all members.

Public Member Functions

unsigned int | getNumberOfOwners () const
Get the number of owners of this OwnedObject.

OwnerHandle * | getOwner (unsigned int index) const
Get the owning OwnerHandle at position index.

OwnedObject< OwnerHandle > & | operator= (const OwnedObject< OwnerHandle > &rhs)
Assignment operator.

virtual bool | invalidateIncarnation ()
Invalidate the nvutil::Incarnation.

Protected Types

typedef std::vector< OwnerType
>::iterator 		OwnerIterator
Non-constant iterator type on owners.

typedef std::vector< OwnerType
>::const_iterator 		ConstOwnerIterator
Constant iterator type on owners.

Protected Member Functions

OwnedObject ()
Protected default constructor to prevent instantiation of an OwnedObject.

OwnedObject (const Object &rhs)
Protected copy constructor from an Object.

OwnedObject (const OwnedObject< OwnerHandle > &rhs)
Protected copy constructor from an OwnedObject.

~OwnedObject ()
Protected destructor of an OwnedObject.

void | addOwner (typename OwnerHandle::ObjectType *obj)
Add an owner to the set of owners.

void | removeOwner (typename OwnerHandle::ObjectType *obj)
Remove an owner from the set of owners.

ConstOwnerIterator | ownersBegin () const
Get a constant iterator to the first owner from the set of owners.

OwnerIterator ownersBegin ()
Get an iterator to the first owner from the set of owners.

ConstOwnerIterator | ownersEnd () const
Get a constant iterator to behind the last owner from the set of owners.

OwnerIterator ownersEnd ()
Get an iterator to behind the last owner from the set of owners.

Friends

template<typename T, typename U> void | addAsOwnerTo (T *, U *)
template<typename T, typename U> void | removeAsOwnerFrom (T *, U *)

Detailed Description

template<typename OwnerHandle>
class nvsg::OwnedObject< OwnerHandle >

Helper class to hold a vector of owners of an Object.

Remarks:
Some classes, like Drawable, LightSource, or StateAttribute, need to know all the objects that "own" them, i.e. the objects that are referencing them in the tree hierarchy. This knowledge is needed to carry information from such objects that are not derived from Node "up-tree" to the Nodes that hold them. That is, the "owner-relationship" is similar to the "parent-relationship" of the Nodes. Each OwnedObject can only be owned by one specific type of owners, specified as the template parameter "OwnerHandle".
See also:
Node

Member Typedef Documentation

typedef std::vector<OwnerType>::iterator OwnerIterator [protected]

Non-constant iterator type on owners.

See also:
ConstOwnerIterator

typedef std::vector<OwnerType>::const_iterator ConstOwnerIterator [protected]

Constant iterator type on owners.

See also:
OwnerIterator

Constructor & Destructor Documentation

OwnedObject ( ) [protected]

Protected default constructor to prevent instantiation of an OwnedObject.

Remarks:
An OwnedObject is not intended to be instantiated, but only classes derived from it.

OwnedObject ( const Object & rhs ) [protected]

Protected copy constructor from an Object.

Remarks:
An OwnedObject is not intended to be instantiated, but only classes derived from it.

OwnedObject ( const OwnedObject< OwnerHandle > & rhs ) [protected]

Protected copy constructor from an OwnedObject.

Remarks:
An OwnedObject is not intended to be instantiated, but only classes derived from it.

~OwnedObject ( ) [protected]

Protected destructor of an OwnedObject.

Remarks:
An OwnedObject is not intended to be instantiated, but only classes derived from it.

Member Function Documentation

unsigned int getNumberOfOwners ( ) const [inline]

Get the number of owners of this OwnedObject.

Returns:
Number of owners of this OwnedObject.
Remarks:
An OwnedObject that is part of one or more OwnerHandle objects holds a pointer back to each of those OwnerHandle objects. These are called the owners. So the number of owners tells you how often this OwnedObject is referenced in a scene tree.
See also:
getOwner

OwnerHandle * getOwner ( unsigned int index ) const [inline]

Get the owning OwnerHandle at position index.

Parameters:
index Position of the OwnerHandle to get in the list of owners.
Returns:
A pointer to the OwnerHandle that owns this OwnedObject.
Remarks:
An OwnedObject that is part of one or more OwnerHandle objects, holds a pointer back to each of those OnwerHandle objects. These are called the owners.
Note:
The behavior is undefined if index is greater than or equal to the number of owners.
See also:
getNumberOfOwners

OwnedObject< OwnerHandle > & operator= ( const OwnedObject< OwnerHandle > & rhs ) [inline]

Assignment operator.

Parameters:
rhs A reference to the constant OwnedObject to copy from
Returns:
A reference to the assigned OwnedObject
Remarks:
The assignment operator calls the assignment operator of Object.
Note:
The owners of rhs are not copied.
See also:
Object

bool invalidateIncarnation ( ) [inline, virtual]

Invalidate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this OwnedObject is to be marked as invalid. If it was marked as valid before, it marks its own Incarnation as invalid and calls invalidateIncarnation on all its owners.
See also:
nvutil::Incarnation, validateIncarnation

Reimplemented from Object.

Reimplemented in AnimatedVertexAttributeSet.

void addOwner ( typename OwnerHandle::ObjectType * obj ) [inline, protected]

Add an owner to the set of owners.

Parameters:
obj A pointer to the object to add as an owner.
Remarks:
The owner oh is added to the set of owners.
Note:
The reference count of the owner oh is not increased.
See also:
removeOwner, getNumberOfOwners, getOwner, ownersBegin, ownersEnd

void removeOwner ( typename OwnerHandle::ObjectType * obj ) [inline, protected]

Remove an owner from the set of owners.

Parameters:
obj A pointer to the object to remove as an owner.
Remarks:
The owner oh is removed from the set of owners.
Note:
The reference count of the owner oh is not decreased.
See also:
addOwner, getNumberOfOwners, getOwner, ownersBegin, ownersEnd

ConstOwnerIterator ownersBegin ( ) const [inline, protected]

Get a constant iterator to the first owner from the set of owners.

Returns:
A constant iterator to the first owner from the set of owners.
See also:
ownersEnd

OwnerIterator ownersBegin ( ) [inline, protected]

Get an iterator to the first owner from the set of owners.

Returns:
An iterator to the first owner from the set of owners.
See also:
ownersEnd

ConstOwnerIterator ownersEnd ( ) const [inline, protected]

Get a constant iterator to behind the last owner from the set of owners.

Returns:
A constant iterator to behind the last owner from the set of owners.
See also:
ownersBegin

OwnerIterator ownersEnd ( ) [inline, protected]

Get an iterator to behind the last owner from the set of owners.

Returns:
An iterator to behind the last owner from the set of owners.
See also:
ownersBegin

The documentation for this class was generated from the following file:
  • OwnedObject.h
Generated on Tue Jan 15 10:29:11 2008 for NVSGSDK by NVIDIA


Member List

OwnedObject Member List

This is the complete list of members for OwnedObject, including all inherited members.
addAsOwnerTo (defined in OwnedObject) | OwnedObject | [friend]
addOwner(typename OwnerHandle::ObjectType *obj) | OwnedObject | [inline, protected]
ConstOwnerIterator typedef | OwnedObject | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject | [inline]
getUserData() const | Object | [inline]
invalidateIncarnation() | OwnedObject | [inline, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const OwnedObject< OwnerHandle > &rhs) | OwnedObject | [inline]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject | [protected]
OwnedObject(const Object &rhs) | OwnedObject | [protected]
OwnedObject(const OwnedObject< OwnerHandle > &rhs) | OwnedObject | [protected]
OwnerIterator typedef | OwnedObject | [protected]
ownersBegin() const | OwnedObject | [inline, protected]
ownersBegin() | OwnedObject | [inline, protected]
ownersEnd() const | OwnedObject | [inline, protected]
ownersEnd() | OwnedObject | [inline, protected]
removeAsOwnerFrom (defined in OwnedObject) | OwnedObject | [friend]
removeOwner(typename OwnerHandle::ObjectType *obj) | OwnedObject | [inline, protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | Object | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject | [protected]
Generated on Tue Jan 15 10:29:11 2008 for NVSGSDK by NVIDIA


ParallelCamera Class Reference

Class describing a parallel (non-perspective) Camera. More...

#include <ParallelCamera.h>

Inheritance diagram for ParallelCamera:

[legend]
Collaboration diagram for ParallelCamera:

[legend]
List of all members.

Public Member Functions

NVSG_API | ParallelCamera ()
Default-constructs a ParallelCamera.

NVSG_API | ParallelCamera (const Camera &rhs)
Constructs a ParallelCamera from a Camera.

NVSG_API | ParallelCamera (const ParallelCamera &rhs)
Copy-constructs a ParallelCamera from another ParallelCamera.

virtual NVSG_API | ~ParallelCamera ()
virtual NVSG_API nvmath::Mat44f | getProjection () const
Get the projection matrix of this ParallelCamera.

virtual NVSG_API nvmath::Mat44f | getInverseProjection () const
Get the inverse projection matrix of this ParallelCamera.

virtual NVSG_API void | getPickRay (int x, int y, int w, int h, nvmath::Vec3f &rayOrigin, nvmath::Vec3f &rayDir) const
Get a pick ray in world coordinates for a given screen point.

NVSG_API ParallelCamera & | operator= (const ParallelCamera &rhs)
Assignment operator.

virtual NVSG_API CullCode | determineCullCode (const nvmath::Sphere3f &sphere) const
Determine the CullCode of a Sphere3f relative to the view volume.

Detailed Description

Class describing a parallel (non-perspective) Camera.

Namespace: nvsg
Remarks:
A ParallelCamera overwrites the projection-specific functions of a Camera.
See also:
Camera, PerspectiveCamera

Constructor & Destructor Documentation

NVSG_API ParallelCamera ( )

Default-constructs a ParallelCamera.

Remarks:
The ParallelCamera initially is positioned at (0.0,0.0,1.0), has the y-axis as up-vector and looks down the negative z-axis.

NVSG_API ParallelCamera ( const Camera & rhs ) [explicit]

Constructs a ParallelCamera from a Camera.

See also:
Camera

NVSG_API ParallelCamera ( const ParallelCamera & rhs )

Copy-constructs a ParallelCamera from another ParallelCamera.

virtual NVSG_API ~ParallelCamera ( ) [virtual]

Destructs a ParallelCamera.

Member Function Documentation

virtual NVSG_API nvmath::Mat44f getProjection ( ) const [virtual]

Get the projection matrix of this ParallelCamera.

Returns:
The projection transformation.
See also:
Camera, getInverseProjection, getWorldToViewMatrix, getViewToWorldMatrix

Implements Camera.

virtual NVSG_API nvmath::Mat44f getInverseProjection ( ) const [virtual]

Get the inverse projection matrix of this ParallelCamera.

Returns:
The inverse projection transformation.
See also:
Camera, getProjection, getWorldToViewMatrix, getViewToWorldMatrix

Implements Camera.

virtual NVSG_API void getPickRay | ( | int | x,
 |  | int | y,
 |  | int | w,
 |  | int | h,
 |  | nvmath::Vec3f & | rayOrigin,
 |  | nvmath::Vec3f & | rayDir
 | ) | const [virtual]

Get a pick ray in world coordinates for a given screen point.

Parameters:
x | x-coordinate of the input screen point.
y | y-coordinate of the input screen point.
w | Width of the screen window in pixels.
h | Height of the screen window in pixels.
rayOrigin | Reference to an nvmath::Vec3f to get the ray origin.
rayDir | Reference to an nvmath::Vec3f to get the ray direction.
Remarks:
The function returns in rayOrigin the origin, and in rayDir the direction of the pick ray calculated from the screen point specified by its x and y coordinate. The pick ray is a ray parallel to the camera direction, starting from a point, that is a displacement of the camera position parallel to the projection plane.
Note:
A screen point of (0,0) indicates the lower left of the currently considered screen window.

Implements Camera.

NVSG_API ParallelCamera& operator= ( const ParallelCamera & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant ParallelCamera to copy from.
Returns:
A reference to the assigned ParallelCamera.
Remarks:
The assignment operator calls the assignment operator of Camera.

virtual NVSG_API CullCode determineCullCode ( const nvmath::Sphere3f & sphere ) const [virtual]

Determine the CullCode of a Sphere3f relative to the view volume.

Parameters:
sphere A reference to the constant Sphere3f to determine the CullCode for.
Returns:
CC_IN, if the Sphere3f sphere is completely inside the view volume; CC_OUT if it is completely out of the view volume; otherwise CC_PART.

Implements Camera.

The documentation for this class was generated from the following file:
  • ParallelCamera.h
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


Member List

ParallelCamera Member List

This is the complete list of members for ParallelCamera, including all inherited members.
addHeadLight(LightSourceHandle *light) | Camera |
calcNearFarDistances(const nvmath::Sphere3f &sphere) | Camera |
Camera(void) | Camera | [protected]
Camera(const Camera &rhs) | Camera | [protected]
clearHeadLights(void) | Camera |
determineCullCode(const nvmath::Sphere3f &sphere) const | ParallelCamera | [virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getAspectRatio(void) const | Camera | [inline]
getDataID() const | Object | [virtual]
getDirection(void) const | Camera | [inline]
getFarDistance(void) const | Camera | [inline]
getFocusDistance(void) const | Camera | [inline]
getHeadLight(unsigned int index) const | Camera | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getInverseProjection() const | ParallelCamera | [virtual]
getName() const | Object |
getNearDistance(void) const | Camera | [inline]
getNumberOfHeadLights(void) const | Camera | [inline]
getObjectCode() const | Object | [inline]
getOrientation(void) const | Camera | [inline]
getPickRay(int x, int y, int w, int h, nvmath::Vec3f &rayOrigin, nvmath::Vec3f &rayDir) const | ParallelCamera | [virtual]
getPosition(void) const | Camera | [inline]
getProjection() const | ParallelCamera | [virtual]
getUpVector(void) const | Camera | [inline]
getUserData() const | Object | [inline]
getViewToWorldMatrix(void) const | Camera |
getWindowOffset(void) const | Camera | [inline]
getWindowRegion(nvmath::Vec2f &lowerLeft, nvmath::Vec2f &upperRight) const | Camera | [inline]
getWindowSize(void) const | Camera | [inline]
getWorldToViewMatrix(void) const | Camera |
invalidateIncarnation() | Object | [virtual]
isAutoClipPlanes(void) const | Camera | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
move(const nvmath::Vec3f &delta, bool cameraRelative=true) | Camera |
moveX(float val) | Camera | [inline]
moveY(float val) | Camera | [inline]
moveZ(float val) | Camera | [inline]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const ParallelCamera &rhs) | ParallelCamera |
nvsg::Camera::operator=(const Camera &rhs) | Camera | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
orbit(const nvmath::Vec3f &axis, float targetDistance, float angle, bool cameraRelative=true) | Camera |
orbitX(float targetDistance, float angle) | Camera | [inline]
orbitY(float targetDistance, float angle) | Camera | [inline]
orbitZ(float targetDistance, float angle) | Camera | [inline]
ParallelCamera() | ParallelCamera |
ParallelCamera(const Camera &rhs) | ParallelCamera | [explicit]
ParallelCamera(const ParallelCamera &rhs) | ParallelCamera |
removeHeadLight(unsigned int index) | Camera |
rotate(const nvmath::Vec3f &axis, float angle, bool cameraRelative=true) | Camera |
rotateX(float angle) | Camera | [inline]
rotateY(float angle) | Camera | [inline]
rotateZ(float angle) | Camera | [inline]
setAnnotation(const std::string &anno) | Object |
setAspectRatio(float ar, bool keepWidth=false) | Camera |
setAutoClipPlanes(bool on) | Camera |
setDirection(const nvmath::Vec3f &dir) | Camera |
setFarDistance(float fd) | Camera | [inline]
setFocusDistance(float fd) | Camera | [virtual]
setName(const std::string &name) | Object |
setNearDistance(float nd) | Camera | [inline]
setOrientation(const nvmath::Quatf &quat) | Camera |
setOrientation(const nvmath::Vec3f &dir, const nvmath::Vec3f &up) | Camera |
setPosition(const nvmath::Vec3f &pos) | Camera |
setUpVector(const nvmath::Vec3f &up) | Camera |
setUserData(const void *userData) | Object | [inline]
setWindowOffset(const nvmath::Vec2f &offset) | Camera | [inline]
setWindowRegion(const nvmath::Vec2f &lowerLeft, const nvmath::Vec2f &upperRight) | Camera | [inline]
setWindowSize(const nvmath::Vec2f &size) | Camera | [inline]
validateIncarnation() const | Camera | [virtual]
zoom(float factor) | Camera | [inline]
zoom(const nvmath::Sphere3f &sphere, float fovy=-1.0f) | Camera |
~Camera(void) | Camera | [virtual]
~Object() | Object | [virtual]
~ParallelCamera() | ParallelCamera | [virtual]
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


Path Class Reference

Class that represents a path through the tree. More...

#include <Path.h>

Inheritance diagram for Path:

[legend]
Collaboration diagram for Path:

[legend]
List of all members.

Public Member Functions

NVSG_API | Path ()
Construct a Path object.

NVSG_API | Path (const Path &rhs)
Copy constructor.

NVSG_API unsigned int | getLength () const
Get the length of the path through the graph.

NVSG_API bool | isEmpty () const
Test an empty path.

NVSG_API ObjectHandle * | getHead () const
Get the head object of the path.

NVSG_API ObjectHandle * | getTail () const
Get the tail object of the path.

NVSG_API ObjectHandle * | getFromHead (unsigned int i) const
Get an object on the path.

NVSG_API ObjectHandle * | getFromTail (unsigned int i) const
Get an object on the path.

NVSG_API void | pop ()
Remove the last object from the path.

NVSG_API void | push (ObjectHandle *pObject)
Append an object to the path chain.

NVSG_API void | truncate (unsigned int start)
Remove several objects from the path chain.

NVSG_API void | getModelToWorldMatrix (nvmath::Mat44f &modelToWorld, nvmath::Mat44f &worldToModel) const
Get the ModelToWorld and WorldToModel matrices along the path.

Protected Member Functions

virtual NVSG_API | ~Path ()
Prohibit explicit creation on stack by making the destructor protected.

Detailed Description

Class that represents a path through the tree.

Namespace: nvsg
Remarks:
A Path represents a scene graph or subgraph. It contains pointers to a chain of objects, each being a child of the previous object.
A path can hold any kind of Object-derived objects (even Drawables).

Constructor & Destructor Documentation

NVSG_API Path ( )

Construct a Path object.

NVSG_API Path ( const Path & rhs )

Copy constructor.

Parameters:
rhs Reference to a constant Path object.
Remarks:
This copy constructor creates an exact copy of the provided Path object.
Internally this class holds a vector of node pointer representing the path through the graph. This copy constructor does not perform a deep copy on the pointers in the vector. It simply copies the pointers.

virtual NVSG_API ~Path ( ) [protected, virtual]

Prohibit explicit creation on stack by making the destructor protected.

Member Function Documentation

unsigned int getLength ( ) const [inline]

Get the length of the path through the graph.

Returns:
The number of nodes in the path chain.
Remarks:
The path length is the exact number of nodes in the path chain.

bool isEmpty ( ) const [inline]

Test an empty path.

Returns:
When there is no node in the path chain, this function returns true.
Remarks:
Testing on emptiness with this function is possibly faster than testing the length.

ObjectHandle * getHead ( ) const [inline]

Get the head object of the path.

Returns:
This function returns a pointer to the constant head object or NULL when the path is empty.
Remarks:
The head object is the first object in the path chain. the call Path::getFromHead(0) is equivalent to Path::getHead().
See also:
getTail, getFromHead, getFromTail

ObjectHandle * getTail ( ) const [inline]

Get the tail object of the path.

Returns:
This function returns a pointer to the constant tail object or NULL when the path is empty.
Remarks:
The tail object is the last object in the path chain. the call Path::getFromTail(0) is equivalent to Path::getTail().
See also:
getHead, getFromHead, getFromTail

ObjectHandle * getFromHead ( unsigned int i ) const [inline]

Get an object on the path.

Parameters:
i Null based index of the node to get from the path. The behavior of this function is undefined for an invalid index.
Returns:
Pointer to the constant object with the index i.
Remarks:
The returned object is the object at the requested position. Providing an index of 0 corresponds to the call to Path::getHead.
See also:
getHead, getFromHead, getFromTail

ObjectHandle * getFromTail ( unsigned int i ) const [inline]

Get an object on the path.

Parameters:
i Null based index of the node to get from the path. The behavior of this function is undefined for an invalid index.
Returns:
Pointer to the constant object with the index i.
Remarks:
The returned object is the object at the requested position. Providing an index of 0 corresponds to the call to Path::getTail.
See also:
getTail, getFromHead, getFromTail

void pop ( ) [inline]

Remove the last object from the path.

Remarks:
This function simply removes the last (tail) object from the current path chain. It also handles decrementing the reference count of the removed object.
Calling this function on an empty path will lead to undefined behavior.
See also:
push, truncate

NVSG_API void push ( ObjectHandle * pObject )

Append an object to the path chain.

Parameters:
pObject Pointer to a constant Object. Providing an invalid pointer or a NULL pointer will lead to undefined behavior.
Remarks:
This function appends the given Object to the end of the path chain. It also correctly increments the reference count of the provide object.
See also:
pop, truncate

NVSG_API void truncate ( unsigned int start )

Remove several objects from the path chain.

Parameters:
start The start index where the removal starts. Providing an invalid start index will lead to undefined behavior.
Remarks:
This function removes all following objects beginning from the start index from the path chain, including the object at the start index. It correctly decrements the reference counts of all the removed objects.
Calling Path::truncate(0) will remove all objects from the path chain.
See also:
pop, push

NVSG_API void getModelToWorldMatrix | ( | nvmath::Mat44f & | modelToWorld,
 |  | nvmath::Mat44f & | worldToModel
 | ) | const

Get the ModelToWorld and WorldToModel matrices along the path.

Parameters:
modelToWorld | Reference for returning the ModelToWorld matrix, excluding the tail node transformation.
worldToModel | Reference for returning the WorldToModel matrix, excluding the tail node transformation.
Remarks:
The accumulated matrices do not contain the tail node transformation. These matrices are very handy in the nvui::TransformManipulator derived classes. nvui::TransformManipulator

The documentation for this class was generated from the following file:
  • Path.h
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


Member List

Path Member List

This is the complete list of members for Path, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
getFromHead(unsigned int i) const | Path | [inline]
getFromTail(unsigned int i) const | Path | [inline]
getHead() const | Path | [inline]
getLength() const | Path | [inline]
getModelToWorldMatrix(nvmath::Mat44f &modelToWorld, nvmath::Mat44f &worldToModel) const | Path |
getTail() const | Path | [inline]
IAllocator() | IAllocator | [inline]
isEmpty() const | Path | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
Path() | Path |
Path(const Path &rhs) | Path |
pop() | Path | [inline]
push(ObjectHandle *pObject) | Path |
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
truncate(unsigned int start) | Path |
~IAllocator() | IAllocator | [inline, virtual]
~Path() | Path | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


PerspectiveCamera Class Reference

Class describing a perspective Camera. More...

#include <PerspectiveCamera.h>

Inheritance diagram for PerspectiveCamera:

[legend]
Collaboration diagram for PerspectiveCamera:

[legend]
List of all members.

Public Member Functions

NVSG_API | PerspectiveCamera ()
Default-constructs a PerspectiveCamera.

NVSG_API | PerspectiveCamera (const Camera &rhs)
Constructs a PerspectiveCamera from a Camera.

NVSG_API | PerspectiveCamera (const PerspectiveCamera &rhs)
Copy-constructs a PerspectiveCamera from another PerspectiveCamera.

virtual NVSG_API | ~PerspectiveCamera ()
NVSG_API float | getFieldOfView () const
Get the field of view.

NVSG_API void | setFieldOfView (float fov)
Set the field of view.

virtual NVSG_API void | setFocusDistance (float fd)
Set the distance to the projection plane. Set the distance to the projection plane.

virtual NVSG_API nvmath::Mat44f | getProjection () const
Get the projection matrix of this PerspectiveCamera.

virtual NVSG_API nvmath::Mat44f | getInverseProjection () const
Get the inverse projection matrix of this PerspectiveCamera.

virtual NVSG_API void | getPickRay (int x, int y, int w, int h, nvmath::Vec3f &rayOrigin, nvmath::Vec3f &rayDir) const
Get a pick ray in world coordinates for a given screen point.

NVSG_API PerspectiveCamera & | operator= (const PerspectiveCamera &rhs)
Assignment operator.

virtual NVSG_API CullCode | determineCullCode (const nvmath::Sphere3f &sphere) const
Determine the CullCode of a Sphere3f relative to the view frustum.

Detailed Description

Class describing a perspective Camera.

Namespace: nvsg
Remarks:
A PerspectiveCamera overwrites the projection specific functions of a Camera.
See also:
Camera, ParallelCamera

Constructor & Destructor Documentation

NVSG_API PerspectiveCamera ( )

Default-constructs a PerspectiveCamera.

Remarks:
The PerspectiveCamera initially is positioned at (0.0,0.0,1.0), has the y-axis as up-vector and looks down the negative z-axis.

NVSG_API PerspectiveCamera ( const Camera & rhs ) [explicit]

Constructs a PerspectiveCamera from a Camera.

See also:
Camera

NVSG_API PerspectiveCamera ( const PerspectiveCamera & rhs )

Copy-constructs a PerspectiveCamera from another PerspectiveCamera.

virtual NVSG_API ~PerspectiveCamera ( ) [virtual]

Destructs a PerspectiveCamera.

Member Function Documentation

float getFieldOfView ( ) const [inline]

Get the field of view.

Returns:
The field of view in radians.
Remarks:
The field of view is the complete view angle (in radians) in the y-direction.
See also:
setFieldOfView

NVSG_API void setFieldOfView ( float fov )

Set the field of view.

Parameters:
fov The field of view in radians.
Remarks:
The field of view is the complete view angle (in radians) in the y-direction.
See also:
getFieldOfView

virtual NVSG_API void setFocusDistance ( float fd ) [virtual]

Set the distance to the projection plane. Set the distance to the projection plane.

Parameters:
fd The distance from the PerspectiveCamera to the projection plane.
Remarks:
Setting the focus distance keeps the field of view constant. Therefore, the window size is adjusted accordingly.
See also:
getFieldOfView, getFocusDistance

Reimplemented from Camera.

virtual NVSG_API nvmath::Mat44f getProjection ( ) const [virtual]

Get the projection matrix of this PerspectiveCamera.

Returns:
The projection transformation.
See also:
Camera, getInverseProjection, getWorldToViewMatrix, getViewToWorldMatrix

Implements Camera.

virtual NVSG_API nvmath::Mat44f getInverseProjection ( ) const [virtual]

Get the inverse projection matrix of this PerspectiveCamera.

Returns:
The inverse projection transformation.
See also:
Camera, getProjection, getWorldToViewMatrix, getViewToWorldMatrix

Implements Camera.

virtual NVSG_API void getPickRay | ( | int | x,
 |  | int | y,
 |  | int | w,
 |  | int | h,
 |  | nvmath::Vec3f & | rayOrigin,
 |  | nvmath::Vec3f & | rayDir
 | ) | const [virtual]

Get a pick ray in world coordinates for a given screen point.

Parameters:
x | x-coordinate of the input screen point.
y | y-coordinate of the input screen point.
w | Width of the screen window in pixels.
h | Height of the screen window in pixels.
rayOrigin | Reference to an nvmath::Vec3f to get the ray origin.
rayDir | Reference to an nvmath::Vec3f to get the ray direction.
Remarks:
The function returns in rayOrigin the origin, and in rayDir the direction of the pick ray calculated from the screen point specified by its x and y coordinate. The ray origin is the camera position.
Note:
A screen point of (0,0) indicates the lower left of the currently considered screen window.

Implements Camera.

NVSG_API PerspectiveCamera& operator= ( const PerspectiveCamera & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant PerspectiveCamera to copy from.
Returns:
A reference to the assigned PerspectiveCamera.
Remarks:
The assignment operator calls the assignment operator of Camera.

virtual NVSG_API CullCode determineCullCode ( const nvmath::Sphere3f & sphere ) const [virtual]

Determine the CullCode of a Sphere3f relative to the view frustum.

Parameters:
sphere A reference to the constant Sphere3f to determine the CullCode for.
Returns:
CC_IN, if the Sphere3f sphere is completely inside the view frustum; CC_OUT if it is completely out of the view frustum; otherwise CC_PART.

Implements Camera.

The documentation for this class was generated from the following file:
  • PerspectiveCamera.h
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


Member List

PerspectiveCamera Member List

This is the complete list of members for PerspectiveCamera, including all inherited members.
addHeadLight(LightSourceHandle *light) | Camera |
calcNearFarDistances(const nvmath::Sphere3f &sphere) | Camera |
Camera(void) | Camera | [protected]
Camera(const Camera &rhs) | Camera | [protected]
clearHeadLights(void) | Camera |
determineCullCode(const nvmath::Sphere3f &sphere) const | PerspectiveCamera | [virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getAspectRatio(void) const | Camera | [inline]
getDataID() const | Object | [virtual]
getDirection(void) const | Camera | [inline]
getFarDistance(void) const | Camera | [inline]
getFieldOfView() const | PerspectiveCamera | [inline]
getFocusDistance(void) const | Camera | [inline]
getHeadLight(unsigned int index) const | Camera | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getInverseProjection() const | PerspectiveCamera | [virtual]
getName() const | Object |
getNearDistance(void) const | Camera | [inline]
getNumberOfHeadLights(void) const | Camera | [inline]
getObjectCode() const | Object | [inline]
getOrientation(void) const | Camera | [inline]
getPickRay(int x, int y, int w, int h, nvmath::Vec3f &rayOrigin, nvmath::Vec3f &rayDir) const | PerspectiveCamera | [virtual]
getPosition(void) const | Camera | [inline]
getProjection() const | PerspectiveCamera | [virtual]
getUpVector(void) const | Camera | [inline]
getUserData() const | Object | [inline]
getViewToWorldMatrix(void) const | Camera |
getWindowOffset(void) const | Camera | [inline]
getWindowRegion(nvmath::Vec2f &lowerLeft, nvmath::Vec2f &upperRight) const | Camera | [inline]
getWindowSize(void) const | Camera | [inline]
getWorldToViewMatrix(void) const | Camera |
invalidateIncarnation() | Object | [virtual]
isAutoClipPlanes(void) const | Camera | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
move(const nvmath::Vec3f &delta, bool cameraRelative=true) | Camera |
moveX(float val) | Camera | [inline]
moveY(float val) | Camera | [inline]
moveZ(float val) | Camera | [inline]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const PerspectiveCamera &rhs) | PerspectiveCamera |
nvsg::Camera::operator=(const Camera &rhs) | Camera | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
orbit(const nvmath::Vec3f &axis, float targetDistance, float angle, bool cameraRelative=true) | Camera |
orbitX(float targetDistance, float angle) | Camera | [inline]
orbitY(float targetDistance, float angle) | Camera | [inline]
orbitZ(float targetDistance, float angle) | Camera | [inline]
PerspectiveCamera() | PerspectiveCamera |
PerspectiveCamera(const Camera &rhs) | PerspectiveCamera | [explicit]
PerspectiveCamera(const PerspectiveCamera &rhs) | PerspectiveCamera |
removeHeadLight(unsigned int index) | Camera |
rotate(const nvmath::Vec3f &axis, float angle, bool cameraRelative=true) | Camera |
rotateX(float angle) | Camera | [inline]
rotateY(float angle) | Camera | [inline]
rotateZ(float angle) | Camera | [inline]
setAnnotation(const std::string &anno) | Object |
setAspectRatio(float ar, bool keepWidth=false) | Camera |
setAutoClipPlanes(bool on) | Camera |
setDirection(const nvmath::Vec3f &dir) | Camera |
setFarDistance(float fd) | Camera | [inline]
setFieldOfView(float fov) | PerspectiveCamera |
setFocusDistance(float fd) | PerspectiveCamera | [virtual]
setName(const std::string &name) | Object |
setNearDistance(float nd) | Camera | [inline]
setOrientation(const nvmath::Quatf &quat) | Camera |
setOrientation(const nvmath::Vec3f &dir, const nvmath::Vec3f &up) | Camera |
setPosition(const nvmath::Vec3f &pos) | Camera |
setUpVector(const nvmath::Vec3f &up) | Camera |
setUserData(const void *userData) | Object | [inline]
setWindowOffset(const nvmath::Vec2f &offset) | Camera | [inline]
setWindowRegion(const nvmath::Vec2f &lowerLeft, const nvmath::Vec2f &upperRight) | Camera | [inline]
setWindowSize(const nvmath::Vec2f &size) | Camera | [inline]
validateIncarnation() const | Camera | [virtual]
zoom(float factor) | Camera | [inline]
zoom(const nvmath::Sphere3f &sphere, float fovy=-1.0f) | Camera |
~Camera(void) | Camera | [virtual]
~Object() | Object | [virtual]
~PerspectiveCamera() | PerspectiveCamera | [virtual]
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


plane_t Struct Reference

The plane_t structure specifies how a pair of a bool and a Plane3f is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t active
Specifies if this plane is active.

float3_t normal
Specifies the normal of the plane.

float offset
Specifies the offset of the plane.

Detailed Description

The plane_t structure specifies how a pair of a bool and a Plane3f is stored in a .NBF file.

Member Data Documentation

uint_t active

Specifies if this plane is active.

float3_t normal

Specifies the normal of the plane.

float offset

Specifies the offset of the plane.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


Member List

plane_t Member List

This is the complete list of members for plane_t, including all inherited members.
active | plane_t
normal | plane_t
offset | plane_t
Generated on Tue Jan 15 10:28:45 2008 for NVSGSDK by NVIDIA


TemplatePlanent class Reference

Planent Class Template Reference

Plane class. More...

#include <Planent.h>

Inheritance diagram for Planent:

[legend]
Collaboration diagram for Planent:

[legend]
List of all members.

Public Member Functions

Planent ()
Default constructor.

Planent (const Vecnt< n, T > &normal, T offset)
Constructor by normal and an offset.

Planent (const Vecnt< n, T > &normal, const Vecnt< n, T > &p)
Constructor by normal and a point on the plane.

Planent (const Vecnt< n, T > &p0, const Vecnt< n, T > &p1, const Vecnt< n, T > &p2)
Constructor by three points on the plane.

const Vecnt< n, T > & | getNormal () const
Get the normal of the plane.

T | getOffset () const
Get the offset of the plane.

T | operator() (const Vecnt< n, T > &p) const
Function call operator.

void | setNormal (const Vecnt< n, T > &normal)
Set the normal of the plane.

void | setOffset (T offset)
Set the offset of the plane.

Detailed Description

template<unsigned int n, typename T>
class nvmath::Planent< n, T >

Plane class.

Remarks:
A Plane is a Hyperplane in n-space. It's defined by a normal and an offset, such that for any point x in the plane, the equation
 normal * x + offset = 0
holds.

Constructor & Destructor Documentation

Planent ( ) [inline]

Default constructor.

Remarks:
For performance reasons no initialization is performed.

Planent | ( | const Vecnt< n, T > & | normal,
 |  | T | offset
 | ) | [inline]

Constructor by normal and an offset.

Parameters:
normal | The normal of the plane.
offset | The offset of the plane.
Note:
It is assumed that normal is normalized.

Planent | ( | const Vecnt< n, T > & | normal,
 |  | const Vecnt< n, T > & | p
 | ) | [inline]

Constructor by normal and a point on the plane.

Parameters:
normal | The normal of the plane.
p | An arbitrary point on the plane.
Remarks:
The plane containing the point p, with the plane normal normal is created.

Planent | ( | const Vecnt< n, T > & | p0,
 |  | const Vecnt< n, T > & | p1,
 |  | const Vecnt< n, T > & | p2
 | ) | [inline]

Constructor by three points on the plane.

Parameters:
p0 | A first point on the plane.
p1 | A second point on the plane.
p2 | A third point on the plane.
Remarks:
Three points uniquely define a plane.

Member Function Documentation

const Vecnt< n, T > & getNormal ( ) const [inline]

Get the normal of the plane.

Returns:
A constant reference to the normal of the plane.
See also:
getOffset, setNormal

T getOffset ( ) const [inline]

Get the offset of the plane.

Returns:
The offset of the plane.
See also:
getNormal, setOffset

T operator() ( const Vecnt< n, T > & p ) const [inline]

Function call operator.

Parameters:
p A reference to a constant point.
Returns:
The signed distance of the point p from the plane.

void setNormal ( const Vecnt< n, T > & normal ) [inline]

Set the normal of the plane.

Parameters:
normal A reference to the constant normal to use.
See also:
getNormal, setOffset

void setOffset ( T offset ) [inline]

Set the offset of the plane.

Parameters:
offset The offset to use.
See also:
getOffset, setNormal

The documentation for this class was generated from the following file:
  • Planent.h
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


Member List

Planent Member List

This is the complete list of members for Planent, including all inherited members.
getNormal() const | Planent | [inline]
getOffset() const | Planent | [inline]
operator()(const Vecnt< n, T > &p) const | Planent | [inline]
Planent() | Planent | [inline]
Planent(const Vecnt< n, T > &normal, T offset) | Planent | [inline]
Planent(const Vecnt< n, T > &normal, const Vecnt< n, T > &p) | Planent | [inline]
Planent(const Vecnt< n, T > &p0, const Vecnt< n, T > &p1, const Vecnt< n, T > &p2) | Planent | [inline]
setNormal(const Vecnt< n, T > &normal) | Planent | [inline]
setOffset(T offset) | Planent | [inline]
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


PlugIn Class Reference

Plug-in base class. More...

#include <PlugIn.h>

Inheritance diagram for PlugIn:

[legend]
Collaboration diagram for PlugIn:

[legend]
List of all members.

Public Member Functions

void | setCallback (PlugInCallback *cb, bool throwExceptionOnError=true)
Set the callback object to use on this PlugIn.

Protected Member Functions

virtual void | deleteThis (void)=0
Plug-in deletion.

const PlugInCallback * | callback (void) const
Get the current callback object.

PlugInCallback * | callback (void)

Detailed Description

Plug-in base class.

Serves as base class for all user defined plug-ins.

Member Function Documentation

void setCallback | ( | PlugInCallback * | cb,
 |  | bool | throwExceptionOnError = true
 | ) | [inline]

Set the callback object to use on this PlugIn.

The PlugInCallback object is used to report errors and warnings that happen while using this PlugIn.

Parameters:
cb | callback object to use
throwExceptionOnError | true if an exception is thrown on error

virtual void deleteThis ( void ) [protected, pure virtual]

Plug-in deletion.

Every plug-in must provide this function. It assures that, when deleting the plug-in object, always the right heap manager is called to free the associated memory.

Note:
Ordinary client code is not allowed to call deleteThis on a plug-in object. Client code needs to utilize the PlugInServer interface for plug-in managment for this purposes.

Implemented in ILTexLoader, NBFLoader, NVBLoader, NVSGLoader, PLYLoader, VolLoader, WRLLoader, ILTexSaver, NBFSaver, NVSGSaver, OBJSaver, and VolSaver.

const PlugInCallback * callback ( void ) const [inline, protected]

Get the current callback object.

The documentation for this class was generated from the following file:
  • PlugIn.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

PlugIn Member List

This is the complete list of members for PlugIn, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void)=0 | PlugIn | [protected, pure virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


PlugInCallback Class Reference

PlugInCallback base class. More...

#include <PlugInCallback.h>

Inheritance diagram for PlugInCallback:

[legend]
Collaboration diagram for PlugInCallback:

[legend]
List of all members.

Public Types

enum PIC_ERROR {
PICE_UNEXPECTED_EOF, PICE_UNEXPECTED_TOKEN, PICE_UNKNOWN_TOKEN, PICE_FILE_ACCESS_FAILED,
PICE_FILE_MAPPING_FAILED, PICE_INCOMPATIBLE_FILE, PICE_INVALID_FILE, PICE_UNSPECIFIED_ERROR
}
Enumeration of PlugInCallback errors. More...

enum PIC_WARNING {
PICW_FILE_EMPTY, PICW_FILE_NOT_FOUND, PICW_FILES_NOT_FOUND, PICW_EMPTY_TOKEN,
PICW_INCOMPATIBLE_VALUES, PICW_INVALID_VALUE, PICW_UNDEFINED_TOKEN, PICW_UNSUPPORTED_TOKEN,
PICW_DEGENERATE_GEOMETRY, PICW_UNSPECIFIED_WARNING
}
Enumeration of PlugInCallback warnings. More...

enum | PIC_TYPE_ID { PICT_INT, PICT_FLOAT }
Enumeration of value types used in warnings/errors. More...

Public Member Functions

PlugInCallback ()
Constructor.

void | setThrowExceptionOnError (bool set)
Set whether an exception should be thrown on error.

virtual void | onError (PIC_ERROR eid, const void *info) const
General callback on error.

virtual bool | onWarning (PIC_WARNING wid, const void *info) const
General callback on warning.

virtual bool | onUnLocalizedMessage (const std::string &severity, const std::string &message) const
General callback to display an unlocalized message.

virtual void | onUnexpectedEndOfFile (unsigned int position) const
Specialized callback on error: PICE_UNEXPECTED_EOF.

virtual void | onUnexpectedToken (unsigned int position, const std::string &expected, const std::string &encountered) const
Specialized callback on error: PICE_UNEXPECTED_TOKEN.

virtual void | onUnknownToken (unsigned int position, const std::string &context, const std::string &token) const
Specialized callback on error: PICE_UNKNOWN_TOKEN.

virtual bool | onEmptyToken (unsigned int position, const std::string &context, const std::string &token) const
Specialized callback on warning: PICW_EMPTY_TOKEN.

virtual bool | onFileEmpty (const std::string &file) const
Specialized callback on warning: PICW_FILE_EMPTY.

virtual bool | onFileNotFound (const std::string &file) const
Specialized callback on warning: PICW_FILE_NOT_FOUND.

virtual bool | onFilesNotFound (const std::vector< std::string > &files) const
Specialized callback on warning: PICW_FILES_NOT_FOUND.

virtual bool | onUndefinedToken (unsigned int position, const std::string &context, const std::string &token) const
Specialized callback on warning: PICW_UNDEFINED_TOKEN.

virtual bool | onIncompatibleValues (unsigned int position, const std::string &context, const std::string &value0Name, int value0, const std::string &value1Name, int value1) const
Specialized callback on warning: PICW_INCOMPATIBLE_VALUES.

virtual bool | onIncompatibleValues (unsigned int position, const std::string &context, const std::string &value0Name, float value0, const std::string &value1Name, float value1) const
Specialized callback on warning: PICW_INCOMPATIBLE_VALUES.

virtual bool | onInvalidValue (unsigned int position, const std::string &context, const std::string &valueName, int value) const
Specialized callback on warning: PICW_INVALID_VALUE.

virtual bool | onInvalidValue (unsigned int position, const std::string &context, const std::string &valueName, float value) const
Specialized callback on warning: PICW_INVALID_VALUE.

virtual bool | onUnsupportedToken (unsigned int position, const std::string &context, const std::string &token) const
Specialized callback on warning: PICW_UNSUPPORTED_TOKEN.

virtual bool | onDegenerateGeometry (unsigned int position, const std::string &context) const
Specialized callback on warning: PICW_DEGENERATE_GEOMETRY.

virtual void | onFileAccessFailed (const std::string &file, unsigned int systemSpecificErrorCode) const
Error callback on PICE_FILE_ACCESS_FAILED error.

virtual void | onFileMappingFailed (unsigned int systemSpecificErrorCode) const
Error callback on PICE_FILE_MAPPING_FAILED error.

virtual void | onIncompatibleFile (const std::string &file, const std::string &context, unsigned int expectedVersion, unsigned int detectedVersion) const
Error callback on PICE_INCOMPATIBLE_FILE error.

virtual void | onInvalidFile (const std::string &file, const std::string &context) const
Error callback on PICE_INVALID_FILE error.

Protected Member Functions

virtual | ~PlugInCallback ()
Protected destructor to prevent explicit creation on stack.

Detailed Description

PlugInCallback base class.

A PlugInCallback object can be used to report warnings and errors that happen while using a PlugIn. It is applied to a PlugIn via PlugIn::setCallback(). A PlugInCallback object consists of a set of virtual functions that can be overloaded by an application specific PlugInCallback object. It has two generic callbacks onError and onWarning, that can be called with any error/warning code. And it has two families of specific error and warning functions that are called on specific error/warning conditions.

Member Enumeration Documentation

enum PIC_ERROR

Enumeration of PlugInCallback errors.

enum PIC_WARNING

Enumeration of PlugInCallback warnings.

enum PIC_TYPE_ID

Enumeration of value types used in warnings/errors.

Constructor & Destructor Documentation

PlugInCallback ( ) [inline]

Constructor.

~PlugInCallback ( ) [inline, protected, virtual]

Protected destructor to prevent explicit creation on stack.

Member Function Documentation

void setThrowExceptionOnError ( bool set ) [inline]

Set whether an exception should be thrown on error.

void onError | ( | PIC_ERROR | eid,
 |  | const void * | info
 | ) | const [inline, virtual]

General callback on error.

This general error callback is called with every error that isn't completely handled in a specialized error callback. If throwExceptionOnError is set (default), onError throws an PIC_ERROR exception. The specific error callbacks fall back to this function. This callback can be overloaded to support new error conditions.

Parameters:
eid | error ID
info | pointer to information structure corresponding to eid

bool onWarning | ( | PIC_WARNING | wid,
 |  | const void * | info
 | ) | const [inline, virtual]

General callback on warning.

This general warning callback is called with every warning that isn't completely handled in a specialized warning callback. In this base implemetation, onWarning just returns true, meaning the PlugIn operation can be continued without danger. The specific warning callbacks fall back to this function. This callback can be overloaded to support new warning conditions.

Parameters:
wid | waringing ID
info | pointer to information structure corresponding to wid

bool onUnLocalizedMessage | ( | const std::string & | severity,
 |  | const std::string & | message
 | ) | const [inline, virtual]

General callback to display an unlocalized message.

This general callback is *DISCOURAGED* but can be used by a loader in the event that an unstructured or unlocalized message must be presented to the user.

'severity' should contain either "WARNING" or "ERROR" 'message' should contain the unlocalized text message

In this base implemetation, if the string severity == "WARNING" then the function will return true; if the string severity == "ERROR" then if throwExceptionOnError is set (default), throws PIC_ERROR exception.

This callback can be overloaded to support new warning conditions.

void onUnexpectedEndOfFile ( unsigned int position ) const [inline, virtual]

Specialized callback on error: PICE_UNEXPECTED_EOF.

This error callback is called, when the end of a file was reached unexpectedly. In this base implementation, the general callback onError is called. Overload this callback to implement special handling on unexpected end of file errors.

Parameters:
position position in file, where error occured

void onUnexpectedToken | ( | unsigned int | position,
 |  | const std::string & | expected,
 |  | const std::string & | encountered
 | ) | const [inline, virtual]

Specialized callback on error: PICE_UNEXPECTED_TOKEN.

This error callback is called, when an unexpected token is encountered. In this base implementation, a struct UnexpectedTokenInfo is constructed out of the arguments, and the general callback onError is called. Overlaod this callback to implement special handling on unexpected token errors.

Parameters:
position | position in file, where error occured
expected | expected token
encountered | encountered token

void onUnknownToken | ( | unsigned int | position,
 |  | const std::string & | context,
 |  | const std::string & | token
 | ) | const [inline, virtual]

Specialized callback on error: PICE_UNKNOWN_TOKEN.

This error callback is called, when an unknown token is encountered. In this base implementation, a struct UnknownTokenInfo is constructed out of the arguments, and the general callback onError is called. Overload this callback to implement special handling on unknown token errors.

Parameters:
position | position in file, where the error occured
context | context of the unknown token
token | unknown token

bool onEmptyToken | ( | unsigned int | position,
 |  | const std::string & | context,
 |  | const std::string & | token
 | ) | const [inline, virtual]

Specialized callback on warning: PICW_EMPTY_TOKEN.

This warning callback is called, when a token proved to be empty. In this base implementation, a struct EmptyTokenInfo is constructed out of the arguments, and the general callback onWarning is called. Overload this callback to implement special handling on empty token warnings.

Parameters:
position | position in file, where the warning occured
context | context of the empty token
token | name of the empty token

bool onFileEmpty ( const std::string & file ) const [inline, virtual]

Specialized callback on warning: PICW_FILE_EMPTY.

This warning callback is called, when a file proved to be empty. In this base implementation, the general callback onWarning is called. Overload this callback to implement special handling on empty file warnings.

Parameters:
file name of the empty file

bool onFileNotFound ( const std::string & file ) const [inline, virtual]

Specialized callback on warning: PICW_FILE_NOT_FOUND.

This warning callback is called, when a file wasn't found. In this base implementation, the general callback onWarning is called. Overload this callback to implement special handling on file not found warnings.

Parameters:
file name of the file, that wasn't found

bool onFilesNotFound ( const std::vector< std::string > & files ) const [inline, virtual]

Specialized callback on warning: PICW_FILES_NOT_FOUND.

This warning callback is called, when none of a number of files was found. In this base implementation, the general callback onWarning is called. Overload this callback to implement special handling on file not found warnings.

Parameters:
files vector of files, where none was found

bool onUndefinedToken | ( | unsigned int | position,
 |  | const std::string & | context,
 |  | const std::string & | token
 | ) | const [inline, virtual]

Specialized callback on warning: PICW_UNDEFINED_TOKEN.

This warning callback is called, a named token is used that wasn't defined before. In this base implementation, a struct UndefinedTokenInfo is constructed out of the arguments, and the general callback onWarning is called. Overload this callback to implement special handling on undefined token warnings.

Parameters:
position | position in file, where the warning occured
context | context of the undefined token
token | undefined token

bool onIncompatibleValues | ( | unsigned int | position,
 |  | const std::string & | context,
 |  | const std::string & | value0Name,
 |  | int | value0,
 |  | const std::string & | value1Name,
 |  | int | value1
 | ) | const [inline, virtual]

Specialized callback on warning: PICW_INCOMPATIBLE_VALUES.

This warning callback is called, when two incompatible values of type int are found in the file. In this base implementation, a struct IncompatibleValueInfo is constructed out of the arguments, and the general callback onWarning is called. Overload this callback to implement special handling on incompatible values warnings.

Parameters:
position | position in file, where the warning occured
context | context of the incompatible values
value0Name | name of the first value
value0 | first value
value1Name | name of the second value
value1 | second value

bool onIncompatibleValues | ( | unsigned int | position,
 |  | const std::string & | context,
 |  | const std::string & | value0Name,
 |  | float | value0,
 |  | const std::string & | value1Name,
 |  | float | value1
 | ) | const [inline, virtual]

Specialized callback on warning: PICW_INCOMPATIBLE_VALUES.

This warning callback is called, when two incompatible values of type float are found in the file. In this base implementation, a struct IncompatibleValueInfo is constructed out of the arguments, and the general callback onWarning is called. Overload this callback to implement special handling on incompatible values warnings.

Parameters:
position | position in file, where the warning occured
context | context of the incompatible values
value0Name | name of the first value
value0 | first value
value1Name | name of the second value
value1 | second value

bool onInvalidValue | ( | unsigned int | position,
 |  | const std::string & | context,
 |  | const std::string & | valueName,
 |  | int | value
 | ) | const [inline, virtual]

Specialized callback on warning: PICW_INVALID_VALUE.

This warning callback is called, when an invalid value of type int is found in the file. In this base implementation, a struct InvalidValueInfo is constructed out of the arguments, and the general callback onWarning is called. Overload this callback to implement special handling on incompatible values warnings.

Parameters:
position | position in file, where the warning occured
context | context of the invalid value
valueName | name of the invalid value
value | invalid value

bool onInvalidValue | ( | unsigned int | position,
 |  | const std::string & | context,
 |  | const std::string & | valueName,
 |  | float | value
 | ) | const [inline, virtual]

Specialized callback on warning: PICW_INVALID_VALUE.

This warning callback is called, when an invalid value of type float is found in the file. In this base implementation, a struct InvalidValueInfo is constructed out of the arguments, and the general callback onWarning is called. Overload this callback to implement special handling on incompatible values warnings.

Parameters:
position | position in file, where the warning occured
context | context of the invalid value
valueName | name of the invalid value
value | invalid value

bool onUnsupportedToken | ( | unsigned int | position,
 |  | const std::string & | context,
 |  | const std::string & | token
 | ) | const [inline, virtual]

Specialized callback on warning: PICW_UNSUPPORTED_TOKEN.

This warning callback is called, when an unsupported token is found in the file. In this base implementation, a struct UnsupportedTokenInfo is constructed out of the arguments, and the general callback onWarning is called. Overload this callback to implement special handling on unsupported token warnings.

Parameters:
position | position in file, where the warning occured
context | context of the unsupported token
token | unsupported token

bool onDegenerateGeometry | ( | unsigned int | position,
 |  | const std::string & | context
 | ) | const [inline, virtual]

Specialized callback on warning: PICW_DEGENERATE_GEOMETRY.

This warning callback is called when degenerate geometry is found in the file. In this base implementation, a struct DegenerateGeometryInfo is constructed out of the arguments, and the general callback onWarning is called. Overload this callback to implement special handling on unsupported token warnings.

Parameters:
position | position in file, where the warning occured
name | name of geometry

void onFileAccessFailed | ( | const std::string & | file,
 |  | unsigned int | systemSpecificErrorCode
 | ) | const [inline, virtual]

Error callback on PICE_FILE_ACCESS_FAILED error.

This callback should be invoked from within a plug-in if a file access error occured. The default implementation simply calls onError.
It is advisable to overload this function if more customized error handling is requested for file access errors.

Parameters:
file | Specifies the name of the file
systemSpecificErrorCode | Specifies a system specific error code.

void onFileMappingFailed ( unsigned int systemSpecificErrorCode ) const [inline, virtual]

Error callback on PICE_FILE_MAPPING_FAILED error.

This callback should be invoked from within a plug-in if a file mapping error occured. The default implementation simply calls onError.
It is advisable to overload this function if more customized error handling is requested for file mapping errors.

Parameters:
systemSpecificErrorCode Specifies a system specific error code.

void onIncompatibleFile | ( | const std::string & | file,
 |  | const std::string & | context,
 |  | unsigned int | expectedVersion,
 |  | unsigned int | detectedVersion
 | ) | const [inline, virtual]

Error callback on PICE_INCOMPATIBLE_FILE error.

This callback should be invoked from within a plug-in if a file is detected to be incompatible. The default implementation simply calls onError.
It is advisable to overload this function if more customized error handling is requested when detecting incompatible files.

Parameters:
file | Specifies the name of the file.
context | Specifies the context of detected incompatibility.
expectedVersion | Specifies the expected version. The high-order 16-bits specify < the major version; the low-order 16-bits specify the compatibility level.
detectedVersion | Specifies the detected version. The high-order 16-bits specify < the major version; the low-order 16-bits specify the compatibility level.

void onInvalidFile | ( | const std::string & | file,
 |  | const std::string & | context
 | ) | const [inline, virtual]

Error callback on PICE_INVALID_FILE error.

This callback should be invoked from within a plug-in if a file is detected to be invalid. The default implementation simply calls onError.
It is advisable to overload this function if more customized error handling is requested when detecting invalid files.

Parameters:
file | Specifies the name of the file.
context | Specifies the context of detected invalidity.

The documentation for this class was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback Member List

This is the complete list of members for PlugInCallback, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
onDegenerateGeometry(unsigned int position, const std::string &context) const | PlugInCallback | [inline, virtual]
onEmptyToken(unsigned int position, const std::string &context, const std::string &token) const | PlugInCallback | [inline, virtual]
onError(PIC_ERROR eid, const void *info) const | PlugInCallback | [inline, virtual]
onFileAccessFailed(const std::string &file, unsigned int systemSpecificErrorCode) const | PlugInCallback | [inline, virtual]
onFileEmpty(const std::string &file) const | PlugInCallback | [inline, virtual]
onFileMappingFailed(unsigned int systemSpecificErrorCode) const | PlugInCallback | [inline, virtual]
onFileNotFound(const std::string &file) const | PlugInCallback | [inline, virtual]
onFilesNotFound(const std::vector< std::string > &files) const | PlugInCallback | [inline, virtual]
onIncompatibleFile(const std::string &file, const std::string &context, unsigned int expectedVersion, unsigned int detectedVersion) const | PlugInCallback | [inline, virtual]
onIncompatibleValues(unsigned int position, const std::string &context, const std::string &value0Name, int value0, const std::string &value1Name, int value1) const | PlugInCallback | [inline, virtual]
onIncompatibleValues(unsigned int position, const std::string &context, const std::string &value0Name, float value0, const std::string &value1Name, float value1) const | PlugInCallback | [inline, virtual]
onInvalidFile(const std::string &file, const std::string &context) const | PlugInCallback | [inline, virtual]
onInvalidValue(unsigned int position, const std::string &context, const std::string &valueName, int value) const | PlugInCallback | [inline, virtual]
onInvalidValue(unsigned int position, const std::string &context, const std::string &valueName, float value) const | PlugInCallback | [inline, virtual]
onUndefinedToken(unsigned int position, const std::string &context, const std::string &token) const | PlugInCallback | [inline, virtual]
onUnexpectedEndOfFile(unsigned int position) const | PlugInCallback | [inline, virtual]
onUnexpectedToken(unsigned int position, const std::string &expected, const std::string &encountered) const | PlugInCallback | [inline, virtual]
onUnknownToken(unsigned int position, const std::string &context, const std::string &token) const | PlugInCallback | [inline, virtual]
onUnLocalizedMessage(const std::string &severity, const std::string &message) const | PlugInCallback | [inline, virtual]
onUnsupportedToken(unsigned int position, const std::string &context, const std::string &token) const | PlugInCallback | [inline, virtual]
onWarning(PIC_WARNING wid, const void *info) const | PlugInCallback | [inline, virtual]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
PIC_ERROR enum name | PlugInCallback |
PIC_TYPE_ID enum name | PlugInCallback |
PIC_WARNING enum name | PlugInCallback |
PICE_FILE_ACCESS_FAILED enum value (defined in PlugInCallback) | PlugInCallback |
PICE_FILE_MAPPING_FAILED enum value (defined in PlugInCallback) | PlugInCallback |
PICE_INCOMPATIBLE_FILE enum value (defined in PlugInCallback) | PlugInCallback |
PICE_INVALID_FILE enum value (defined in PlugInCallback) | PlugInCallback |
PICE_UNEXPECTED_EOF enum value (defined in PlugInCallback) | PlugInCallback |
PICE_UNEXPECTED_TOKEN enum value (defined in PlugInCallback) | PlugInCallback |
PICE_UNKNOWN_TOKEN enum value (defined in PlugInCallback) | PlugInCallback |
PICE_UNSPECIFIED_ERROR enum value (defined in PlugInCallback) | PlugInCallback |
PICT_FLOAT enum value (defined in PlugInCallback) | PlugInCallback |
PICT_INT enum value (defined in PlugInCallback) | PlugInCallback |
PICW_DEGENERATE_GEOMETRY enum value (defined in PlugInCallback) | PlugInCallback |
PICW_EMPTY_TOKEN enum value (defined in PlugInCallback) | PlugInCallback |
PICW_FILE_EMPTY enum value (defined in PlugInCallback) | PlugInCallback |
PICW_FILE_NOT_FOUND enum value (defined in PlugInCallback) | PlugInCallback |
PICW_FILES_NOT_FOUND enum value (defined in PlugInCallback) | PlugInCallback |
PICW_INCOMPATIBLE_VALUES enum value (defined in PlugInCallback) | PlugInCallback |
PICW_INVALID_VALUE enum value (defined in PlugInCallback) | PlugInCallback |
PICW_UNDEFINED_TOKEN enum value (defined in PlugInCallback) | PlugInCallback |
PICW_UNSPECIFIED_WARNING enum value (defined in PlugInCallback) | PlugInCallback |
PICW_UNSUPPORTED_TOKEN enum value (defined in PlugInCallback) | PlugInCallback |
PlugInCallback() | PlugInCallback | [inline]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setThrowExceptionOnError(bool set) | PlugInCallback | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~PlugInCallback() | PlugInCallback | [inline, protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::DegenerateGeometryInfo Struct Reference

Information structure used for warning PICW_DEGENERATE_GEOMETRY. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int | position
position in file, where the warning was raised

std::string | name
name of the geometry that was degenerate

Detailed Description

Information structure used for warning PICW_DEGENERATE_GEOMETRY.

Member Data Documentation

unsigned int position

position in file, where the warning was raised

std::string name

name of the geometry that was degenerate

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::DegenerateGeometryInfo Member List

This is the complete list of members for PlugInCallback::DegenerateGeometryInfo, including all inherited members.
name | PlugInCallback::DegenerateGeometryInfo
position | PlugInCallback::DegenerateGeometryInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::EmptyTokenInfo Struct Reference

Information structure used for warning PICW_EMPTY_TOKEN. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int | position
position in file, where the warning was raised

std::string | context
context of the warning

std::string | token
name of empty token

Detailed Description

Information structure used for warning PICW_EMPTY_TOKEN.

Member Data Documentation

unsigned int position

position in file, where the warning was raised

std::string context

context of the warning

std::string token

name of empty token

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::EmptyTokenInfo Member List

This is the complete list of members for PlugInCallback::EmptyTokenInfo, including all inherited members.
context | PlugInCallback::EmptyTokenInfo
position | PlugInCallback::EmptyTokenInfo
token | PlugInCallback::EmptyTokenInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::FileAccessFailedInfo Struct Reference

Information structure used for error PICE_FILE_ACCESS_ERROR. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

std::string | file
Specifies the name of the file for which the access error occurred.

unsigned int | systemSpecificErrorCode
Specifies a system specific error code.

Detailed Description

Information structure used for error PICE_FILE_ACCESS_ERROR.

Member Data Documentation

std::string file

Specifies the name of the file for which the access error occurred.

unsigned int systemSpecificErrorCode

Specifies a system specific error code.

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::FileAccessFailedInfo Member List

This is the complete list of members for PlugInCallback::FileAccessFailedInfo, including all inherited members.
file | PlugInCallback::FileAccessFailedInfo
systemSpecificErrorCode | PlugInCallback::FileAccessFailedInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::FileMappingFailedInfo Struct Reference

Information structure used for error PICE_FILE_MAPPING_ERROR. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int systemSpecificErrorCode
Specifies a system specific error code.

Detailed Description

Information structure used for error PICE_FILE_MAPPING_ERROR.

Member Data Documentation

unsigned int systemSpecificErrorCode

Specifies a system specific error code.

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::FileMappingFailedInfo Member List

This is the complete list of members for PlugInCallback::FileMappingFailedInfo, including all inherited members.
systemSpecificErrorCode PlugInCallback::FileMappingFailedInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::IncompatibleFileInfo Struct Reference

Information structure used for error PICE_INCOMPATIBLE_FILE. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

std::string | file
Specifies the name of the file that was detected to be incompatible.

std::string | context
Specifies the context of detected incompatibility.

unsigned int | expectedVersion
unsigned int | detectedVersion

Detailed Description

Information structure used for error PICE_INCOMPATIBLE_FILE.

Member Data Documentation

std::string file

Specifies the name of the file that was detected to be incompatible.

std::string context

Specifies the context of detected incompatibility.

unsigned int expectedVersion

Specifies the expected version. The high-order 16-bits specify < the major version; the low-order 16-bits specify the compatibility level.

unsigned int detectedVersion

Specifies the detected version. The high-order 16-bits specify < the major version; the low-order 16-bits specify the compatibility level.

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::IncompatibleFileInfo Member List

This is the complete list of members for PlugInCallback::IncompatibleFileInfo, including all inherited members.
context | PlugInCallback::IncompatibleFileInfo
detectedVersion | PlugInCallback::IncompatibleFileInfo
expectedVersion | PlugInCallback::IncompatibleFileInfo
file | PlugInCallback::IncompatibleFileInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::IncompatibleValueInfo Struct Reference

Information structure used for warning PICW_INCOMPATIBLE_VALUES. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int | position
position in file, where the warning was raised

std::string | context
context of the warning

PIC_TYPE_ID valueType
type of the incompatible values

std::string | value0Name
name of the first value

const void * | value0
pointer to the first value

std::string | value1Name
name of the second value

const void * | value1
pointer to the second value

Detailed Description

Information structure used for warning PICW_INCOMPATIBLE_VALUES.

Member Data Documentation

unsigned int position

position in file, where the warning was raised

std::string context

context of the warning

PIC_TYPE_ID valueType

type of the incompatible values

std::string value0Name

name of the first value

const void* value0

pointer to the first value

std::string value1Name

name of the second value

const void* value1

pointer to the second value

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::IncompatibleValueInfo Member List

This is the complete list of members for PlugInCallback::IncompatibleValueInfo, including all inherited members.
context | PlugInCallback::IncompatibleValueInfo
position | PlugInCallback::IncompatibleValueInfo
value0 | PlugInCallback::IncompatibleValueInfo
value0Name | PlugInCallback::IncompatibleValueInfo
value1 | PlugInCallback::IncompatibleValueInfo
value1Name | PlugInCallback::IncompatibleValueInfo
valueType | PlugInCallback::IncompatibleValueInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::InvalidFileInfo Struct Reference

Information structure used for error PICE_INVALID_FILE. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

std::string | file
Specifies the name of the file the was detected to be invalid.

std::string | context
Specifies the context of detected invalidity.

Detailed Description

Information structure used for error PICE_INVALID_FILE.

Member Data Documentation

std::string file

Specifies the name of the file the was detected to be invalid.

std::string context

Specifies the context of detected invalidity.

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::InvalidFileInfo Member List

This is the complete list of members for PlugInCallback::InvalidFileInfo, including all inherited members.
context | PlugInCallback::InvalidFileInfo
file | PlugInCallback::InvalidFileInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::InvalidValueInfo Struct Reference

Information structure used for warning PICW_INVALID_VALUE. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int | position
position in file, where the warning was raised

std::string | context
context of the warning

PIC_TYPE_ID valueType
type of the invalid value

std::string | valueName
name of the value

const void * | value
pointer to the value

Detailed Description

Information structure used for warning PICW_INVALID_VALUE.

Member Data Documentation

unsigned int position

position in file, where the warning was raised

std::string context

context of the warning

PIC_TYPE_ID valueType

type of the invalid value

std::string valueName

name of the value

const void* value

pointer to the value

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::InvalidValueInfo Member List

This is the complete list of members for PlugInCallback::InvalidValueInfo, including all inherited members.
context | PlugInCallback::InvalidValueInfo
position | PlugInCallback::InvalidValueInfo
value | PlugInCallback::InvalidValueInfo
valueName | PlugInCallback::InvalidValueInfo
valueType | PlugInCallback::InvalidValueInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::UndefinedTokenInfo Struct Reference

Information structure used for warning PICW_UNDEFINED_TOKEN. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int | position
position in file, where the warning was raised

std::string | context
context of the undefined token

std::string | token
undefined token

Detailed Description

Information structure used for warning PICW_UNDEFINED_TOKEN.

Member Data Documentation

unsigned int position

position in file, where the warning was raised

std::string context

context of the undefined token

std::string token

undefined token

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::UndefinedTokenInfo Member List

This is the complete list of members for PlugInCallback::UndefinedTokenInfo, including all inherited members.
context | PlugInCallback::UndefinedTokenInfo
position | PlugInCallback::UndefinedTokenInfo
token | PlugInCallback::UndefinedTokenInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::UnexpectedTokenInfo Struct Reference

Information structure used for error PICE_UNEXPECTED_TOKEN. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int | position
position in file, where the error was raised

std::string | expected
expected token

std::string | encountered
encountered token

Detailed Description

Information structure used for error PICE_UNEXPECTED_TOKEN.

Member Data Documentation

unsigned int position

position in file, where the error was raised

std::string expected

expected token

std::string encountered

encountered token

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::UnexpectedTokenInfo Member List

This is the complete list of members for PlugInCallback::UnexpectedTokenInfo, including all inherited members.
encountered | PlugInCallback::UnexpectedTokenInfo
expected | PlugInCallback::UnexpectedTokenInfo
position | PlugInCallback::UnexpectedTokenInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::UnknownTokenInfo Struct Reference

Information structure used for error PICE_UNKNOWN_TOKEN. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int | position
position in file, where the error was raised

std::string | context
context of the unknown token

std::string | token
unknown token

Detailed Description

Information structure used for error PICE_UNKNOWN_TOKEN.

Member Data Documentation

unsigned int position

position in file, where the error was raised

std::string context

context of the unknown token

std::string token

unknown token

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::UnknownTokenInfo Member List

This is the complete list of members for PlugInCallback::UnknownTokenInfo, including all inherited members.
context | PlugInCallback::UnknownTokenInfo
position | PlugInCallback::UnknownTokenInfo
token | PlugInCallback::UnknownTokenInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInCallback::UnsupportedTokenInfo Struct Reference

Information structure used for warning PICW_UNSUPPORTED_TOKEN. More...

#include <PlugInCallback.h>

List of all members.

Public Attributes

unsigned int | position
position in file, where the warning was raised

std::string | context
context of the unsupported token

std::string | token
unsupported token

Detailed Description

Information structure used for warning PICW_UNSUPPORTED_TOKEN.

Member Data Documentation

unsigned int position

position in file, where the warning was raised

std::string context

context of the unsupported token

std::string token

unsupported token

The documentation for this struct was generated from the following file:
  • PlugInCallback.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInCallback::UnsupportedTokenInfo Member List

This is the complete list of members for PlugInCallback::UnsupportedTokenInfo, including all inherited members.
context | PlugInCallback::UnsupportedTokenInfo
position | PlugInCallback::UnsupportedTokenInfo
token | PlugInCallback::UnsupportedTokenInfo
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PlugInServer Class Reference

Plug-in management. More...

#include <PlugIn.h>

List of all members.

Friends

NVSG_API bool | getInterface (const std::vector< std::string > &searchPath, const UPIID &piid, PlugIn *&plugIn)
Get hold of a certain interface object.

NVSG_API bool | queryInterfaceType (const std::vector< std::string > &searchPath, const UPITID &pitid, std::vector< UPIID > &piids)
Query for a certain interface type.

NVSG_API void | releaseInterface (const UPIID &piid)
Release a certain interface.

NVSG_API void | setPlugInFileFilter (const std::string &filter)
Specify a file name filter to be used while searching for appropriate plug-in modules.

NVSG_API void | addPlugInSearchPath (const std::string &path)
Add a path to the list of directories used to search for PlugIn DLLs.

NVSG_API const std::vector<
std::string > & 		getPlugInSearchPath ()
Return the list of directories used to search for PlugIn DLLs.

Detailed Description

Plug-in management.

The PlugInServer class provides functionality for convenient plug-in managment.

The PlugInServer is a central management tool to handle plug-ins and therefore it is implemented as a singleton object. The interface of the PlugInServer can only be accesses through an external set of wrapper functions with special access rights.

Friends And Related Function Documentation

NVSG_API bool getInterface | ( | const std::vector< std::string > & | searchPath,
 |  | const UPIID & | piid,
 |  | PlugIn *& | plugIn
 | ) | [friend]

Get hold of a certain interface object.

Searches the searchPath in addition to plug-in search-paths for a plug-in that provides an interface specified by piid. If successfull, plugIn holds the requested interface object.

While searching for appropriate plug-in modules, this function uses either the PlugInServer's default file name filter or a custom file name filter set by a call to nvutil::setPlugInFileFilter. The default file name filter for plug-in modules is "*.nxm" on Microsoft(R) Windows platforms as well as on Linux platforms.

The function always returns the first matching interface found in the specified search path in consideration of the used file name filter.

If client code asks for a certain interface a second time, without releasing the interface object got with the first call to getInterface, this function will not search through the search path a second time but returning the interface object registered with the first call. This will also work this way, independent of whether the file name filter was changed in between.

Remarks:
If client code has no concrete interface ID available to query for, it should first query for a superior interface type using nvutil::queryInterfaceType to get hold of a list of interfaces all providing the superior interface type.
In order to utilize the concrete interface queried for, client code must 'reinterpret_cast' plugIn to a concrete interface pointer and use this pointer to access the interface.
To avoid resource leaks, client code should release the interface through a call to nvutil::releaseInterface, after usage.
Returns:
true if successfull, false otherwise.
Parameters:
searchPath | The optional path to search for the plug-ins.
piid | Identifies the interface to search for.
plugIn | Holds the interface object (plug-in), if successfull.

NVSG_API bool queryInterfaceType | ( | const std::vector< std::string > & | searchPath,
 |  | const UPITID & | pitid,
 |  | std::vector< UPIID > & | piids
 | ) | [friend]

Query for a certain interface type.

Searches the searchPath in addition to plug-in search paths for all plug-ins that provide a certain interface type specified by pitid. If successful, client code will receive the concrete interface IDs in piids. Each of these IDs can than be used along with nvutil::getInterface, to get an interface object.

While searching for appropriate plug-in modules, this function uses either the PlugInServer's default file name filter or a custom file name filter set by a call to nvutil::setPlugInFileFilter. The default file name filter for plug-in modules is "*.dll" on Microsoft(R) Windows platforms, and "*.so" on Linux platforms.

Returns:
true if successful, false otherwise.
Parameters:
searchPath | The optional path to search for plug-ins.
pitid | Identifies the interface type to query for.
piids | Holds all interface IDs found, if successfull.

NVSG_API void releaseInterface ( const UPIID & piid ) [friend]

Release a certain interface.

Frees all resources acquired by the interface object identified by piid.

Parameters:
piid Identifies the interface to be released.

NVSG_API void setPlugInFileFilter ( const std::string & filter ) [friend]

Specify a file name filter to be used while searching for appropriate plug-in modules.

This function overrides the PlugInServer's default file name filter used to search for appropriate plug-in modules. The function lets you specify different file name patterns. The patterns must be separated by a semicolon.

Parameters:
filter String of file name filter patterns all delimited by a semicolon.

NVSG_API void addPlugInSearchPath ( const std::string & path ) [friend]

Add a path to the list of directories used to search for PlugIn DLLs.

This function adds a directory to the internal search list. The list is used internally when NVSG looks for Texture Loaders and it can be queried by an application through getPlugInSearchPath() to be used as a search path when querying SceneLoader PlugIns. It will always contain the current instance's path (module path), which is added during initialization.

Parameters:
path A directory to be added to the search path.

NVSG_API const std::vector<std::string>& getPlugInSearchPath ( ) [friend]

Return the list of directories used to search for PlugIn DLLs.

See comments for addPlugInSearchPath()

The documentation for this class was generated from the following file:
  • PlugIn.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

PlugInServer Member List

This is the complete list of members for PlugInServer, including all inherited members.
addPlugInSearchPath(const std::string &path) | PlugInServer | [friend]
getInterface(const std::vector< std::string > &searchPath, const UPIID &piid, PlugIn *&plugIn) | PlugInServer | [friend]
getPlugInSearchPath() | PlugInServer | [friend]
PlugInServer() (defined in PlugInServer) | PlugInServer |
queryInterfaceType(const std::vector< std::string > &searchPath, const UPITID &pitid, std::vector< UPIID > &piids) | PlugInServer | [friend]
releaseInterface(const UPIID &piid) | PlugInServer | [friend]
setPlugInFileFilter(const std::string &filter) | PlugInServer | [friend]
~PlugInServer() (defined in PlugInServer) | PlugInServer |
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


PLYLoader Class Reference

A Scene Loader for PLY files. More...

#include <PLYLoader.h>

Inheritance diagram for PLYLoader:

[legend]
Collaboration diagram for PLYLoader:

[legend]
List of all members.

Public Member Functions

void | deleteThis (void)
Realization of the pure virtual interface function of a PlugIn.

nvsg::SceneHandle * | load (const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState)
Realization of the pure virtual interface function of a SceneLoader.

Protected Member Functions

ubyte_t * | mapOffset (uint_t offset, size_t numBytes)
Maps numBytes bytes at file offset offset into process memory.

void | unmapOffset (ubyte_t *offsetPtr)
Unmaps the memory that previously was mapped through mapOffset from the process' address space.

Detailed Description

A Scene Loader for PLY files.

PLY are simple single geometry files often used in academia. Most famous scenes found in PLY format are the Stanford Bunny, Happy Buddha, Dragon, and Armadillo. A repository of model can be found here:

Member Function Documentation

ubyte_t * mapOffset | ( | uint_t | offset,
 |  | size_t | numBytes
 | ) | [inline, protected]

Maps numBytes bytes at file offset offset into process memory.

This function turns a given offset into a pointer and ensures that a minimum of numBytes bytes are mapped.

Returns:
A pointer to the mapped memory.
Parameters:
offset | File offset of the memory block to map.
numBytes | Amount of bytes to map into process memory.

void unmapOffset ( ubyte_t * offsetPtr ) [inline, protected]

Unmaps the memory that previously was mapped through mapOffset from the process' address space.

The function accepts a pointer to the mapped file offset that previously was received by a call to mapOffset.

Parameters:
offsetPtr Address where the file offset was mapped.

void deleteThis ( void ) [inline, virtual]

Realization of the pure virtual interface function of a PlugIn.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

nvsg::SceneHandle* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | nvsg::ViewStateHandle *& | viewState
 | ) | [virtual]

Realization of the pure virtual interface function of a SceneLoader.

Loads a PLY file given by filename. It looks for this file and possibly referenced other files like textures or effects at the given path first, then at the current location and finally it searches through the searchPaths.

Returns:
A pointer to the loaded scene.
Parameters:
filename | file to load
searchPaths | paths to search through
viewState | If the function succeeded, this points to the optional ViewState stored with the scene.

Implements SceneLoader.

The documentation for this class was generated from the following file:
  • PLYLoader.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

PLYLoader Member List

This is the complete list of members for PLYLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | PLYLoader | [inline, virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState) | PLYLoader | [virtual]
mapOffset(uint_t offset, size_t numBytes) | PLYLoader | [inline, protected]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
PLYLoader() (defined in PLYLoader) | PLYLoader |
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
unmapOffset(ubyte_t *offsetPtr) | PLYLoader | [inline, protected]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~PLYLoader() (defined in PLYLoader) | PLYLoader |
~SceneLoader() | SceneLoader | [protected, virtual]
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


PointAttribute Class Reference

PrimitiveAttribute specific for Points. More...

#include <PointAttribute.h>

Inheritance diagram for PointAttribute:

[legend]
Collaboration diagram for PointAttribute:

[legend]
List of all members.

Public Member Functions

NVSG_API | PointAttribute ()
Default-constructs a PointAttribute.

NVSG_API | PointAttribute (const PrimitiveAttribute &rhs)
Constructs a PointAttribute from a PrimitiveAttribute.

NVSG_API | PointAttribute (const PointAttribute &rhs)
Constructs a PointAttribute as a copy from another PointAttribute.

virtual NVSG_API | ~PointAttribute ()
Destructs a PointAttribute.

NVSG_API bool | isAntiAliased () const
Get the anti-aliasing state.

NVSG_API void | setAntiAliasing (bool aa)
Set the anti-aliasing state.

NVSG_API float | getSize () const
Get the point size.

NVSG_API void | setSize (float size)
Set the point size.

NVSG_API PointAttribute & | operator= (const PointAttribute &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other PointAttribute.

Detailed Description

PrimitiveAttribute specific for Points.

Namespace: nvsg
Remarks:
A PointAttribute holds the point-specific attributes of a StatePass.
Note:
Faces and Lines are not affected by a PointAttribute.
See also:
FaceAttribute, LineAttribute, PrimitiveAttribute, StatePass

Constructor & Destructor Documentation

NVSG_API PointAttribute ( )

Default-constructs a PointAttribute.

Remarks:
A default-constructed PointAttribute has anti-aliasing off, and a point size of 1.0.

NVSG_API PointAttribute ( const PrimitiveAttribute & rhs ) [explicit]

Constructs a PointAttribute from a PrimitiveAttribute.

Parameters:
rhs Source PrimitiveAttribute
Remarks:
The PointAttribute will be initially has anti-aliasing off, and a point size of 1.0.

NVSG_API PointAttribute ( const PointAttribute & rhs )

Constructs a PointAttribute as a copy from another PointAttribute.

virtual NVSG_API ~PointAttribute ( ) [virtual]

Destructs a PointAttribute.

Member Function Documentation

bool isAntiAliased ( ) const [inline]

Get the anti-aliasing state.

Returns:
true, if anti-aliasing for Points is enabled, otherwise false.
Remarks:
With anti-aliasing enabled, a point is drawn as a circular group of pixels, and the pixels on the boundaries are typically drawn at less than full intensity to give the edge a smoother appearance. By default, anti-aliasing is disabled.
See also:
getSize, setAntiAliasing

void setAntiAliasing ( bool aa ) [inline]

Set the anti-aliasing state.

Parameters:
aa true, if anti-aliasing is to be enabled, otherwise false.
Remarks:
With anti-aliasing enabled, a point is drawn as a circular group of pixels, and the pixels on the boundaries are typically drawn at less than full intensity to give the edge a smoother appearance. By default, anti-aliasing is disabled.
See also:
isAntiAliasing, setSize

float getSize ( ) const [inline]

Get the point size.

Returns:
The point size
Remarks:
The size must be greater than 0.0, and by default is 1.0.
See also:
isAntiAliased, setSize

void setSize ( float size ) [inline]

Set the point size.

Parameters:
size The point size
Remarks:
The size must be greater than 0.0, and by default is 1.0.
See also:
getSize, setAntiAliasing

NVSG_API PointAttribute& operator= ( const PointAttribute & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant PointAttribute to copy from
Returns:
A reference to the assigned PointAttribute
Remarks:
The assignment operator calls the assignment operator of PrimitiveAttribute and then copies the PointAttribute specific data.
See also:
PrimitiveAttribute

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other PointAttribute.

Parameters:
p | A reference to the constant PointAttribute to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the PointAttribute p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as PrimitiveAttribute, they are equivalent if they have the same anti-aliasing state and the same point size.
Note:
The behavior is undefined if p is not a PointAttribute nor derived from one.
See also:
PrimitiveAttribute

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • PointAttribute.h
Generated on Tue Jan 15 10:29:13 2008 for NVSGSDK by NVIDIA


Member List

PointAttribute Member List

This is the complete list of members for PointAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getSize() const | PointAttribute | [inline]
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isAntiAliased() const | PointAttribute | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | PointAttribute | [virtual]
isTransparent(void) const | StateAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const PointAttribute &rhs) | PointAttribute |
nvsg::PrimitiveAttribute::operator=(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
PointAttribute() | PointAttribute |
PointAttribute(const PrimitiveAttribute &rhs) | PointAttribute | [explicit]
PointAttribute(const PointAttribute &rhs) | PointAttribute |
PrimitiveAttribute() | PrimitiveAttribute | [protected]
PrimitiveAttribute(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setAntiAliasing(bool aa) | PointAttribute | [inline]
setName(const std::string &name) | Object |
setSize(float size) | PointAttribute | [inline]
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~PointAttribute() | PointAttribute | [virtual]
~PrimitiveAttribute() | PrimitiveAttribute | [virtual]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:13 2008 for NVSGSDK by NVIDIA


PointLight Class Reference

LightSource representing a point light. More...

#include <PointLight.h>

Inheritance diagram for PointLight:

[legend]
Collaboration diagram for PointLight:

[legend]
List of all members.

Public Member Functions

NVSG_API | PointLight ()
Default-constructs a PointLight.

NVSG_API | PointLight (const LightSource &rhs)
Constructs a PointLight from a LightSource.

NVSG_API | PointLight (const PointLight &rhs)
Constructs a PointLight as a copy of another PointLight.

virtual NVSG_API | ~PointLight ()
Destructs a PointLight.

NVSG_API const nvmath::Vec3f & | getPosition () const
Get the position.

NVSG_API void | setPosition (const nvmath::Vec3f &position)
Set the position.

NVSG_API bool | isAttenuated () const
Query if this PointLight is attenuated.

NVSG_API void | getAttenuation (float &c, float &l, float &q) const
Get the attenuation factors.

NVSG_API const nvmath::Vec3f & | getAttenuation () const
Get the attenuation factors as a nvmath::Vec3f.

NVSG_API void | setAttenuation (float c, float l, float q)
Set the attenuation factors.

NVSG_API void | setAttenuation (const nvmath::Vec3f &attenuation)
Set the attenuation factors by a nvmath::Vec3f.

NVSG_API PointLight & | operator= (const PointLight &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other PointLight.

Detailed Description

LightSource representing a point light.

Namespace: nvsg
Remarks:
Point lights have color and position within a scene, but no single direction. They give off light equally in all directions. A light bulb is a good example of a point light. Point lights are affected by attenuation and range, and illuminate a mesh on a vertex-by-vertex basis. During lighting, the point light's position in world space and the coordinates of the vertex being lit are used to derive a vector for the direction of the light and the distance that the light has traveled. Both are used, along with the vertex normal, to calculate the contribution of the light to the illumination of the surface. The defaults for a PointLight are as follows:
  • attenuation is off (constant = 1.0, linear = 0.0, quadratic = 0.0)
  • position is the origin (0.0,0.0,0.0)
See also:
LightSource, DirectedLight, SpotLight

Constructor & Destructor Documentation

NVSG_API PointLight ( )

Default-constructs a PointLight.

NVSG_API PointLight ( const LightSource & rhs ) [explicit]

Constructs a PointLight from a LightSource.

Parameters:
rhs LightSource to construct the PointLight from.
Remarks:
This is kind of a partial copy constructor only copying the LightSource part from the source object.

NVSG_API PointLight ( const PointLight & rhs )

Constructs a PointLight as a copy of another PointLight.

virtual NVSG_API ~PointLight ( ) [virtual]

Destructs a PointLight.

Member Function Documentation

const nvmath::Vec3f & getPosition ( ) const [inline]

Get the position.

Returns:
A reference to the constant position of the PointLight.
Remarks:
The default position is the origin (0.0,0.0,0.0).
See also:
setPosition

NVSG_API void setPosition ( const nvmath::Vec3f & position )

Set the position.

Parameters:
position A reference to the constant position to set.
Remarks:
The default position is the origin (0.0,0.0,0.0).
See also:
getPosition

bool isAttenuated ( ) const [inline]

Query if this PointLight is attenuated.

Returns:
true if this light source is attenuated, otherwise false
Remarks:
A PointLight is attenuated if the constant attenuation factor is different from one, or if the linear or quadratic attenuation factor is different from zero.
By default, attenuation is off.
See also:
getAttenuation, setAttenuation

void getAttenuation | ( | float & | c,
 |  | float & | l,
 |  | float & | q
 | ) | const [inline]

Get the attenuation factors.

Parameters:
c | A reference to a float to get the constant attenuation factor.
l | A reference to a float to get the linear attenuation factor.
q | A reference to a float to get the quadratic attenuation factor.
Remarks:
The attenuation factors are used to calculate the attenuation of this light at a lit point, using the equation
 atten = 1 / ( c + l * d + q * d * d )
where d is the distance between the light and the vertex.
By default, attenuation is off.
See also:
isAttenuated, setAttenuation

const nvmath::Vec3f & getAttenuation ( ) const [inline]

Get the attenuation factors as a nvmath::Vec3f.

Returns:
A reference to the constant nvmath::Vec3f with the attenuation factors.
Remarks:
The attenuation factors are used to calculate the attenuation of this light at a lit point, using the equation
 atten = 1 / ( v[0] + v[1] * d + v[2] * d * d )
where v is the returned nvmath::Vec3f, and d is the distance between the light and the vertex.
By default, attenuation is off.
See also:
isAttenuated, setAttenuation

void setAttenuation | ( | float | c,
 |  | float | l,
 |  | float | q
 | ) | [inline]

Set the attenuation factors.

Parameters:
c | The constant attenuation factor.
l | The linear attenuation factor.
q | The quadratic attenuation factor.
Remarks:
The attenuation factors are used to calculate the attenuation of this light at a lit point, using the equation
 atten = 1 / ( c + l * d + q * d * d )
where d is the distance between the light and the vertex.
By default, attenuation is off.
See also:
isAttenuated, getAttenuation

void setAttenuation ( const nvmath::Vec3f & attenuation ) [inline]

Set the attenuation factors by a nvmath::Vec3f.

Parameters:
attenuation A reference to the constant attenuation factors.
Remarks:
The attenuation factors are used to calculate the attenuation of this light at a lit point, using the equation
 atten = 1 / ( v[0] + v[1] * d + v[2] * d * d )
where v is the returned nvmath::Vec3f, and d is the distance between the light and the vertex.
By default, attenuation is off.
See also:
isAttenuated, getAttenuation

NVSG_API PointLight& operator= ( const PointLight & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant PointLight to copy from
Returns:
A reference to the assigned PointLight
Remarks:
The assignment operator calls the assignment operator of LightSource, and copies the attenuation factors.
See also:
LightSource

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other PointLight.

Parameters:
p | A pointer to the PointLight to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the PointLight p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as LightSource, they are equivalent if the attenuation factors are equal.
Note:
The behavior is undefined if p is not a PointLight nor derived from one.
See also:
DirectedLight, LightSource, SpotLight

Reimplemented from LightSource.

The documentation for this class was generated from the following file:
  • PointLight.h
Generated on Tue Jan 15 10:29:13 2008 for NVSGSDK by NVIDIA


Member List

PointLight Member List

This is the complete list of members for PointLight, including all inherited members.
addOwner(typename GroupHandle::ObjectType *obj) | OwnedObject< GroupHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< GroupHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAmbientColor() const | LightSource | [inline]
getAnimation() const | LightSource | [inline]
getAnnotation() const | Object |
getAttenuation(float &c, float &l, float &q) const | PointLight | [inline]
getAttenuation() const | PointLight | [inline]
getDataID() const | Object | [virtual]
getDiffuseColor() const | LightSource | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIntensity() const | LightSource | [inline]
getInverse() const | LightSource | [inline]
getName() const | Object |
getNumberOfOwners() const | OwnedObject< GroupHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< GroupHandle > |
getPosition() const | PointLight | [inline]
getSpecularColor() const | LightSource | [inline]
getTransformationMatrix() const | LightSource | [inline]
getUserData() const | Object | [inline]
invalidateAnimationContainment() | LightSource |
invalidateIncarnation() | OwnedObject< GroupHandle > | [virtual]
isAttenuated() const | PointLight | [inline]
isDataShared() const | Object | [virtual]
isEnabled() const | LightSource | [inline]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | PointLight | [virtual]
isShadowCasting() const | LightSource | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
LightSource() | LightSource | [protected]
LightSource(const LightSource &rhs) | LightSource | [protected]
m_objectCode | Object | [protected]
m_trafo | LightSource | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const PointLight &rhs) | PointLight |
nvsg::LightSource::operator=(const LightSource &rhs) | LightSource | [protected]
nvsg::OwnedObject< GroupHandle >::operator=(const OwnedObject< GroupHandle > &rhs) | OwnedObject< GroupHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< GroupHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< GroupHandle > | [protected]
OwnedObject(const OwnedObject< GroupHandle > &rhs) | OwnedObject< GroupHandle > | [protected]
OwnerIterator typedef | OwnedObject< GroupHandle > | [protected]
ownersBegin() const | OwnedObject< GroupHandle > | [inline, protected]
ownersBegin() | OwnedObject< GroupHandle > | [inline, protected]
ownersEnd() const | OwnedObject< GroupHandle > | [inline, protected]
ownersEnd() | OwnedObject< GroupHandle > | [inline, protected]
PointLight() | PointLight |
PointLight(const LightSource &rhs) | PointLight | [explicit]
PointLight(const PointLight &rhs) | PointLight |
removeOwner(typename GroupHandle::ObjectType *obj) | OwnedObject< GroupHandle > | [protected]
setAmbientColor(const nvmath::Vec3f &color) | LightSource | [inline]
setAnimation(TrafoAnimationHandle *animation) | LightSource |
setAnnotation(const std::string &anno) | Object |
setAttenuation(float c, float l, float q) | PointLight | [inline]
setAttenuation(const nvmath::Vec3f &attenuation) | PointLight | [inline]
setDiffuseColor(const nvmath::Vec3f &color) | LightSource | [inline]
setEnabled(bool enable) | LightSource | [inline]
setIntensity(float intensity) | LightSource | [inline]
setName(const std::string &name) | Object |
setPosition(const nvmath::Vec3f &position) | PointLight |
setShadowCasting(bool cast) | LightSource | [inline]
setSpecularColor(const nvmath::Vec3f &color) | LightSource | [inline]
setUserData(const void *userData) | Object | [inline]
validateIncarnation() const | LightSource | [virtual]
~LightSource() | LightSource | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< GroupHandle > | [protected]
~PointLight() | PointLight | [virtual]
Generated on Tue Jan 15 10:29:13 2008 for NVSGSDK by NVIDIA


Points Class Reference

IndependentPrimitiveSet for points. More...

#include <Points.h>

Inheritance diagram for Points:

[legend]
Collaboration diagram for Points:

[legend]
List of all members.

Public Member Functions

NVSG_API | Points ()
Default-constructs a Points.

NVSG_API | Points (const IndependentPrimitiveSet &rhs)
Constructs a Points from an IndependentPrimitiveSet.

NVSG_API | Points (const PrimitiveSet &rhs)
Constructs a Points from a PrimitiveSet.

NVSG_API | Points (const Points &rhs)
Constructs a Points as a copy from another Points.

virtual NVSG_API | ~Points ()
Destructs a Points.

NVSG_API Points & | operator= (const Points &rhs)
Assignment operator.

Detailed Description

IndependentPrimitiveSet for points.

Namespace: nvsg
Remarks:
A Points is an IndependentPrimitiveSet that holds an array of indices. Each of these indices describes a point with the index pointing in the array of vertices. All vertex attributes (like normal, texture,...) are indexed with the same index.
See also:
IndependentPrimitiveSet, Lines, Quads, Triangles

Constructor & Destructor Documentation

NVSG_API Points ( )

Default-constructs a Points.

NVSG_API Points ( const IndependentPrimitiveSet & rhs ) [explicit]

Constructs a Points from an IndependentPrimitiveSet.

NVSG_API Points ( const PrimitiveSet & rhs ) [explicit]

Constructs a Points from a PrimitiveSet.

NVSG_API Points ( const Points & rhs )

Constructs a Points as a copy from another Points.

virtual NVSG_API ~Points ( ) [virtual]

Destructs a Points.

Member Function Documentation

NVSG_API Points& operator= ( const Points & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant Points to copy from.
Returns:
A reference to the assigned Points.
Remarks:
The assignment operator calls the assignment operator of IndependentPrimitiveSet.

The documentation for this class was generated from the following file:
  • Points.h
Generated on Tue Jan 15 10:29:14 2008 for NVSGSDK by NVIDIA


Member List

Points Member List

This is the complete list of members for Points, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | IndependentPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getName() const | Object |
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Points &rhs) | Points |
nvsg::IndependentPrimitiveSet::operator=(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
Points() | Points |
Points(const IndependentPrimitiveSet &rhs) | Points | [explicit]
Points(const PrimitiveSet &rhs) | Points | [explicit]
Points(const Points &rhs) | Points |
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setIndices(const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setIndices(unsigned int pos, const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~Points() | Points | [virtual]
~PrimitiveSet() | PrimitiveSet | [virtual]
Generated on Tue Jan 15 10:29:14 2008 for NVSGSDK by NVIDIA


PrimitiveAttribute Class Reference

Base class for all primitive related StateAttribute classes. More...

#include <PrimitiveAttribute.h>

Inheritance diagram for PrimitiveAttribute:

[legend]
Collaboration diagram for PrimitiveAttribute:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~PrimitiveAttribute ()
Destructs a PrimitiveAttribute.

Protected Member Functions

NVSG_API | PrimitiveAttribute ()
Protected default constructor to prevent explicit creation.

NVSG_API | PrimitiveAttribute (const PrimitiveAttribute &rhs)
Protected copy constructor to prevent explicit creation.

NVSG_API PrimitiveAttribute & | operator= (const PrimitiveAttribute &rhs)
Assignment operator.

Detailed Description

Base class for all primitive related StateAttribute classes.

Namespace: nvsg
Remarks:
For each primitive type like points, lines, or faces, there is one specific PrimitiveAttribute, like PointAttribute, LineAttribute, and FaceAttribute. The different kinds of PrimitiveAttributes do not interfere.
See also:
FaceAttribute, LineAttribute, PointAttribute, StateAttribute

Constructor & Destructor Documentation

virtual NVSG_API ~PrimitiveAttribute ( ) [virtual]

Destructs a PrimitiveAttribute.

NVSG_API PrimitiveAttribute ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This default constructor is accessible only by derived classes.

NVSG_API PrimitiveAttribute ( const PrimitiveAttribute & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveAttribute to copy from
Remarks:
This copy constructor is accessible only by derived classes.

Member Function Documentation

NVSG_API PrimitiveAttribute& operator= ( const PrimitiveAttribute & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant PrimitiveAttribute to copy from.
Returns:
A reference to the assigned PrimitiveAttribute.
Remarks:
This assignment operator is accessible only by derived classes. It calls the assignment operator of StateAttibute.

The documentation for this class was generated from the following file:
  • PrimitiveAttribute.h
Generated on Tue Jan 15 10:29:14 2008 for NVSGSDK by NVIDIA


Member List

PrimitiveAttribute Member List

This is the complete list of members for PrimitiveAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isTransparent(void) const | StateAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
PrimitiveAttribute() | PrimitiveAttribute | [protected]
PrimitiveAttribute(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~PrimitiveAttribute() | PrimitiveAttribute | [virtual]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:14 2008 for NVSGSDK by NVIDIA


PrimitiveSet Class Reference

Base class for Drawable objects holding a VertexAttributeSet. More...

#include <PrimitiveSet.h>

Inheritance diagram for PrimitiveSet:

[legend]
Collaboration diagram for PrimitiveSet:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~PrimitiveSet ()
Destructs a PrimitiveSet.

NVSG_API VertexAttributeSetHandle * | getVertexAttributeSet () const
Get a pointer to the constant VertexAttributeSet.

NVSG_API void | setVertexAttributeSet (VertexAttributeSetHandle *vash)
Set the VertexAttributeSet.

NVSG_API SkinHandle * | getSkin () const
Get the Skin of this PrimitiveSet.

NVSG_API void | setSkin (SkinHandle *skin)
Set the Skin of this PrimitiveSet.

NVSG_API bool | isCompatible (const PrimitiveSet *p) const
Test for compatibility with an other PrimitiveSet.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other PrimitiveSet.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

NVSG_API void | invalidateAnimationContainment ()
Invalidate the containment of an animation.

virtual NVSG_API bool | containsAnimation () const
Interface to determine if an Object contains an animation.

Protected Member Functions

NVSG_API | PrimitiveSet ()
Protected default constructor to prevent explicit creation.

NVSG_API | PrimitiveSet (const PrimitiveSet &rhs)
Protected copy constructor to prevent explicit creation.

NVSG_API PrimitiveSet & | operator= (const PrimitiveSet &rhs)
Assignment operator.

Detailed Description

Base class for Drawable objects holding a VertexAttributeSet.

Namespace: nvsg
Remarks:
This class provides the common interface for Drawable object with a VertexAttributeSet, like IndependentPrimitiveSet or StrippedPrimitiveSet.
See also:
Drawable, IndependentPrimitiveSet, StrippedPrimitiveSet, VertexAttributeSet

Constructor & Destructor Documentation

virtual NVSG_API ~PrimitiveSet ( ) [virtual]

Destructs a PrimitiveSet.

NVSG_API PrimitiveSet ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This default constructor is accessible only by derived classes. By default, it holds no VertexAttributeSet.

NVSG_API PrimitiveSet ( const PrimitiveSet & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveSet to copy from
Remarks:
This copy constructor is accessible only by derived classes. The new PrimitiveSet holds a copy of the VertexAttributeSet of rhs.

Member Function Documentation

VertexAttributeSetHandle * getVertexAttributeSet ( ) const [inline]

Get a pointer to the constant VertexAttributeSet.

Returns:
A pointer to the constant VertexAttributeSet.
See also:
VertexAttributeSet

NVSG_API void setVertexAttributeSet ( VertexAttributeSetHandle * vash )

Set the VertexAttributeSet.

Parameters:
vash A pointer to the constant VertexAttributeSet.
Remarks:
The reference count of set is incremented, while the reference count of any previous VertexAttributeSet is decremented.
See also:
VertexAttributeSet

SkinHandle * getSkin ( ) const [inline]

Get the Skin of this PrimitiveSet.

Returns:
A pointer to the SkinHandle of this PrimitiveSet, if there is one, or NULL.
Remarks:
If a PrimitiveSet holds a Skin, the associated VertexAttributeSet is skinned using that Skin object.
See also:
setSkin, getSkinnedVertexAttributeSet, getVertexAttributeSet

NVSG_API void setSkin ( SkinHandle * skin )

Set the Skin of this PrimitiveSet.

Parameters:
skin A pointer to the SkinHandle to set. Can be NULL.
Remarks:
If a PrimitiveSet holds a Skin, the associated VertexAttributeSet is skinned using that Skin object.
See also:
getSkin, getVertexAttributeSet

NVSG_API bool isCompatible ( const PrimitiveSet * p ) const

Test for compatibility with an other PrimitiveSet.

Parameters:
p A pointer to the constant PrimitiveSet to test for compatibility with.
Returns:
true if the PrimitiveSet p is compatible with this, otherwise false.
Remarks:
p and this are compatible, if their VertexAttributeSets are compatible.
Note:
The behavior is undefined if p is not a PrimitiveSet nor derived from one.
See also:
Drawable, VertexAttributeSet

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other PrimitiveSet.

Parameters:
p | A reference to the constant PrimitiveSet to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the PrimitiveSet p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Drawable, they are equivalent if the VertexAttributeSet objects are equivalent. If deepCompare is true, a full equivalence test is performed on the VertexAttributeSet objects, otherwise they are considered to be equivalent if the pointers are equal.
Note:
The behavior is undefined if p is not a PrimitiveSet nor derived from one.
See also:
Drawable, VertexAttributeSet

Reimplemented from Object.

Reimplemented in IndependentPrimitiveSet, MeshedPrimitiveSet, SkinnedTriangles, and StrippedPrimitiveSet.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and it is marked as invalid. Then it is validated and the Incarnation of its VertexAttributeSet is requested to continue validation down the tree hierarchy.
See also:
nvutil::Incarnation, VertexAttributeSet

Reimplemented from Drawable.

Reimplemented in SkinnedTriangles.

NVSG_API void invalidateAnimationContainment ( )

Invalidate the containment of an animation.

Remarks:
The animation containment of all the owners is invalidated.

Reimplemented from Drawable.

virtual NVSG_API bool containsAnimation ( ) const [virtual]

Interface to determine if an Object contains an animation.

Returns:
true if the VertexAttributeSet of this PrimitiveSet contains an animation, otherwise false.

Reimplemented from Drawable.

Reimplemented in SkinnedTriangles.

NVSG_API PrimitiveSet& operator= ( const PrimitiveSet & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant PrimitiveSet to copy from.
Returns:
A reference to the assigned PrimitiveSet.
Remarks:
This assignment operator is accessible only by derived classes. It calls the assignment operator of PrimitiveSet.

The documentation for this class was generated from the following file:
  • PrimitiveSet.h
Generated on Tue Jan 15 10:29:14 2008 for NVSGSDK by NVIDIA


Member List

PrimitiveSet Member List

This is the complete list of members for PrimitiveSet, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const=0 | Drawable | [protected, pure virtual]
calculateBoundingSphere() const=0 | Drawable | [protected, pure virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | PrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
Generated on Tue Jan 15 10:29:14 2008 for NVSGSDK by NVIDIA


ProblemInfo Class Reference

Class that holds the problem information. More...

#include <ProblemLog.h>

List of all members.

Public Member Functions

ProblemInfo (const char *problem, bool isCritical, const char *missingFeatures)
Constructor to construct a valid problem info.

Public Attributes

std::string | m_problem
catchword

bool | m_isCritical
severity

std::string | m_missingFeatures
explanation

Detailed Description

Class that holds the problem information.

This class holds the problem information that is logged in the ProblemLog class.

Constructor & Destructor Documentation

ProblemInfo | ( | const char * | problem,
 |  | bool | isCritical,
 |  | const char * | missingFeatures
 | ) | [inline]

Constructor to construct a valid problem info.

Parameters:
problem | Catchword, like the name of a missing extension
isCritical | Yes means critical problem
missingFeatures | Longer description on what feature(s) will be missing

Member Data Documentation

std::string m_problem

catchword

bool m_isCritical

severity

std::string m_missingFeatures

explanation

The documentation for this class was generated from the following file:
  • ProblemLog.h
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


Member List

ProblemInfo Member List

This is the complete list of members for ProblemInfo, including all inherited members.
m_isCritical | ProblemInfo |
m_missingFeatures | ProblemInfo |
m_problem | ProblemInfo |
ProblemInfo(const char *problem, bool isCritical, const char *missingFeatures) | ProblemInfo | [inline]
~ProblemInfo() (defined in ProblemInfo) | ProblemInfo | [inline]
Generated on Tue Jan 15 10:29:47 2008 for NVSGSDK by NVIDIA


QuadMeshes Class Reference

MeshedPrimitiveSet for quad meshes. More...

#include <QuadMeshes.h>

Inheritance diagram for QuadMeshes:

[legend]
Collaboration diagram for QuadMeshes:

[legend]
List of all members.

Public Member Functions

NVSG_API | QuadMeshes ()
Default-constructs a QuadMeshes.

NVSG_API | QuadMeshes (const MeshedPrimitiveSet &rhs)
Constructs a QuadMeshes from a MeshedPrimitiveSet.

NVSG_API | QuadMeshes (const QuadMeshes &rhs)
Copy-Constructs a QuadMeshes from another QuadMeshes.

virtual NVSG_API | ~QuadMeshes ()
Destructs a QuadMeshes.

NVSG_API QuadMeshes & | operator= (const QuadMeshes &rhs)
Assignment operator.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (QuadMeshes *qm, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2)
Generate tangents and binormals for a QuadMeshes.

NVSG_API void | generateNormals (QuadMeshes *qm)
Generate normals for a QuadMeshes.

Detailed Description

MeshedPrimitiveSet for quad meshes.

Namespace: nvsg
Remarks:
A QuadMeshes is a MeshedPrimitiveSet that interprets the vertex attributes and the vector of IndexMesh objects of a MeshedPrimitiveSet as a mesh of quads.
See also:
IndependentPrimitiveSet, StrippedPrimitiveSet

Constructor & Destructor Documentation

NVSG_API QuadMeshes ( )

Default-constructs a QuadMeshes.

Remarks:
After instantiation the QuadMeshes initially is empty.

NVSG_API QuadMeshes ( const MeshedPrimitiveSet & rhs )

Constructs a QuadMeshes from a MeshedPrimitiveSet.

Parameters:
rhs Source MeshedPrimitiveSet.
Remarks:
After instantiation the QuadMeshes initially is empty.

NVSG_API QuadMeshes ( const QuadMeshes & rhs )

Copy-Constructs a QuadMeshes from another QuadMeshes.

Parameters:
rhs Source QuadMeshes.

virtual NVSG_API ~QuadMeshes ( ) [virtual]

Destructs a QuadMeshes.

Member Function Documentation

NVSG_API QuadMeshes& operator= ( const QuadMeshes & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant QuadMeshes to copy from.
Returns:
A reference to the assigned QuadMeshes.
Remarks:
The assignment operator calls the assignment operator of MeshedPrimitiveSet.

Friends And Related Function Documentation

NVSG_API void calculateTangentSpace | ( | QuadMeshes * | qm,
 |  | unsigned int | tu = 0,
 |  | unsigned int | tg = 1,
 |  | unsigned int | bn = 2
 | ) | [related]

Generate tangents and binormals for a QuadMeshes.

Parameters:
qm | A pointer to the constant QuadMeshes to create tangents and binormals for.
tu | The optional texture unit that holds texture coordinates to use, default is 0.
tg | The optional texture unit that is going to hold the tangents, default is 1.
bn | The optional texture unit that is going to hold the binormals, default is 2.
Remarks:
This routine calculates tangents and binormals for every vertex in the QuadMeshes qm. The tangent points along the second component of the texture parameterization. The binormal is calculated by the cross product of the normal and the tangent at that vertex.
Note:
The behavior is undefined if the QuadMeshes has no normals.

NVSG_API void generateNormals ( QuadMeshes * qm ) [related]

Generate normals for a QuadMeshes.

Parameters:
qm A pointer to the constant QuadMeshes to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • QuadMeshes.h
Generated on Tue Jan 15 10:29:15 2008 for NVSGSDK by NVIDIA


Member List

QuadMeshes Member List

This is the complete list of members for QuadMeshes, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | MeshedPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | MeshedPrimitiveSet | [protected, virtual]
calculateTangentSpace(QuadMeshes *qm, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2) | QuadMeshes | [related]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
generateNormals(QuadMeshes *qm) | QuadMeshes | [related]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | MeshedPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getMeshes() const | MeshedPrimitiveSet | [inline]
getName() const | Object |
getNumberOfMeshes() const | MeshedPrimitiveSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasMeshes() const | MeshedPrimitiveSet | [inline]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | MeshedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | MeshedPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
MeshedPrimitiveSet() | MeshedPrimitiveSet |
MeshedPrimitiveSet(const MeshedPrimitiveSet &rhs) | MeshedPrimitiveSet | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const QuadMeshes &rhs) | QuadMeshes |
nvsg::MeshedPrimitiveSet::operator=(const MeshedPrimitiveSet &rhs) | MeshedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
QuadMeshes() | QuadMeshes |
QuadMeshes(const MeshedPrimitiveSet &rhs) | QuadMeshes |
QuadMeshes(const QuadMeshes &rhs) | QuadMeshes |
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setMeshes(const IndexMesh *meshes, unsigned int numMeshes) | MeshedPrimitiveSet |
setMeshes(unsigned int pos, const IndexMesh *meshes, unsigned int numMeshes) | MeshedPrimitiveSet |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~MeshedPrimitiveSet() | MeshedPrimitiveSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~QuadMeshes() | QuadMeshes | [virtual]
Generated on Tue Jan 15 10:29:15 2008 for NVSGSDK by NVIDIA


Quads Class Reference

IndependentPrimitiveSet for quads. More...

#include <Quads.h>

Inheritance diagram for Quads:

[legend]
Collaboration diagram for Quads:

[legend]
List of all members.

Public Member Functions

NVSG_API | Quads ()
Default-constructs a Quads.

NVSG_API | Quads (const PrimitiveSet &rhs)
Constructs a Quads from a PrimitiveSet.

NVSG_API | Quads (const IndependentPrimitiveSet &rhs)
Constructs a Quads from an IndependentPrimitiveSet.

NVSG_API | Quads (const Quads &rhs)
Constructs a Quads as a copy from another Quads.

virtual NVSG_API | ~Quads ()
Destructs a Quads.

NVSG_API bool | hasFaces () const
Query if this Quads has faces.

NVSG_API unsigned int | getNumberOfFaces () const
Get the number of quadrangular faces.

NVSG_API const Face4 * | getFaces () const
Get a pointer to the faces.

NVSG_API void | setFaces (const Face4 *faces, unsigned int numFaces)
Set the faces of this Quads.

NVSG_API void | setFaces (unsigned int pos, const Face4 *faces, unsigned int numFaces)
Set a subset of faces of this Quads.

NVSG_API Quads & | operator= (const Quads &rhs)
Assignment operator.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (Quads *q, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2)
Generate tangents and binormals for a Quads.

NVSG_API void | generateNormals (Quads *q)
Generate normals for a Quads.

Detailed Description

IndependentPrimitiveSet for quads.

Namespace: nvsg
Remarks:
A Quads is an IndependentPrimitiveSet that holds an array of index-quadruples. Each of these quadruples describe a quad with the indices pointing in the array of vertices. All vertex attributes (such as normal, texture,...) are indexed with the same index.
See also:
IndependentPrimitiveSet, Points, Lines, Triangles

Constructor & Destructor Documentation

NVSG_API Quads ( )

Default-constructs a Quads.

NVSG_API Quads ( const PrimitiveSet & rhs )

Constructs a Quads from a PrimitiveSet.

NVSG_API Quads ( const IndependentPrimitiveSet & rhs )

Constructs a Quads from an IndependentPrimitiveSet.

NVSG_API Quads ( const Quads & rhs )

Constructs a Quads as a copy from another Quads.

virtual NVSG_API ~Quads ( ) [virtual]

Destructs a Quads.

Member Function Documentation

bool hasFaces ( ) const [inline]

Query if this Quads has faces.

Returns:
true, if this Quads has at least four indices, otherwise false.
Remarks:
Each quadruple of successive indices represent one quadrangular face.
See also:
getNumberOfFaces, getFaces, setFaces

unsigned int getNumberOfFaces ( ) const [inline]

Get the number of quadrangular faces.

Returns:
The number of indices of this Quads divided by four.
Remarks:
Each quadruple of successive indices represent one quadrangular face.
See also:
hasFaces, getFaces, setFaces

const Face4 * getFaces ( ) const [inline]

Get a pointer to the faces.

Returns:
A pointer to the constant indices of this IndependentPrimitiveSet.
Remarks:
Each quadruple of successive indices represent one quadrangular face.
See also:
hasFaces, getNumberOfFaces, setFaces

void setFaces | ( | const Face4 * | faces,
 |  | unsigned int | numFaces
 | ) | [inline]

Set the faces of this Quads.

Parameters:
faces | A pointer to the constant faces to use.
numFaces | The number of faces, with four indices per face.
Remarks:
Copies four times numFaces indices from faces into this Quads by just calling the appropriate setIndices.
Note:
The behavior is undefined if there are less than numFaces values of type nvsg::Face4 located at faces.
See also:
hasFaces, getNumberOfFaces, getFaces

void setFaces | ( | unsigned int | pos,
 |  | const Face4 * | faces,
 |  | unsigned int | numFaces
 | ) | [inline]

Set a subset of faces of this Quads.

Parameters:
pos | The start position inside the range of pre-existing faces.
faces | A pointer to the constant faces to use.
numFaces | The number of faces.
Remarks:
Copies four times numFaces indices from faces into this Quads, starting at position four times pos inside the range of pre-existing indices.
Pre-existing indices in the range [4*pos, 4*(pos + numFaces)) will be replaced. Pre-existing indices outside this range remain untouched.
If you specifiy (-1) for pos or pos specifies the number of faces currently stored, the faces pointed to by faces will be appended to the pre-existing faces.
Note:
The behavior is undefined if pos is neither a valid position inside the range of pre-existing faces, nor the number of faces currently stored, nor (-1).

The behavior is undefined if there are less than numFaces values of type Face4 located at segments.

See also:
hasFaces, getNumberOfFaces, getFaces

NVSG_API Quads& operator= ( const Quads & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant Quads to copy from.
Returns:
A reference to the assigned Quads.
Remarks:
The assignment operator calls the assignment operator of IndependentPrimitiveSet.

Friends And Related Function Documentation

NVSG_API void calculateTangentSpace | ( | Quads * | q,
 |  | unsigned int | tu = 0,
 |  | unsigned int | tg = 1,
 |  | unsigned int | bn = 2
 | ) | [related]

Generate tangents and binormals for a Quads.

Parameters:
q | A pointer to the constant Quads to create tangents and binormals for.
tu | The optional texture unit that holds texture coordinates to use; default is 0.
tg | The optional texture unit that is going to hold the tangents; default is 1.
bn | The optional texture unit that is going to hold the binormals; default is 2.
Remarks:
This routine calculates tangents and binormals for every vertex in the Quads q. The tangent points along the second component of the texture parameterization. The binormal is calculated by the cross product of the normal and the tangent at that vertex.

NVSG_API void generateNormals ( Quads * q ) [related]

Generate normals for a Quads.

Parameters:
q A pointer to the constant Quads to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • Quads.h
Generated on Tue Jan 15 10:29:15 2008 for NVSGSDK by NVIDIA


Member List

Quads Member List

This is the complete list of members for Quads, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | IndependentPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
calculateTangentSpace(Quads *q, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2) | Quads | [related]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
generateNormals(Quads *q) | Quads | [related]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getFaces() const | Quads | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getName() const | Object |
getNumberOfFaces() const | Quads | [inline]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasFaces() const | Quads | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Quads &rhs) | Quads |
nvsg::IndependentPrimitiveSet::operator=(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
Quads() | Quads |
Quads(const PrimitiveSet &rhs) | Quads |
Quads(const IndependentPrimitiveSet &rhs) | Quads |
Quads(const Quads &rhs) | Quads |
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setFaces(const Face4 *faces, unsigned int numFaces) | Quads | [inline]
setFaces(unsigned int pos, const Face4 *faces, unsigned int numFaces) | Quads | [inline]
setIndices(const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setIndices(unsigned int pos, const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~Quads() | Quads | [virtual]
Generated on Tue Jan 15 10:29:15 2008 for NVSGSDK by NVIDIA


QuadStrips Class Reference

StrippedPrimitiveSet for quad strips. More...

#include <QuadStrips.h>

Inheritance diagram for QuadStrips:

[legend]
Collaboration diagram for QuadStrips:

[legend]
List of all members.

Public Member Functions

NVSG_API | QuadStrips ()
Default-constructs a QuadStrips.

NVSG_API | QuadStrips (const StrippedPrimitiveSet &rhs)
Constructs a QuadStrips from a StrippedPrimitiveSet.

NVSG_API | QuadStrips (const QuadStrips &rhs)
Constructs a QuadStrips as a copy from another QuadStrips.

virtual NVSG_API | ~QuadStrips ()
Destructs a QuadStrips.

NVSG_API QuadStrips & | operator= (const QuadStrips &rhs)
Assignment operator.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (QuadStrips *qs, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2)
Generate tangents and binormals for a QuadStrips.

NVSG_API void | generateNormals (QuadStrips *q)
Generate normals for a QuadStrips.

Detailed Description

StrippedPrimitiveSet for quad strips.

Namespace: nvsg
Remarks:
A QuadStrips is a StrippedPrimitiveSet that represents the vertex attributes of the StrippedPrimitiveSet as quad strips.
Example
If you have an array of eight vertices in the StrippedPrimitiveSet, one possible method for making them a cube is to define three IndexSet elements as follows:
    set[0] = { 0, 1, 2, 3, 4, 5, 6, 7, 0, 1 };
    set[1] = { 1, 7, 3, 5 };
    set[2] = { 6, 0, 4, 2 };
The ordering ensures that the quads are all drawn with the same orientation so that the quad strip correctly forms part of a surface. Preserving the orientation is important for some operations, such as culling. The number of vertices per IndexSet must be at least 4 for anything to be drawn.
See also:
LineStrips, StrippedPrimitiveSet, TriangleStrips

Constructor & Destructor Documentation

NVSG_API QuadStrips ( )

Default-constructs a QuadStrips.

NVSG_API QuadStrips ( const StrippedPrimitiveSet & rhs ) [explicit]

Constructs a QuadStrips from a StrippedPrimitiveSet.

NVSG_API QuadStrips ( const QuadStrips & rhs ) [explicit]

Constructs a QuadStrips as a copy from another QuadStrips.

virtual NVSG_API ~QuadStrips ( ) [virtual]

Destructs a QuadStrips.

Member Function Documentation

NVSG_API QuadStrips& operator= ( const QuadStrips & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant QuadStrips to copy from.
Returns:
A reference to the assigned QuadStrips.
Remarks:
The assignment operator calls the assignment operator of StrippedPrimitiveSet.

Friends And Related Function Documentation

NVSG_API void calculateTangentSpace | ( | QuadStrips * | qs,
 |  | unsigned int | tu = 0,
 |  | unsigned int | tg = 1,
 |  | unsigned int | bn = 2
 | ) | [related]

Generate tangents and binormals for a QuadStrips.

Parameters:
qs | A pointer to the QuadStrips to create tangents and binormals for.
tu | The optional texture unit that holds texture coordinates to use, default is 0.
tg | The optional texture unit that is going to hold the tangents; default is 1.
bn | The optional texture unit that is going to hold the binormals; default is 2.
Remarks:
This routine calculates tangents and binormals for every vertex in the QuadStrips qs. The tangent points along the second component of the texture parameterization. The binormal is calculated by the cross product of the normal and the tangent at that vertex.

NVSG_API void generateNormals ( QuadStrips * q ) [related]

Generate normals for a QuadStrips.

Parameters:
q A pointer to the QuadStrips to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • QuadStrips.h
Generated on Tue Jan 15 10:29:15 2008 for NVSGSDK by NVIDIA


Member List

QuadStrips Member List

This is the complete list of members for QuadStrips, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | StrippedPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | StrippedPrimitiveSet | [protected, virtual]
calculateTangentSpace(QuadStrips *qs, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2) | QuadStrips | [related]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
generateNormals(QuadStrips *q) | QuadStrips | [related]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const QuadStrips &rhs) | QuadStrips |
nvsg::StrippedPrimitiveSet::operator=(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
QuadStrips() | QuadStrips |
QuadStrips(const StrippedPrimitiveSet &rhs) | QuadStrips | [explicit]
QuadStrips(const QuadStrips &rhs) | QuadStrips | [explicit]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setStrips(const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setStrips(unsigned int pos, const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~QuadStrips() | QuadStrips | [virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [virtual]
Generated on Tue Jan 15 10:29:15 2008 for NVSGSDK by NVIDIA


TemplateQuatt class Reference

Quatt Class Template Reference

Quaternion class. More...

#include <Quatt.h>

Inheritance diagram for Quatt:

[legend]
Collaboration diagram for Quatt:

[legend]
List of all members.

Public Member Functions

Quatt ()
Default constructor.

Quatt (T x, T y, T z, T w)
Constructor using four scalar values.

Quatt (const Vecnt< 4, T > &v)
Constructor using a Vecnt<4,T>.

template<typename S> | Quatt (const Quatt< S > &q)
Copy constructor using a Quaternion of possibly different type.

Quatt (const Vecnt< 3, T > &axis, T angle)
Constructor using an axis and an angle.

Quatt (const Vecnt< 3, T > &v0, const Vecnt< 3, T > &v1)
Constructor by two vectors.

Quatt (const Matnnt< 3, T > &rot)
Constructor by a rotation matrix.

Quatt< T > & | normalize ()
Normalize the quaternion.

template<typename S> T & | operator[] (S i)
Non-constant subscript operator.

template<typename S> const T & | operator[] (S i) const
Constant subscript operator.

template<typename S> Quatt< T > & | operator= (const Quatt< S > &q)
Quaternion assignment operator from a Quaternion of possibly different type.

Quatt< T > & | operator *= (const Quatt< T > &q)
Quaternion multiplication with a quaternion and assignment operator.

Quatt< T > & | operator/= (const Quatt< T > &q)
Quaternion division by a quaternion and assignment operator.

Detailed Description

template<typename T>
class nvmath::Quatt< T >

Quaternion class.

Remarks:
Quaternions are an alternative to the 3x3 matrices that are typically used for 3-D rotations. A unit quaternion represents an axis in 3-D space and a rotation around that axis. Every rotation can be expressed that way. There are typedefs for the most common usage with float and double: Quatf, Quatd.
Note:
Only unit quaternions represent a rotation.

Constructor & Destructor Documentation

Quatt ( ) [inline]

Default constructor.

Remarks:
For performance reasons no initialization is performed.

Quatt | ( | T | x,
 |  | T | y,
 |  | T | z,
 |  | T | w
 | ) | [inline]

Constructor using four scalar values.

Parameters:
x | X-component of the quaternion.
y | Y-component of the quaternion.
z | Z-component of the quaternion.
w | W-component of the quaternion.
Note:
x, y, and z are not the x,y,z-component of the rotation axis, and w is not the rotation angle. If you have such values handy, use the constructor that takes the axis as a Vecnt<3,T> and an angle.

Quatt ( const Vecnt< 4, T > & v ) [inline, explicit]

Constructor using a Vecnt<4,T>.

Parameters:
v Vector to construct the quaternion from.
Remarks:
The four values of v are just copied over to the quaternion. It is assumed that this operation gives a normalized quaternion.

Quatt ( const Quatt< S > & q ) [inline, explicit]

Copy constructor using a Quaternion of possibly different type.

Parameters:
q The quaternion to copy.

Quatt | ( | const Vecnt< 3, T > & | axis,
 |  | T | angle
 | ) | [inline]

Constructor using an axis and an angle.

Parameters:
axis | Axis to rotate around.
angle | Angle in radians to rotate.
Remarks:
The resulting quaternion represents a rotation by angle (in radians) around axis.

Quatt | ( | const Vecnt< 3, T > & | v0,
 |  | const Vecnt< 3, T > & | v1
 | ) | [inline]

Constructor by two vectors.

Parameters:
v0 | Start vector.
v1 | End vector.
Remarks:
The resulting quaternion represents the rotation that maps vec0 to vec1.

Quatt ( const Matnnt< 3, T > & rot ) [inline, explicit]

Constructor by a rotation matrix.

Parameters:
rot The rotation matrix to convert to a unit quaternion.
Remarks:
The resulting quaternion represents the same rotation as the matrix.

Member Function Documentation

Quatt< T > & normalize ( ) [inline]

Normalize the quaternion.

Returns:
A reference to this, as the normalized quaternion.
Remarks:
It is always assumed, that a quaternion is normalized. But when getting data from outside or due to numerically instabilities, a quaternion might become unnormalized. You can use this function then to normalize it again.

T & operator[] ( S i ) [inline]

Non-constant subscript operator.

Parameters:
i Index to the element to use (i=0,1,2,3).
Returns:
A reference to the i th element of the quaternion.

const T & operator[] ( S i ) const [inline]

Constant subscript operator.

Parameters:
i Index to the element to use (i=0,1,2,3).
Returns:
A reference to the constant i th element of the quaternion.

Quatt< T > & operator= ( const Quatt< S > & q ) [inline]

Quaternion assignment operator from a Quaternion of possibly different type.

Parameters:
q The quaternion to assign.
Returns:
A reference to this, as the assigned Quaternion from q.

Quatt< T > & operator *= ( const Quatt< T > & q ) [inline]

Quaternion multiplication with a quaternion and assignment operator.

Parameters:
q A Quaternion to multiply with.
Returns:
A reference to this, as the product (or concatenation) of this and q.
Remarks:
Multiplying two quaternions give a quaternion that represents the concatenation of the rotations represented by the two quaternions.

Quatt< T > & operator/= ( const Quatt< T > & q ) [inline]

Quaternion division by a quaternion and assignment operator.

Parameters:
q A Quaternion to divide by.
Returns:
A reference to this, as the division of this by q.
Remarks:
Dividing a quaternion by an other gives a quaternion that represents the concatenation of the rotation represented by the numerator quaternion and the rotation represented by the conjugated denumerator quaternion.

The documentation for this class was generated from the following file:
  • Quatt.h
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


Member List

Quatt Member List

This is the complete list of members for Quatt, including all inherited members.
normalize() | Quatt | [inline]
operator *=(const Quatt< T > &q) | Quatt | [inline]
operator/=(const Quatt< T > &q) | Quatt | [inline]
operator=(const Quatt< S > &q) | Quatt | [inline]
operator[](S i) | Quatt | [inline]
operator[](S i) const | Quatt | [inline]
Quatt() | Quatt | [inline]
Quatt(T x, T y, T z, T w) | Quatt | [inline]
Quatt(const Vecnt< 4, T > &v) | Quatt | [inline, explicit]
Quatt(const Quatt< S > &q) | Quatt | [inline, explicit]
Quatt(const Vecnt< 3, T > &axis, T angle) | Quatt | [inline]
Quatt(const Vecnt< 3, T > &v0, const Vecnt< 3, T > &v1) | Quatt | [inline]
Quatt(const Matnnt< 3, T > &rot) | Quatt | [inline, explicit]
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


RayIntersectTraverser Class Reference

RayIntersectTraverser. More...

#include <RayIntersectTraverser.h>

Inheritance diagram for RayIntersectTraverser:

[legend]
Collaboration diagram for RayIntersectTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | RayIntersectTraverser (void)
Default constructor.

NVSG_API void | release ()
Release all resources.

NVSG_API void | setRay (const nvmath::Vec3f &origin, const nvmath::Vec3f &dir)
Set the ray for the intersection test.

NVSG_API void | setCamClipping (bool b)
Enable/disable camera plane clipping.

NVSG_API const Intersection & | getNearest (void) const
Get the nearest intersection.

NVSG_API const Intersection * | getIntersections (void) const
Get intersections.

NVSG_API unsigned int | getNumberOfIntersections (void) const
Get number of intersections.

NVSG_API void | setViewportSize (unsigned int width, unsigned int height)
Set the viewport size for intersection calculations with lines and points.

Protected Types

enum ISType {
_NONE = 0, _BSTANGENT, _BSNEAR, _BSFAR,
_BSNEARFAR
}
Intersection type (bounding sphere). More...

Protected Member Functions

virtual NVSG_API | ~RayIntersectTraverser (void)
Default destructor.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Apply the traverser to the scene.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *gnode)
Handler function for a GeoNode.

virtual NVSG_API void | handleVolumeNode (const nvsg::VolumeNode *vnode)
Handler function for a VolumeNode.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Provide special treatment of an AnimatedTransform node.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Provide special treatment of a Billboard node.

virtual NVSG_API void | handleGroup (const nvsg::Group *group)
Handler function for a Group.

virtual NVSG_API void | handleLOD (const nvsg::LOD *lod)
Handler function for an LOD.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *swtch)
Handler function for a Switch.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Provide special treatment of a Transform node.

virtual NVSG_API void | handleLines (const nvsg::Lines *lines)
Handler function for a Lines.

virtual NVSG_API void | handleLineStrips (const nvsg::LineStrips *strips)
Handler function for a LineStrips.

virtual NVSG_API void | handlePoints (const nvsg::Points *points)
Handler function for a Points.

virtual NVSG_API void | handleQuadMeshes (const nvsg::QuadMeshes *meshes)
Handler function for a QuadsMeshes.

virtual NVSG_API void | handleQuads (const nvsg::Quads *quads)
Handler function for a Quads.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *strips)
Handler function for a QuadStrips.

virtual NVSG_API void | handleSkinnedTriangles (const nvsg::SkinnedTriangles *triangles)
Handler function for a SkinnedTriangles.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *triangles)
Handler function for a Triangles.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *fans)
Handler function for a TriFans.

virtual NVSG_API void | handleTriStrips (const nvsg::TriStrips *strips)
Handler function for a TriStrips.

virtual NVSG_API void | handleCgFx (const nvsg::CgFx *p)
Handler function for a CgFx.

virtual NVSG_API void | handleFaceAttribute (const nvsg::FaceAttribute *faceAttrib)
Handler function for a FaceAttribute.

virtual NVSG_API void | handleStateSet (const nvsg::StateSet *stateSet)
Handler function for a StateSet.

virtual NVSG_API bool | preTraverseGroup (const nvsg::Group *p)
Store the active clip planes of p for later usage.

virtual NVSG_API void | postTraverseGroup (const nvsg::Group *p)
Restore the set of active clip planes to the set before entering p.

virtual NVSG_API bool | preTraverseTransform (const nvmath::Trafo *p)
Handles actions to take between transform stack adjustment and traversal.

virtual NVSG_API void | postTraverseTransform (const nvmath::Trafo *p)
Handles stuff to do between traversal and transform stack adjustment.

NVSG_API bool | checkClipPlanes (const nvmath::Vec3f &p)
Test a point against all active clip planes.

NVSG_API bool | checkClipPlanes (const nvmath::Sphere3f &p)
Test a sphere against all active clip planes.

NVSG_API bool | checkIntersection (const nvmath::Sphere3f &sphere)
Check the current ray for intersection with a Sphere3f.

NVSG_API bool | getWorldIntersection (nvmath::Vec3f &isp, float &dist)
Get the intersection point in world coordinates.

NVSG_API bool | intersectBox (const nvmath::Vec3f &p0, const nvmath::Vec3f &p1, nvmath::Vec3f &isp, float &dist)
Intersect with a box.

NVSG_API bool | intersectLine (const nvmath::Vec3f &v0, const nvmath::Vec3f &v1, nvmath::Vec3f &isp, float &dist)
Intersect with line.

NVSG_API bool | intersectPoint (const nvmath::Vec3f &v0, nvmath::Vec3f &isp, float &dist)
Intersect with point.

NVSG_API bool | intersectTriangle (const nvmath::Vec3f &v0, const nvmath::Vec3f &v1, const nvmath::Vec3f &v2, nvmath::Vec3f &isp, float &dist)
Intersect with triangle.

NVSG_API void | storeIntersection (const nvsg::Drawable *p, const nvmath::Vec3f &isp, float dist, unsigned int primitiveIndex, const std::vector< unsigned int > &vertexIndices)
Store the intersection point isp.

NVSG_API void | dumpIntersectionList ()

Detailed Description

RayIntersectTraverser.

A RayIntersectTraverser is a specialized traverser that calculates the intersections of a given ray that passes through the scene.

Note:
If you add new geometry objects classes to NVSG you must also derive from this class and add an operator for this object to handle the intersection calculation.

If you create a special kind of transformation node you also have to take care of the transformation stack in this class.

Needs a valid ViewState. Call setViewState prior to apply().

Member Enumeration Documentation

enum ISType [protected]

Intersection type (bounding sphere).

These are the possible types of intersections between the ray and the boundingsphere of an object in the scene. These types are used for the preintersection calculation with the objects bounding sphere. Regarding the intersection type we can skip objects.

Enumeration values:
_NONE | No intersection.
_BSTANGENT | Tangential intersection.
_BSNEAR | Intersection with the front part of the bounding sphere.
_BSFAR | Intersection with the back part of the bounding sphere.
_BSNEARFAR | Intersection with the front and back part of the bounding sphere.

Constructor & Destructor Documentation

NVSG_API RayIntersectTraverser ( void )

Default constructor.

virtual NVSG_API ~RayIntersectTraverser ( void ) [protected, virtual]

Default destructor.

Member Function Documentation

NVSG_API void release ( )

Release all resources.

By releasing all resources we can use this traverser for the next intersection calculation.

NVSG_API void setRay | ( | const nvmath::Vec3f & | origin,
 |  | const nvmath::Vec3f & | dir
 | ) |

Set the ray for the intersection test.

Sets a world-space ray along which to pick. The ray is defined as a world space origin point and direction vector. The direction vector must be normalized.

Parameters:
origin | World space origin
dir | Direction of the ray - must be normalized!

void setCamClipping ( bool b ) [inline]

Enable/disable camera plane clipping.

Enabling camera plane clipping forces the traverser to calculate only intersections that lie in between the camera's clip planes.

Parameters:
flag true = enable clipping

const Intersection & getNearest ( void ) const [inline]

Get the nearest intersection.

Returns:
The nearest intersection regarding the rays origin.

const Intersection * getIntersections ( void ) const [inline]

Get intersections.

Returns:
All intersections along the ray.

unsigned int getNumberOfIntersections ( void ) const [inline]

Get number of intersections.

Returns:
The number of intersections along the ray.

NVSG_API void setViewportSize | ( | unsigned int | width,
 |  | unsigned int | height
 | ) |

Set the viewport size for intersection calculations with lines and points.

Note:
Both width and height have to be positive.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Apply the traverser to the scene.

Start the intersection calculation of the given ray with the scene objects.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * gnode ) [protected, virtual]

Handler function for a GeoNode.

Parameters:
gnode A pointer to the read-locked GeoNode being traversed.
Remarks:
This function is called from the framework whenever a GeoNode is encountered on traversal. The GeoNode gnode is already read-locked.
The base implementation just calls Traverser::traverseGeoNode().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGeoNode

Reimplemented from SharedTraverser.

virtual NVSG_API void handleVolumeNode ( const nvsg::VolumeNode * vnode ) [protected, virtual]

Handler function for a VolumeNode.

Parameters:
vnode A pointer to the read-locked VolumeNode being traversed.
Remarks:
This function is called from the framework whenever a VolumeNode is encountered on traversal. The VolumeNode vnode is already read-locked.
The base implementation just calls Traverser::traverseVolumeNode().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseVolumeNode

Reimplemented from SharedTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Provide special treatment of an AnimatedTransform node.

An AnimatedTransform is handled as a Transform.

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Provide special treatment of a Billboard node.

On a Billboard the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * group ) [protected, virtual]

Handler function for a Group.

Parameters:
group A pointer to the read-locked Group being traversed.
Remarks:
This function is called from the framework whenever a Group is encountered on traversal. The Group group is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * lod ) [protected, virtual]

Handler function for an LOD.

Parameters:
lod A pointer to the read-locked LOD being traversed.
Remarks:
This function is called from the framework whenever an LOD is encountered on traversal. The LOD lod is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * swtch ) [protected, virtual]

Handler function for a Switch.

Parameters:
swtch A pointer to the read-locked Switch being traversed.
Remarks:
This function is called from the framework whenever a Switch is encountered on traversal. The Switch switch is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Provide special treatment of a Transform node.

On a Transform the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * lines ) [protected, virtual]

Handler function for a Lines.

Parameters:
lines A pointer to the read-locked Lines being traversed.
Remarks:
This function is called from the framework whenever a Lines is encountered on traversal. The Lines lines is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * strips ) [protected, virtual]

Handler function for a LineStrips.

Parameters:
strips A pointer to the read-locked LineStrips being traversed.
Remarks:
This function is called from the framework whenever a LineStrips is encountered on traversal. The LineStrips strips is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * points ) [protected, virtual]

Handler function for a Points.

Parameters:
points A pointer to the read-locked Points being traversed.
Remarks:
This function is called from the framework whenever a Points is encountered on traversal. The Points points is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * meshes ) [protected, virtual]

Handler function for a QuadsMeshes.

Parameters:
meshes A pointer to the read-locked QuadsMeshes being traversed.
Remarks:
This function is called from the framework whenever a QuadsMeshes is encountered on traversal. The QuadsMeshes meshes is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * quads ) [protected, virtual]

Handler function for a Quads.

Parameters:
quads A pointer to the read-locked Quads being traversed.
Remarks:
This function is called from the framework whenever a Quads is encountered on traversal. The Quads quads is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * strips ) [protected, virtual]

Handler function for a QuadStrips.

Parameters:
strips A pointer to the read-locked QuadStrips being traversed.
Remarks:
This function is called from the framework whenever a QuadStrips is encountered on traversal. The QuadStrips strips is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * triangles ) [protected, virtual]

Handler function for a SkinnedTriangles.

Parameters:
triangles A pointer to the read-locked Triangles being traversed.
Remarks:
This function is called from the framework whenever a SkinnedTriangles is encountered on traversal. The SkinnedTriangles triangles is already read-locked.
The base implementation first traverses each TrafoAnimation of each bone of each skin, and then calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * triangles ) [protected, virtual]

Handler function for a Triangles.

Parameters:
triangles A pointer to the read-locked Triangles being traversed.
Remarks:
This function is called from the framework whenever a Triangles is encountered on traversal. The Triangles quads is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * fans ) [protected, virtual]

Handler function for a TriFans.

Parameters:
fans A pointer to the read-locked TriFans being traversed.
Remarks:
This function is called from the framework whenever a TriFans is encountered on traversal. The TriFans fans is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * strips ) [protected, virtual]

Handler function for a TriStrips.

Parameters:
strips A pointer to the read-locked TriStrips being traversed.
Remarks:
This function is called from the framework whenever a TriStrips is encountered on traversal. The TriStrips strips is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from SharedTraverser.

virtual NVSG_API void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Handler function for a CgFx.

Parameters:
cgfx A pointer to the read-locked CgFx being traversed.
Remarks:
This function is called from the framework whenever a CgFx is encountered on traversal. The CgFx cgfx is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFaceAttribute ( const nvsg::FaceAttribute * faceAttrib ) [protected, virtual]

Handler function for a FaceAttribute.

Parameters:
faceAttrib A pointer to the read-locked FaceAttribute being traversed.
Remarks:
This function is called from the framework whenever a FaceAttribute is encountered on traversal. The FaceAttribute faceAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * stateSet ) [protected, virtual]

Handler function for a StateSet.

Parameters:
stateSet A pointer to the read-locked StateSet being traversed.
Remarks:
This function is called from the framework whenever a StateSet is encountered on traversal. The StateSet stateSet is already read-locked.
The base implementation just traverses the active StateVariant.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
StateVariant

Reimplemented from SharedTraverser.

virtual NVSG_API bool preTraverseGroup ( const nvsg::Group * p ) [protected, virtual]

Store the active clip planes of p for later usage.

Parameters:
p A pointer to the constant Group to get the active clip planes from.
Returns:
The result of ModelViewTraverser::preTraverseGroup().
See also:
postTraverseGroup

Reimplemented from Traverser.

virtual NVSG_API void postTraverseGroup ( const nvsg::Group * p ) [protected, virtual]

Restore the set of active clip planes to the set before entering p.

Parameters:
p A pointer to the constant Group just traversed.
Remarks:
The clip planes stored in preTraverseGroup are removed.
See also:
preTraverseGroup

Reimplemented from Traverser.

virtual NVSG_API bool preTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handles actions to take between transform stack adjustment and traversal.

Adjusts the ray origin and direction and the camera direction in model space.

Returns:
result of the base class (ModelViewTraverser).
Parameters:
p Trafo of node to traverse next

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void postTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handles stuff to do between traversal and transform stack adjustment.

Readjusts the ray origin and direction and the camera direction in model space.

Parameters:
p Trafo of node that was traversed immediately before this call.

Reimplemented from SharedModelViewTraverser.

NVSG_API bool checkClipPlanes ( const nvmath::Vec3f & p ) [protected]

Test a point against all active clip planes.

Parameters:
p A reference to a constant point to test against the clip planes.
Returns:
true if p is on the visible side of all active clip planes, otherwise false.

NVSG_API bool checkClipPlanes ( const nvmath::Sphere3f & p ) [protected]

Test a sphere against all active clip planes.

Parameters:
p A reference to a constant sphere to test agains the clip planes.
Returns:
true if p is at least partially on the visible side of all active clip planes, otherwise false.

NVSG_API bool checkIntersection ( const nvmath::Sphere3f & sphere ) [protected]

Check the current ray for intersection with a Sphere3f.

Returns:
true, if the ray intersects sphere, otherwise false.

NVSG_API bool getWorldIntersection | ( | nvmath::Vec3f & | isp,
 |  | float & | dist
 | ) | [protected]

Get the intersection point in world coordinates.

Returns:
true: intersection in front of hte ray origin, false: no such intersection
Parameters:
isp | Result: intersection point (world space)
dist | Input: distance in model space; Result: distance in world space

NVSG_API bool intersectBox | ( | const nvmath::Vec3f & | p0,
 |  | const nvmath::Vec3f & | p1,
 |  | nvmath::Vec3f & | isp,
 |  | float & | dist
 | ) | [protected]

Intersect with a box.

This methods tells if it intersects a box or not. It also calculates the intersection point between a box and a ray and the distance of the intersection from the origin of the ray.

Returns:
true: intersection in front of the ray origin, false: no such intersection
Parameters:
p0 | lower left front point of box
p1 | upper right back point of box
isp | Result: intesection point (world space)
dist | Result: distance form camera to intersection

NVSG_API bool intersectLine | ( | const nvmath::Vec3f & | v0,
 |  | const nvmath::Vec3f & | v1,
 |  | nvmath::Vec3f & | isp,
 |  | float & | dist
 | ) | [protected]

Intersect with line.

This method tells if it intersects the line or not. It also calculates the intersection point between line and ray and the distance of the intersection from the origin of the ray.

Returns:
true: intersection in front of the ray origin, false: no such intersection
Parameters:
v0 | First vertex of the line
v1 | Second vertex of the line
isp | Result: intersection point (world space)
dist | Result: distance from camera to intersection

NVSG_API bool intersectPoint | ( | const nvmath::Vec3f & | v0,
 |  | nvmath::Vec3f & | isp,
 |  | float & | dist
 | ) | [protected]

Intersect with point.

This method tells if it intersects the point or not. It also calculates the intersection point between point and ray and the distance of the intersection from the origin of the ray.

Returns:
true: intersection in front of the ray origin, false: no such intersection
Parameters:
v0 | vertex of the point
isp | Result: intersection point (world space)
dist | Result: distance from camera to intersection

NVSG_API bool intersectTriangle | ( | const nvmath::Vec3f & | v0,
 |  | const nvmath::Vec3f & | v1,
 |  | const nvmath::Vec3f & | v2,
 |  | nvmath::Vec3f & | isp,
 |  | float & | dist
 | ) | [protected]

Intersect with triangle.

This method tells if it intersects the triangle or not. It also calculates the intersection point between triangle and ray and the distance of the intersection from the origin of the ray.

Returns:
true: intersection in front of the ray origin, false: no such intersection
Parameters:
v0 | First vertex of the triangle
v1 | Second vertex of the triangle
v2 | Third vertex of the triangle
isp | Result: intersection point (world space)
dist | Result: distance from camera to intersection

NVSG_API void storeIntersection | ( | const nvsg::Drawable * | p,
 |  | const nvmath::Vec3f & | isp,
 |  | float | dist,
 |  | unsigned int | primitiveIndex,
 |  | const std::vector< unsigned int > & | vertexIndices
 | ) | [protected]

Store the intersection point isp.

If the point isn't clipped, it is stored to the intersection list.

Parameters:
p | Drawable that holds the intersection
isp | Intersection point
dist | Distance from camera to intersection
primitiveIndex | Index of the intersected primitive
vertexIndices | Indices of the vertices of the intersected primitive

NVSG_API void dumpIntersectionList ( ) [protected]

Dump intersection map - for Debug

The documentation for this class was generated from the following file:
  • RayIntersectTraverser.h
Generated on Tue Jan 15 10:29:33 2008 for NVSGSDK by NVIDIA


Member List

RayIntersectTraverser Member List

This is the complete list of members for RayIntersectTraverser, including all inherited members.
_BSFAR enum value | RayIntersectTraverser | [protected]
_BSNEAR enum value | RayIntersectTraverser | [protected]
_BSNEARFAR enum value | RayIntersectTraverser | [protected]
_BSTANGENT enum value | RayIntersectTraverser | [protected]
_NONE enum value | RayIntersectTraverser | [protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
checkClipPlanes(const nvmath::Vec3f &p) | RayIntersectTraverser | [protected]
checkClipPlanes(const nvmath::Sphere3f &p) | RayIntersectTraverser | [protected]
checkIntersection(const nvmath::Sphere3f &sphere) | RayIntersectTraverser | [protected]
doApply(nvsg::NodeHandle *root) | RayIntersectTraverser | [protected, virtual]
dumpIntersectionList() | RayIntersectTraverser | [protected]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
getIntersections(void) const | RayIntersectTraverser | [inline]
getNearest(void) const | RayIntersectTraverser | [inline]
getNumberOfIntersections(void) const | RayIntersectTraverser | [inline]
getWorldIntersection(nvmath::Vec3f &isp, float &dist) | RayIntersectTraverser | [protected]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | RayIntersectTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | SharedTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | RayIntersectTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | RayIntersectTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | RayIntersectTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *anim) | SharedTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *gnode) | RayIntersectTraverser | [protected, virtual]
handleGroup(const nvsg::Group *group) | RayIntersectTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | RayIntersectTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | RayIntersectTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *lod) | RayIntersectTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | RayIntersectTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | RayIntersectTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | RayIntersectTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | RayIntersectTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | RayIntersectTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | RayIntersectTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *variant) | SharedTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *swtch) | RayIntersectTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | RayIntersectTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | RayIntersectTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | RayIntersectTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | RayIntersectTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SharedTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *vnode) | RayIntersectTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
intersectBox(const nvmath::Vec3f &p0, const nvmath::Vec3f &p1, nvmath::Vec3f &isp, float &dist) | RayIntersectTraverser | [protected]
intersectLine(const nvmath::Vec3f &v0, const nvmath::Vec3f &v1, nvmath::Vec3f &isp, float &dist) | RayIntersectTraverser | [protected]
intersectPoint(const nvmath::Vec3f &v0, nvmath::Vec3f &isp, float &dist) | RayIntersectTraverser | [protected]
intersectTriangle(const nvmath::Vec3f &v0, const nvmath::Vec3f &v1, const nvmath::Vec3f &v2, nvmath::Vec3f &isp, float &dist) | RayIntersectTraverser | [protected]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISType enum name | RayIntersectTraverser | [protected]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedModelViewTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | SharedModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | RayIntersectTraverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | RayIntersectTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | RayIntersectTraverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | RayIntersectTraverser | [protected, virtual]
RayIntersectTraverser(void) | RayIntersectTraverser |
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
release() | RayIntersectTraverser |
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setCamClipping(bool b) | RayIntersectTraverser | [inline]
setRay(const nvmath::Vec3f &origin, const nvmath::Vec3f &dir) | RayIntersectTraverser |
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewportSize(unsigned int width, unsigned int height) | RayIntersectTraverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedModelViewTraverser() | SharedModelViewTraverser | [protected]
SharedTraverser() | SharedTraverser |
storeIntersection(const nvsg::Drawable *p, const nvmath::Vec3f &isp, float dist, unsigned int primitiveIndex, const std::vector< unsigned int > &vertexIndices) | RayIntersectTraverser | [protected]
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RayIntersectTraverser(void) | RayIntersectTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedModelViewTraverser() | SharedModelViewTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


TemplateRCIPtr class Reference

RCIPtr Class Template Reference

A smart pointer template for reference counted objects. More...

#include <RCObject.h>

List of all members.

Public Member Functions

RCIPtr (T *pRCObj=0)
Constructs a RCIPtr object.

RCIPtr (const RCIPtr &rhs)
Copy constructor.

~RCIPtr ()
Destructs a RCIPtr.

RCIPtr< T > & | operator= (const RCIPtr< T > &rhs)
Assigns new content.

T * | operator-> ()
Dereferences the RCIPtr.

const T * | operator-> () const
Dereferences the RCIPtr.

T & | operator * ()
Dereferences the RCIPtr.

const T & | operator * () const
Dereferences the RCIPtr.

Friends

template<typename U> void | writeAccess (RCIPtr< U > &rcPtr)
Initiates write access to the managed object.

Detailed Description

template<typename T>
class nvutil::RCIPtr< T >

A smart pointer template for reference counted objects.

Namespace: nvutil
Remarks:
We have no access to object sources, so we need an additional level of indirection because we can't make them publicly inherit from RCObject. The 'I' stands for 'indirect'.

Constructor & Destructor Documentation

RCIPtr ( T * pRCObj = 0 ) [inline, explicit]

Constructs a RCIPtr object.

Parameters:
pRCObj Optional pointer to an RCObject.
Remarks:
The embedded dump pointer will be assigned to pRCObj.

RCIPtr ( const RCIPtr< T > & rhs ) [inline]

Copy constructor.

~RCIPtr ( ) [inline]

Destructs a RCIPtr.

Member Function Documentation

RCIPtr< T > & operator= ( const RCIPtr< T > & rhs ) [inline]

Assigns new content.

Parameters:
rhs RCIPtr from which to assign the new content.
Returns:
The function returns a reference to this object.
Remarks:
If the embedded dump pointer points to some valid RCObject, the reference count of that RCObject will be decremented before re-assigning the dump pointer with the dump pointer from the right hand sided RCIPtr.

T * operator-> ( ) [inline]

Dereferences the RCIPtr.

Returns:
A pointer to the managed RCObject.
Remarks:
This operator helps a RCIPtr object to behave like an ordinary pointer. It is called with dereferencing a non-const RCIPtr object to access the managed RCObject.

const T * operator-> ( ) const [inline]

Dereferences the RCIPtr.

Returns:
A pointer to the managed RCObject.
Remarks:
This operator helps a RCIPtr object to behave like an ordinary pointer. It is called with dereferencing a const RCIPtr object to access the managed RCObject.

T & operator * ( ) [inline]

Dereferences the RCIPtr.

Returns:
A reference to the managed RCObject.
Remarks:
This operator helps a RCIPtr object to behave like an ordinary pointer. It is called with dereferencing a non-const RCIPtr object to access the managed RCObject.

const T & operator * ( ) const [inline]

Dereferences the RCIPtr.

Returns:
A reference to the managed RCObject.
Remarks:
This operator helps a RCIPtr object to behave like an ordinary pointer. It is called with dereferencing a const RCIPtr object to access the managed RCObject.

Friends And Related Function Documentation

void writeAccess ( RCIPtr< U > & rcPtr ) [friend]

Initiates write access to the managed object.

Parameters:
rcPtr RCIPtr object for which to initiate write access.
Remarks:
This must be called before modifying the managed data of the specified RCIPtr object.

This has been introduced to manually decide whether the underlying data really gets modified by a non-const access. This helps to avoid cloning every shared object when a non-const access occurs but the underlying data remains untouched.

With the introduction of writeAccess, full automatic seceding of a shared object with a non-const access has been removed. To nevertheless maintain correctness with shared data, you must explicitly initiate every modifying code with a call to writeAccess on the corresponding RCIPtr object.
Note:
As U is used as a template parameter for RCIPtr, U must be convertible to RCObject.

The documentation for this class was generated from the following file:
  • RCObject.h
Generated on Tue Jan 15 10:29:48 2008 for NVSGSDK by NVIDIA


Member List

RCIPtr Member List

This is the complete list of members for RCIPtr, including all inherited members.
operator *() | RCIPtr | [inline]
operator *() const | RCIPtr | [inline]
operator->() | RCIPtr | [inline]
operator->() const | RCIPtr | [inline]
operator=(const RCIPtr< T > &rhs) | RCIPtr | [inline]
RCIPtr(T *pRCObj=0) | RCIPtr | [inline, explicit]
RCIPtr(const RCIPtr &rhs) | RCIPtr | [inline]
writeAccess(RCIPtr< U > &rcPtr) | RCIPtr | [friend]
~RCIPtr() | RCIPtr | [inline]
Generated on Tue Jan 15 10:29:48 2008 for NVSGSDK by NVIDIA


RCObject Class Reference

Provides an interface for reference counted objects. More...

#include <RCObject.h>

Inheritance diagram for RCObject:

[legend]
Collaboration diagram for RCObject:

[legend]
List of all members.

Public Member Functions

NVSG_API void | addRef () const
Increments the object's reference count.

NVSG_API void | removeRef () const
Decrements the object's reference count.

NVSG_API void | markUnshareable ()
Marks the object as not shareable.

NVSG_API bool | isShareable () const
Tests whether this particular object is flagged shareable.

NVSG_API bool | isShared () const
Tests whether this RCobject is shared.

NVSG_API void | addOnDestroyCallback (DestroyCallback *dcb, void *data)
Add a callback to be called on destruction.

NVSG_API void | removeOnDestroyCallback (DestroyCallback *dcb, void *data)
Remove a callback from the list of callbacks called on destruction.

Protected Member Functions

RCObject ()
Constructs an RCObject.

RCObject (const RCObject &rhs)
Constructs an RCObject.

RCObject & | operator= (const RCObject &rhs)
Assignment operator.

virtual | ~RCObject ()
Destructs an RCObject.

Detailed Description

Provides an interface for reference counted objects.

Namespace: nvutil
Remarks:
The class provides an interface for managing reference counted objects. RCObject inherits from IAllocator to utilize an optimized heap manager for small object allocation.

The creator of an RCObject is responsible for setting the object's reference count to its proper value. For automatic reference counting, though, an RCObject can be managed by a RCPtr.
Note:
An RCObject can only be constructed on heap. The compiler will reject any attempt to construct an RCObject on stack.

It is prohibited to explicitly delete an RCObject by calling delete on a pointer to an RCObject received from a previous call to new. The compiler will complain if any client code attempts to do so. If client code creates an RCObject, it must increment the object's reference count (RCObject::addRef) before using it and decrement the object's reference count (RCObject::removeRef) after usage. The object will be automatically deleted if its reference count reaches zero.

The reference count of a newly created RCObject is initially zero.

See also:
nvutil::RCPtr

Constructor & Destructor Documentation

RCObject ( ) [inline, protected]

Constructs an RCObject.

Remarks:
Initializes the reference count to zero. The creator is responsible for setting the reference count to its proper value.

Initially the RCObject is marked as shareable.

An RCObject is intended to serve as base class only. That is, an RCObject can be instantiated only as an object of a class derived from RCObject.

RCObject ( const RCObject & rhs ) [inline, protected]

Constructs an RCObject.

Remarks:
A new RCObject is created, and hence, the reference count will be initialized to zero because no one but the creator is currently referencing this object, and the creator is responsible for setting the reference count to its proper value.

Initially the RCObject is marked as shareable.

An RCObject is intended to serve as base class only. That is, an RCObject can be instantiated only as an object of a class derived from RCObject.

virtual ~RCObject ( ) [inline, protected, virtual]

Destructs an RCObject.

Remarks:
An RCObject will be automatically deleted when its reference count changes from one to zero.
See also:
RCObject::removeRef

Member Function Documentation

void addRef ( ) const [inline]

Increments the object's reference count.

Remarks:
For user code to ensure that the data of a reference counted object is valid as long as it uses the object, it should first increment the objects reference count. After usage, client code should decrement the objects reference count to avoid resource leaks.
Note:
The reference count of a newly created RCObject initially is zero.
See also:
RCObject::removeRef

void removeRef ( ) const [inline]

Decrements the object's reference count.

Remarks:
It is prohibited to explicitly delete an RCObject. The object will be automatically deleted, if the reference count changes from one to zero.
See also:
RCObject::addRef

void markUnshareable ( ) [inline]

Marks the object as not shareable.

Remarks:
The function marks the object as not shareable. The shareable flag of an RCObject will be evaluated if a managing RCPtr (reference counter pointer) will be copied. If the managed RCObject is flagged as shareable (default), only the reference count of the RCObject will be incremented, indicating that two or more RCPtr objects share the same RCObject. The managed RCObject will be copied not before the first write access (lazy copying).
If instead the RCObject is flagged as not shareable, the managed RCObject will be copied as the managing RCPtr object will be copied (immediate copying).
See also:
RCObject::isShareable

bool isShareable ( ) const [inline]

Tests whether this particular object is flagged shareable.

Returns:
true if shareable, false otherwise.
Remarks:
Marking an RCObject as shareable enables lazy copying of the RCObject if managed by a RCPtr (reference counted pointer) object. That is, a RCPtr object can share its embedded RCObject with other RCPtr objects as long as no write access happens.
See also:
RCObject::markUnshareable

bool isShared ( ) const [inline]

Tests whether this RCobject is shared.

Returns:
true if the internal reference count is greater than one, false otherwise.
Remarks:
See also:
RCObject::addRef, RCObject::removeRef

void addOnDestroyCallback | ( | DestroyCallback * | dcb,
 |  | void * | data
 | ) | [inline]

Add a callback to be called on destruction.

Parameters:
dcb | A pointer to the DestroyCallback to add.
data | A pointer to be used as the second argument of the DestroyCallback.
Note:
The behavior is undefined, if the same combination of DestroyCallback and void * is added more than once.
Example
    Object * o = beginEdit( myObject );
    o->addOnDestroyCallback( myDestroyCallback, NULL );
    endEdit( o );
See also:
DestroyCallback, removeOnDestroyCallback

void removeOnDestroyCallback | ( | DestroyCallback * | dcb,
 |  | void * | data
 | ) | [inline]

Remove a callback from the list of callbacks called on destruction.

Parameters:
dcb | A pointer to the DestroyCallback to remove.
data | The pointer that is used as the data pointer in the corresponding addOnDestroyCallback.
Note:
The behavior is undefined if the combination of dcb and data is not registered as a callback on destruction via addOnDestroyCallback.
Example
    Object * o = beginEdit( myObject );
    o->removeOnDestroyCallback( myDestroyCallback, NULL );
    endEdit( o );
See also:
DestroyCallback, addOnDestroyCallback

RCObject& operator= ( const RCObject & rhs ) [inline, protected]

Assignment operator.

Remarks:
Assigning new content from another object does not change the number of users referencing the object nor does it change its shareable state. Hence, this assignment operator leaves the reference count and the shareable state unchanged.

The documentation for this class was generated from the following file:
  • RCObject.h
Generated on Tue Jan 15 10:29:48 2008 for NVSGSDK by NVIDIA


Member List

RCObject Member List

This is the complete list of members for RCObject, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:48 2008 for NVSGSDK by NVIDIA


TemplateRCObject_AutoPtr class Reference

RCObject_AutoPtr Class Template Reference

AutoPtr for reference counted objects. More...

#include <RCObject.h>

Collaboration diagram for RCObject_AutoPtr:

[legend]
List of all members.

Public Member Functions

RCObject_AutoPtr (T *ptr=0)
Constructs an RCObject_AutoPtr.

template<typename U> | RCObject_AutoPtr (const RCObject_AutoPtr< U > &rhs)
Copy constructor.

~RCObject_AutoPtr ()
Destructs an RCObject_AutoPtr.

template<typename U> RCObject_AutoPtr< T > & | operator= (const RCObject_AutoPtr< U > &rhs)
Assigns new content.

T * | get () const
Returns the dump pointer.

T * | operator-> () const
Member selection operator to make this behave like a dump pointer.

T & | operator * () const
Dereferences an RCObject_AutoPtr.

T * | release ()
Releases the managed RCObject.

void | reset (T *ptr)
Resets the dump pointer to the managed RCObject.

Detailed Description

template<typename T>
class nvutil::RCObject_AutoPtr< T >

AutoPtr for reference counted objects.

Namespace: nvutil
An RCObject_AutoPtr turns a pointer to an RCObject into an automatic object that will be automatically destroyed when running out of scope. As all auto objects, an RCObject_AutoPtr will be correctly cleaned up when it comes to a runtime exception, and hence, helps to use RCObjects in a more exception-safe manner.

Constructor & Destructor Documentation

RCObject_AutoPtr ( T * ptr = 0 ) [inline, explicit]

Constructs an RCObject_AutoPtr.

Parameters:
ptr Optional pointer to an RCObject to be managed by the RCObject
Remarks:
The dump pointer will be initialized with ptr.

RCObject_AutoPtr ( const RCObject_AutoPtr< U > & rhs ) [inline]

Copy constructor.

~RCObject_AutoPtr ( ) [inline]

Destructs an RCObject_AutoPtr.

Remarks:
If the RCObject the dump pointer points to was not released before this destructor is called, the RCObject will be properly freed, if no other user is referencing the RCObject.
See also:
RCObject_AutoPtr::release

Member Function Documentation

RCObject_AutoPtr< T > & operator= ( const RCObject_AutoPtr< U > & rhs ) [inline]

Assigns new content.

Remarks:
If the dump pointer points to a valid RCObject, that RCObject will be properly freed before the dump pointer will be re-assigned to the dump pointer from the right-hand-sided RCObject_AutoPtr.

T * get ( ) const [inline]

Returns the dump pointer.

Returns:
A pointer to the managed RCObject.
See also:
RCObject_AutoPtr::operator->()

T * operator-> ( ) const [inline]

Member selection operator to make this behave like a dump pointer.

Returns:
A pointer to the managed RCObject.
Remarks:
This operator helps an RCObject_AutoPtr object to behave like an ordinary pointer.
See also:
RCObject_AutoPtr::operator*()

T & operator * ( ) const [inline]

Dereferences an RCObject_AutoPtr.

Returns:
A reference to the managed RCObject.
Remarks:
This operator helps an RCObject_AutoPtr object to behave like an ordinary pointer.
See also:
RCObject_AutoPtr::operator->()

T * release ( ) [inline]

Releases the managed RCObject.

Returns:
A pointer to the previously managed RCObject.
Remarks:
The function transfers ownership of the previously managed RCObject to the caller. The caller then is responsible for setting the reference count for the retrieved RCObject to its proper value.

void reset ( T * ptr )

Resets the dump pointer to the managed RCObject.

Parameters:
ptr Pointer to reset the dump pointer to.
Remarks:
A previously managed RCObject will be properly freed before the function resets the dump pointer to the new value.

The documentation for this class was generated from the following file:
  • RCObject.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

RCObject_AutoPtr Member List

This is the complete list of members for RCObject_AutoPtr, including all inherited members.
get() const | RCObject_AutoPtr | [inline]
operator *() const | RCObject_AutoPtr | [inline]
operator->() const | RCObject_AutoPtr | [inline]
operator=(const RCObject_AutoPtr< U > &rhs) | RCObject_AutoPtr | [inline]
RCObject_AutoPtr(T *ptr=0) | RCObject_AutoPtr | [inline, explicit]
RCObject_AutoPtr(const RCObject_AutoPtr< U > &rhs) | RCObject_AutoPtr | [inline]
release() | RCObject_AutoPtr | [inline]
reset(T *ptr) | RCObject_AutoPtr |
~RCObject_AutoPtr() | RCObject_AutoPtr | [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


TemplateRCPtr class Reference

RCPtr Class Template Reference

A smart pointer template to manage reference counted objects. More...

#include <RCObject.h>

Inheritance diagram for RCPtr:

[legend]
Collaboration diagram for RCPtr:

[legend]
List of all members.

Public Member Functions

RCPtr (T *pRCObj=0)
Constructs a RCPtr object.

RCPtr (const RCPtr &rhs)
Copy constructor.

~RCPtr ()
Destructs a RCPtr.

RCPtr< T > & | operator= (const RCPtr< T > &rhs)
Assigns new content.

T * | operator-> ()
Dereferences the RCPtr.

const T * | operator-> () const
Dereferences the RCPtr.

T & | operator * ()
Dereferences the RCPtr.

const T & | operator * () const
Dereferences the RCPtr.

Friends

template<typename U> void | writeAccess (RCPtr< U > &rcPtr)
Initiates write access to the managed object.

Detailed Description

template<typename T>
class nvutil::RCPtr< T >

A smart pointer template to manage reference counted objects.

Namespave: nvutil
Remarks:
Offers automatic reference counting through utilizing the RCObject interface. Like a smart pointer this can be used as an ordinary built-in pointer.
Note:
The type T must be convertible to RCObject. The compiler will reject any attempt to instantiate a RCPtr object for types other than RCObject convertible types.

Constructor & Destructor Documentation

RCPtr ( T * pRCObj = 0 ) [inline, explicit]

Constructs a RCPtr object.

Parameters:
pRCObj Optional pointer to an RCObject.
Remarks:
The embedded dump pointer will be assigned to pRCObj.

RCPtr ( const RCPtr< T > & rhs ) [inline]

Copy constructor.

~RCPtr ( ) [inline]

Destructs a RCPtr.

Member Function Documentation

RCPtr< T > & operator= ( const RCPtr< T > & rhs ) [inline]

Assigns new content.

Parameters:
rhs RCPtr from which to assign the new content.
Returns:
The function returns a reference to this object.
Remarks:
If the embedded dump pointer points to some valid RCObject, the reference count of that RCObject will be decremented before re-assigning the dump pointer with the dump pointer from the right hand sided RCPtr.

T * operator-> ( ) [inline]

Dereferences the RCPtr.

Returns:
A pointer to the managed RCObject.
Remarks:
This operator helps a RCPtr object to behave like an ordinary pointer. It will be called with dereferencing a non-const RCPtr object to access the managed RCObject.

const T * operator-> ( ) const [inline]

Dereferences the RCPtr.

Returns:
A pointer to the managed RCObject.
Remarks:
This operator helps a RCPtr object to behave like an ordinary pointer. It will be called with dereferencing a const RCPtr object to access the managed RCObject.

T & operator * ( ) [inline]

Dereferences the RCPtr.

Returns:
A reference to the managed RCObject.
Remarks:
This operator helps a RCPtr object to behave like an ordinary pointer. It be called with dereferencing a non-const RCPtr object to access the managed RCObject.

const T & operator * ( ) const [inline]

Dereferences the RCPtr.

Returns:
A reference to the managed RCObject.
Remarks:
This operator helps a RCPtr object to behave like an ordinary pointer. It be called with dereferencing a const RCPtr object to access the managed RCObject.

Friends And Related Function Documentation

void writeAccess ( RCPtr< U > & rcPtr ) [friend]

Initiates write access to the managed object.

Parameters:
rcPtr RCPtr object for which to initiate write access.
Remarks:
This must be called before modifying the managed data of the specified RCPtr object.

This has been introduced to manually decide whether the underlying data really gets modified by a non-const access. This helps to avoid cloning every shared object when a non-const access occurs but the underlying data remains untouched.

With the introduction of writeAccess, full automatic seceding of a shared object with a non-const access has been removed. To nevertheless maintain correctness with shared data, you must explicitly initiate every modifying code with a call to writeAccess on the corresponding RCPtr object.
Note:
As U is used as a template parameter for RCPtr, U must be convertible to RCObject.

The documentation for this class was generated from the following file:
  • RCObject.h
Generated on Tue Jan 15 10:29:48 2008 for NVSGSDK by NVIDIA


Member List

RCPtr Member List

This is the complete list of members for RCPtr, including all inherited members.
operator *() | RCPtr | [inline]
operator *() const | RCPtr | [inline]
operator->() | RCPtr | [inline]
operator->() const | RCPtr | [inline]
operator=(const RCPtr< T > &rhs) | RCPtr | [inline]
RCPtr(T *pRCObj=0) | RCPtr | [inline, explicit]
RCPtr(const RCPtr &rhs) | RCPtr | [inline]
writeAccess(RCPtr< U > &rcPtr) | RCPtr | [friend]
~RCPtr() | RCPtr | [inline]
Generated on Tue Jan 15 10:29:48 2008 for NVSGSDK by NVIDIA


TemplateRCVector class Reference

RCVector Class Template Reference

A reference counted vector. More...

#include <RCObject.h>

Inheritance diagram for RCVector:

[legend]
Collaboration diagram for RCVector:

[legend]
List of all members.

Public Member Functions

RCVector ()
Constructs an initially empty RCVector.

RCVector (unsigned int n)
Constructs a RCVector of the specified size.

Detailed Description

template<typename T>
class nvutil::RCVector< T >

A reference counted vector.

Namespace : nvutil
Remarks:
A RCVector is simply a STL vector providing the RCObject interface. A RCVector, once constructed using the limited set of available constructors, can be used same as a STL vector.

Constructor & Destructor Documentation

RCVector ( ) [inline]

Constructs an initially empty RCVector.

RCVector ( unsigned int n ) [inline, explicit]

Constructs a RCVector of the specified size.

Parameters:
n Number of elements in the constructed vector.
Remarks:
The constructor specifies a repetition of the specified number n of elements of the default value for type T.
See also:
std::vector

The documentation for this class was generated from the following file:
  • RCObject.h
Generated on Tue Jan 15 10:29:48 2008 for NVSGSDK by NVIDIA


Member List

RCVector Member List

This is the complete list of members for RCVector, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
RCVector() | RCVector | [inline]
RCVector(unsigned int n) | RCVector | [inline, explicit]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:48 2008 for NVSGSDK by NVIDIA


ReadMapping Class Reference

Helper class to ease efficient reading of large files. More...

#include <FileMapping.h>

Inheritance diagram for ReadMapping:

[legend]
Collaboration diagram for ReadMapping:

[legend]
List of all members.

Public Member Functions

NVSG_API | ReadMapping (const std::string &fileName)
Constructor using the name of the file to read.

NVSG_API | ~ReadMapping ()
Destructor of a read-only mapping.

NVSG_API const void * | mapIn (size_t offset, size_t numBytes)
Map a view of the file.

Detailed Description

Helper class to ease efficient reading of large files.

See also:
FileMapping

Constructor & Destructor Documentation

NVSG_API ReadMapping ( const std::string & fileName )

Constructor using the name of the file to read.

Parameters:
fileName The name of the file to read.
Note:
If the file fileName does not exist, the resulting ReadMapping is marked as invalid. Only valid ReadMappings can be used for reading.
Example:
    ReadMapping rm = new ReadMapping( fileName );
    if ( rm->isValid() )
    {...}

NVSG_API ~ReadMapping ( )

Destructor of a read-only mapping.

Remarks:
If the ReadMapping is valid, the opened file is closed.

Member Function Documentation

const void * mapIn | ( | size_t | offset,
 |  | size_t | numBytes
 | ) | [inline]

Map a view of the file.

Parameters:
offset | The offset that has to be part of the mapping.
numBytes | The number of bytes that, starting from offset, are to be part of the mapping.
Returns:
A pointer to the constant mapped memory location, or NULL if the mapping failed.
See also:
mapOut

Reimplemented from FileMapping.

The documentation for this class was generated from the following file:
  • FileMapping.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

ReadMapping Member List

This is the complete list of members for ReadMapping, including all inherited members.
FileMapping() | FileMapping | [protected]
getLastError() const | FileMapping | [inline]
isValid() const | FileMapping | [inline]
m_accessType | FileMapping | [protected]
m_file | FileMapping | [protected]
m_fileMapping | FileMapping | [protected]
m_isValid | FileMapping | [protected]
m_mappingSize | FileMapping | [protected]
mapIn(size_t offset, size_t numBytes) | ReadMapping | [inline]
mapOut(const void *offsetPtr) | FileMapping |
ReadMapping(const std::string &fileName) | ReadMapping |
~FileMapping() | FileMapping | [protected]
~ReadMapping() | ReadMapping |
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


RedundantLODRangesResult Class Reference

AnalyzeResult indicating LODs with redundant ranges. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for RedundantLODRangesResult:

[legend]
Collaboration diagram for RedundantLODRangesResult:

[legend]
List of all members.

Public Member Functions

virtual | ~RedundantLODRangesResult ()
Virtual Destructor.

Public Attributes

unsigned int | lodRanges
The number of LOD ranges.

unsigned int | redundantLODs
The number of LODs with redundant ranges.

unsigned int | redundantLODRanges
The number of redundant LOD ranges.

Detailed Description

AnalyzeResult indicating LODs with redundant ranges.

Namespace: nvsg
Remarks:
Two ranges of an LOD are redundant, if they are the same.
See also:
AnalyzeResult, AnalyzeTraverser

Constructor & Destructor Documentation

virtual ~RedundantLODRangesResult ( ) [inline, virtual]

Virtual Destructor.

Member Data Documentation

unsigned int lodRanges

The number of LOD ranges.

unsigned int redundantLODs

The number of LODs with redundant ranges.

unsigned int redundantLODRanges

The number of redundant LOD ranges.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


Member List

RedundantLODRangesResult Member List

This is the complete list of members for RedundantLODRangesResult, including all inherited members.
lodRanges | RedundantLODRangesResult |
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
redundantLODRanges | RedundantLODRangesResult |
redundantLODs | RedundantLODRangesResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~RedundantLODRangesResult() | RedundantLODRangesResult | [inline, virtual]
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


TemplateRegVal class Reference

RegVal Class Template Reference

Template class for easy access to the Registry. More...

#include <Registry.h>

Collaboration diagram for RegVal:

[legend]
List of all members.

Public Types

enum | { DIRTY = 1 }

Public Member Functions

RegVal (const TCHAR *value_name, const TCHAR *subkey, DWORD type, HKEY root=HKEY_CURRENT_USER, const T &def=T())
~RegVal ()
RegVal< T > & | operator= (const T &rhs)
operator const T & ()

Detailed Description

template<typename T>
class nvutil::RegVal< T >

Template class for easy access to the Registry.

Constructor & Destructor Documentation

RegVal | ( | const TCHAR * | value_name,
 |  | const TCHAR * | subkey,
 |  | DWORD | type,
 |  | HKEY | root = HKEY_CURRENT_USER,
 |  | const T & | def = T()
 | ) | [inline]

constructor

~RegVal ( ) [inline]

destructor

Member Function Documentation

RegVal< T > & operator= ( const T & rhs ) [inline]

convenient writes throug simple assignment

operator const T & ( ) [inline]

convenient reads through implicit type conversion

The documentation for this class was generated from the following file:
  • Registry.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

RegVal Member List

This is the complete list of members for RegVal, including all inherited members.
DIRTY enum value (defined in RegVal) | RegVal |
operator const T &() | RegVal | [inline]
operator=(const T &rhs) | RegVal | [inline]
RegVal(const TCHAR *value_name, const TCHAR *subkey, DWORD type, HKEY root=HKEY_CURRENT_USER, const T &def=T()) | RegVal | [inline]
~RegVal() | RegVal | [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


removeReference Struct Reference

Convenient helper functor that can be used in STL algorithms. More...

#include <RCObject.h>

List of all members.

Public Member Functions

template<typename RCOBJPTR> RCOBJPTR operator() (RCOBJPTR pRCObject)
Function call operator for one argument, being the pointer to an object.

template<typename AnyType, typename RCOBJPTR> const std::pair< AnyType,
RCOBJPTR > & 		operator() (std::pair< AnyType, RCOBJPTR > &p)
Function call operator for a pair of arguments.

Detailed Description

Convenient helper functor that can be used in STL algorithms.

Member Function Documentation

RCOBJPTR operator() ( RCOBJPTR pRCObject ) [inline]

Function call operator for one argument, being the pointer to an object.

const std::pair<AnyType, RCOBJPTR>& operator() ( std::pair< AnyType, RCOBJPTR > & p ) [inline]

Function call operator for a pair of arguments.

The documentation for this struct was generated from the following file:
  • RCObject.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

removeReference Member List

This is the complete list of members for removeReference, including all inherited members.
operator()(RCOBJPTR pRCObject) | removeReference | [inline]
operator()(std::pair< AnyType, RCOBJPTR > &p) | removeReference | [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


RenderArea Class Reference

The RenderArea is the place where the actual drawing takes place. More...

#include <RenderArea.h>

Inheritance diagram for RenderArea:

[legend]
Collaboration diagram for RenderArea:

[legend]
List of all members.

Public Types

enum | { NVSG_STEREO = BIT0, NVSG_MULTISAMPLE = BIT1 }
Possible features of the RenderArea. (mainly influencing the pixel format - OpenGL). More...

Public Member Functions

virtual NVSG_API | ~RenderArea ()
Destructor of the RenderArea.

virtual NVSG_API bool | init (RenderArea *shareArea=NULL)
Create the RenderArea.

virtual NVSG_API void | destroy (void)
Destroy the render area.

virtual NVSG_API void | renderScene ()
Renders the very next frame.

NVSG_API void | interruptRender ()
Forces interruption of current frame.

NVSG_API bool | wasRenderInterrupted () const
Returns whether the last frame was interrupted.

virtual NVSG_API void | setViewportSize (unsigned int width, unsigned int height)
Handle the viewport resizing.

NVSG_API unsigned int | getViewportHeight () const
Get viewport height.

NVSG_API unsigned int | getViewportWidth () const
Get viewport width.

NVSG_API nvtraverser::RenderTraverser * | getRenderTraverser () const
Get the currently registered nvtraverser::RenderTraverser.

NVSG_API void | setRenderTraverser (nvtraverser::RenderTraverser *tr)
Set the new nvtraverser::RenderTraverser.

NVSG_API void | setAppTraverser (nvtraverser::AppTraverser *tr)
Set the current nvtraverser::AppTraverser.

NVSG_API nvtraverser::AppTraverser * | getAppTraverser () const
Get the currently registered nvtraverser::AppTraverser.

NVSG_API void | pushCullTraverser (nvtraverser::CullTraverser *tr)
Add a nvtraverser::CullTraverser to the culling pipeline.

NVSG_API void | popCullTraverser ()
Remove a nvtraverser::CullTraverser from the cull pipeline.

NVSG_API unsigned int | getNumberOfCullTraverser () const
Get the number of culling stages in the culling pipeline.

NVSG_API nvtraverser::CullTraverser * | getCullTraverser (unsigned int position) const
Get the specified nvtraverser::CullTraverser,.

NVSG_API float | getAspectRatio () const
Get the current aspect ratio of the RenderArea.

NVSG_API bool | isStereoAvailable ()
Check if stereo is available for the current RenderArea.

NVSG_API void | requestStereoSupport (bool stereo)
Request stereo support.

NVSG_API bool | isHWFSAAAvailable ()
Check if hardware full-scene antialiasing (FSAA) is available for the current RenderArea.

NVSG_API void | requestHWFSAA (bool on, unsigned int numBuffers)
Request hardware full-scene antialiasing (FSAA) support.

NVSG_API void | setSceneData (nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState)
Register the Scene and the nvsg::ViewState with this RenderArea.

NVSG_API nvsg::ViewStateHandle * | getViewState () const
Get the current nvsg::ViewState.

virtual NVSG_API void | setViewState (nvsg::ViewStateHandle *viewState)
Register a nvsg::ViewState.

NVSG_API nvsg::SceneHandle * | getScene () const
Get the current nvsg::Scene.

virtual NVSG_API void | setScene (nvsg::SceneHandle *scene)
Register a nvsg::Scene.

virtual NVSG_API void | triggerRedraw (void)
Trigger a redraw of the scene.

NVSG_API const nvutil::ProblemLogList & | getProblems ()
Get the problem log.

Static Public Member Functions

NVSG_API unsigned int | createNewRenderAreaID ()
Create a unique ID for a RenderArea.

Protected Member Functions

NVSG_API | RenderArea ()
Default constructor (protected).

Protected Attributes

std::vector< nvtraverser::CullTraverser * > | m_cullTraverser
These traversers cull objects in the tree.

nvtraverser::RenderTraverser * m_renderTraverser
This traverser renders / displays the tree.

nvtraverser::AppTraverser * m_appTraverser
This traverser applies all pending changes to the tree.

nvsg::SceneHandle * m_scene
Pointer to the scene.

nvsg::ViewStateHandle * m_viewState
Pointer to the view specific controls (camera, animation state,...).

UINT | m_features
All requested features for this render area stereo, multisample, ...

UINT | m_numMSBuffers
Number of multi sample buffers.

bool | m_raCreated
Signal the Create() status.

unsigned int | m_raHeight
Height of the render area.

unsigned int | m_raWidth
Width of the render area.

nvutil::ProblemLog | m_problemLog
All problems during the initialization of the render area go here.

Static Protected Attributes

unsigned int | m_idRenderArea
The child window ID for the different CWnd derived render area windows.

Detailed Description

The RenderArea is the place where the actual drawing takes place.

Namespace: nvui
Remarks:
This class provides a generic interface to a render target view that is independent of device, hardware, and operating system specifics.
By default, this base class is created with an nvtraverser::AppTraverser and a nvtraverser::FrustumCullTraverser. Derived classes may also create a platform specific nvtraverser::RenderTraverser by default.
The RenderArea always uses the camera of the given nvsg::ViewState.
See also:
GLWinRenderArea,

Member Enumeration Documentation

anonymous enum

Possible features of the RenderArea. (mainly influencing the pixel format - OpenGL).

Enumeration values:
NVSG_STEREO | Stereo requested.
NVSG_MULTISAMPLE | Multisample buffer requested.

Constructor & Destructor Documentation

virtual NVSG_API ~RenderArea ( ) [virtual]

Destructor of the RenderArea.

Remarks:
If the RenderArea still has references to the given ViewState and/or given Scene, the objects will be unreferenced.

NVSG_API RenderArea ( ) [protected]

Default constructor (protected).

Remarks:
Hidden default constructor to prevent the application to instantiate this class.

Member Function Documentation

virtual NVSG_API bool init ( RenderArea * shareArea = NULL ) [virtual]

Create the RenderArea.

Parameters:
shareArea Pointer to a RenderArea to share information with. If you do not want to share with another RenderArea, provide NULL.
Returns:
When the function succeeds, the return value is true.
Remarks:
This function creates and initializes the RenderArea. An nvTraverser::AppTraverser and a nvTraverser::FrustumCullTraverser will be created by default.

This class does not use the shareArea parameter. Derived classes can use the shareArea parameter to share data between the two RenderAreas. An OpenGL RenderArea can, for example, call GLShareLists to share display lists, textures, vertex programs, etc.
See also:
GLWinRenderArea

Reimplemented in GLWinRenderArea, and GLMFCRAWnd.

virtual NVSG_API void destroy ( void ) [virtual]

Destroy the render area.

Remarks:
This function destroys and cleans up the RenderArea. It makes sure that all the registered nvtraverser::Traverser will be unregistered. Overload this function to clean up your derived class and call back into the base class.
See also:
GLWinRenderArea

Reimplemented in GLWinRenderArea, and GLMFCRAWnd.

virtual NVSG_API void renderScene ( ) [virtual]

Renders the very next frame.

Remarks:
The function initiates rendering of the very next frame of the entire scene that is assigned to the RenderArea. It does this by subsequently applying the assigned nvtraverser::AppTraverser, nvtraverser::CullTraverser, and nvtraverser::RenderTraverser.
After this functions returns you optionally can call RenderArea::wasRenderInterrupted to check whether the last frame was rendered completely or not.

Do not call this function directly. Trigger the RenderArea::renderScene by calling RenderArea::triggerRedraw , since this call is RenderArea specific. This means that the different overloads will do the right things to trigger a redraw with respect to your used window manager. For example, with MFC you would call something like InvalidateRect(NULL) from inside RenderArea::triggerRedraw to force the framework to enter the View::OnDraw function from where you can call RenderArea::renderScene.
See also:
GLWinRenderArea, wasRenderInterrupted

Reimplemented in GLWinRenderArea.

NVSG_API void interruptRender ( )

Forces interruption of current frame.

Remarks:
This function interrupts the traversal of its assigned traversers. Note that this function is meaningful only if called from a different thread as the thread actually rendering the scene. The render thread then optionally can call wasRenderInterrupted to check whether the frame was entirely rendered or whether the rendering was interrupted.
See also:
wasRenderInterrupted

bool wasRenderInterrupted ( ) const [inline]

Returns whether the last frame was interrupted.

Returns:
The function returns true if rendering of the last frame was interrupted. Otherwise the function returns false, to indicate that the frame was entirely rendered.
Remarks:
This function optionally can be called from the drawing thread, right after renderScene, to check whether the rendering of the last frame was interrupted or whether the frame was entirely rendered.
See also:
renderScene, interruptRender

virtual NVSG_API void setViewportSize | ( | unsigned int | width,
 |  | unsigned int | height
 | ) | [virtual]

Handle the viewport resizing.

Parameters:
width | Width of the viewport. Valid for width > 0.f.
height | Height of the viewport. Valid for height > 0.f.
Remarks:
Resize the viewport. React on parent window size changes and report the new aspect ratio to the camera of the nvsg::ViewState.
See also:
GLWinRenderArea::setViewportSize

Reimplemented in GLWinRenderArea, and GLMFCRAWnd.

unsigned int getViewportHeight ( ) const [inline]

Get viewport height.

Returns:
The height of the viewport in pixels.
See also:
getViewportWidth

unsigned int getViewportWidth ( ) const [inline]

Get viewport width.

Returns:
The width of the viewport in pixels.
See also:
getViewportHeight

nvtraverser::RenderTraverser * getRenderTraverser ( ) const [inline]

Get the currently registered nvtraverser::RenderTraverser.

Returns:
Pointer to the currently registered nvtraverser::RenderTraverser. If there is currently no RenderTraverser registered, this function returns NULL.
Remarks:
nvtraverser::RenderTraverser may be device dependent. So a secure programming technique is not to share one nvtraverser::RenderTraverser with another RenderArea. There may be exceptions to this rule so see the documentation of the derived nvtraverser::RenderTraverser classes for more detailed information on this issue.
See also:
setRenderTraverser, nvtraverser::RenderTraverser

void setRenderTraverser ( nvtraverser::RenderTraverser * tr ) [inline]

Set the new nvtraverser::RenderTraverser.

Parameters:
tr Pointer to the new nvtraverser::RenderTraverser.
Remarks:
Register the new nvtraverser::RenderTraverser. The currently registered nvtraverser::RenderTraverser will be unreferenced and replaced by the new one. If you provide NULL, because the new nvtraverser::RenderTraverser will be unreferenced and the RenderArea has no nvtraverser::RenderTraverser registered, this is completely valid.

nvtraverser::RenderTraverser may be device dependent. So a secure programming technique is not to share one nvtraverser::RenderTraverser with another RenderArea. There may be exceptions to this rule so see the documentation of the derived nvtraverser::RenderTraverser classes for more detailed information on this issue.
See also:
getRenderTraverser, nvtraverser::RenderTraverser

void setAppTraverser ( nvtraverser::AppTraverser * tr ) [inline]

Set the current nvtraverser::AppTraverser.

Parameters:
tr Pointer to the new nvtraverser::AppTraverser.
Remarks:
Register the new nvtraverser::AppTraverser. The currently registered nvtraverser::AppTraverser will be unreferenced and replaced by the new one. If you provide NULL, because the new nvtraverser::AppTraverser will be unreferenced and the RenderArea has no nvtraverser::AppTraverser registered, this is completely valid. But you should be aware of the fact the the default nvtraverser::AppTraverser is needed to bring information into the tree that is needed on a frame by frame basis e.g. animation information etc.
Not providing an nvtraverser::AppTraverser can lead to unexpected rendering results.
See also:
getAppTraverser, nvtraverser::AppTraverser

nvtraverser::AppTraverser * getAppTraverser ( ) const [inline]

Get the currently registered nvtraverser::AppTraverser.

Returns:
Pointer to the currently registered nvtraverser::AppTraverser. If there is currently no nvtraverser::AppTraverser registered, this function returns NULL.
Remarks:
Get the currently registered nvtraverser::AppTraverser. It is a valid constellation to have no nvtraverser::AppTraverser registered with the RenderArea, but you should be aware of the fact the the default nvtraverser::AppTraverser is needed to bring information into the tree that is needed on a frame by frame basis e.g. animation information etc.
Not providing an nvtraverser::AppTraverser can lead to unexpected rendering results.
See also:
setAppTraverser, nvtraverser::AppTraverser

void pushCullTraverser ( nvtraverser::CullTraverser * tr ) [inline]

Add a nvtraverser::CullTraverser to the culling pipeline.

Parameters:
tr Pointer to the new nvtraverser::CullTraverser.
Remarks:
A RenderArea can have more than one nvtraverser::CullTraverser. You can build a type of culling pipeline by stacking together several cull steps. This function appends an additional nvtraverser::CullTraverser to the end of the pipeline of this RenderArea.

Internally we increment the reference count of the new nvtraverser::CullTraverser.

Do not add the same nvtraverser::CullTraverser more than once to the culling pipeline.
See also:
popCullTraverser, getNumberOfCullTraverser, getCullTraverser

void popCullTraverser ( ) [inline]

Remove a nvtraverser::CullTraverser from the cull pipeline.

Remarks:
This function removes the last nvtraverser::CullTraverser from the end of the culling pipeline. The RenderArea also takes care of decrementing the reference count of that nvtraverser::CullTraverser.
See also:
pushCullTraverser, getNumberOfCullTraverser, getCullTraverser

unsigned int getNumberOfCullTraverser ( ) const [inline]

Get the number of culling stages in the culling pipeline.

Returns:
Number of active culling stages.
See also:
pushCullTraverser, popCullTraverser, getCullTraverser

nvtraverser::CullTraverser * getCullTraverser ( unsigned int position ) const [inline]

Get the specified nvtraverser::CullTraverser,.

Parameters:
position Zero-based position of the nvtraverser::CullTraverser. The position must be valid: RenderArea::getNumberOfCullTraverser > position.
Returns:
Pointer to the specified nvtraverser::CullTraverser.
Remarks:
Retrieve the nvtraverser::CullTraverser from the specified position of the culling pipeline. If you feed this function with an invalid position, the behavior is not defined.
See also:
pushCullTraverser, popCullTraverser, getNumberOfCullTraverser

float getAspectRatio ( ) const [inline]

Get the current aspect ratio of the RenderArea.

Returns:
The current aspect ratio of the render area. If height or width is not a valid value, the return value is 0.f.
Remarks:
This function can be used to retrieve the current aspect ratio of the RenderArea. (aspect ratio = width / height). The initial values for height and width is 1.f which corresponds to the camera window size definition.
See also:
nvsg::Camera::setWindowSize

NVSG_API bool isStereoAvailable ( )

Check if stereo is available for the current RenderArea.

Returns:
true if stereo is available. false indicates that stereo is not available or the RenderArea was not initialized and valid.
Remarks:
The RenderArea must be initialized and valid before you can ask for stereo availability.
See also:
init

NVSG_API void requestStereoSupport ( bool stereo )

Request stereo support.

Parameters:
stereo Stereo required for this RenderArea.
Remarks:
Request stereo support for this RenderArea. Call this function prior to the RenderArea::init call. So the init call can make sure to create a RenderArea that supports stereo. By default, the RenderArea::init call will not request stereo.

For rendering stereo images your RenderArea and your nvtraverser::RenderTraverser need to support this special feature. To turn stereo rendering on or off you need to call nvsg::ViewState::toggleStereo.

If you know that you do not need a RenderArea that supports stereo avoid requesting stereo. This avoids wasting resources and rendering performance.
See also:
nvsg::ViewState::toggleStereo

NVSG_API bool isHWFSAAAvailable ( )

Check if hardware full-scene antialiasing (FSAA) is available for the current RenderArea.

Returns:
true if hardware full-scene antialiasing (FSAA) is available. false indicates that hardware full-scene antialiasing (FSAA) is not available or the RenderArea was not initialized and is not valid.
Remarks:
The RenderArea must be initialized and valid before you can ask for hardware full-scene antialiasing (FSAA) availability.
See also:
init

NVSG_API void requestHWFSAA | ( | bool | on,
 |  | unsigned int | numBuffers
 | ) |

Request hardware full-scene antialiasing (FSAA) support.

Parameters:
on | Hardware FSAA is required for this RenderArea.
numBuffers | Hardware FSAA level / number of multisample buffers.
Remarks:
Request hardware full-scene antialiasing (FSAA) support for this RenderArea. Call this function prior to the init call. So the init call can make sure to create a RenderArea that supports hardware full-scene antialiasing (FSAA) with the specified number of multi sample buffers. By default the RenderArea::init call will not request hardware full-scene anti-aliasing.

You can combine hardware FSAA with software FSAA. To turn on software FSAA you need to call nvtraverser::RenderTraverser::setJitterTechnique and nvtraverser::RenderTraverser::setJitter.
See also:
nvtraverser::RenderTraverser::setJitterTechnique, nvtraverser::RenderTraverser::setJitter

NVSG_API void setSceneData | ( | nvsg::SceneHandle * | scene,
 |  | nvsg::ViewStateHandle * | viewState
 | ) |

Register the Scene and the nvsg::ViewState with this RenderArea.

Parameters:
scene | Scene to replace the RenderArea's current Scene. Passing in NULL leads to undefined behavior.
viewState | ViewState to replace the RenderArea's current ViewState. Passing in NULL leads to undefined behavior.
Remarks:
The function replaces the RenderArea's current Scene and ViewState. The reference count of the already contained nScene and ViewState will be decremented where the reference count of the new Scene and ViewState will be incremented.
See also:
setViewState, getViewState, setScene, getScene

nvsg::ViewStateHandle * getViewState ( ) const [inline]

Get the current nvsg::ViewState.

Returns:
Pointer to a ViewStateHandle specifying the ViewState. If no ViewState was registered prior to this call the result will be NULL;
Remarks:
Get the currently registered ViewState of the RenderArea.
See also:
setViewState, setSceneData

virtual NVSG_API void setViewState ( nvsg::ViewStateHandle * viewState ) [virtual]

Register a nvsg::ViewState.

Parameters:
viewState ViewState to replace the RenderArea's current ViewState. Passing in NULL as the new nvsg::ViewState leads to undefined behavior.
Remarks:
Register a nvsg::ViewState with the RenderArea. If there was already a nvsg::ViewState registered, the reference count of the old one will be decremented while the reference count of the new one will be incremented.
See also:
getViewState, setSceneData

nvsg::SceneHandle * getScene ( ) const [inline]

Get the current nvsg::Scene.

Returns:
Pointer to a SceneHandle specifying the nvsg::Scene. If no nvsg::Scene was registered prior to this call the result will be NULL;
Remarks:
Get the currently registered nvsg::Scene of the RenderArea.
See also:
setScene, setSceneData

virtual NVSG_API void setScene ( nvsg::SceneHandle * scene ) [virtual]

Register a nvsg::Scene.

Parameters:
scene Scene to replace the RenderArea's current Scene. Passing in NULL leads to undefined behavior.
Remarks:
Register a nvsg::Scene with the RenderArea. If there was already a nvsg::Scene registered, the reference count of the old one will be decremented while the reference count of the new one will be incremented.
See also:
getScene, setSceneData

unsigned int createNewRenderAreaID ( ) [inline, static]

Create a unique ID for a RenderArea.

Returns:
A unique ID.
Remarks:
Create a unique ID to identify a RenderArea. Derived classes can use this for their creation.
Example
  GLMFCRAWnd * ra;
  ra = new GLMFCRAWnd());
  RECT rect = {0,0,0,0};
  ra->Create("STATIC", NULL, WS_CHILD, rect, view, (UINT)RenderArea::createNewRenderAreaID());
  ra->init();
See also:
GLMFCRAWnd

virtual NVSG_API void triggerRedraw ( void ) [virtual]

Trigger a redraw of the scene.

Remarks:
You should overload this function in your derived class to trigger a redraw event. On Windows / MFC you would fill this function with, for example, InvalidateRect(NULL) to trigger a call to the OnDraw handler where you then can call renderScene from a well defined place.
Do not call drawScene directly from any other place. Use triggerRedraw whenever your application should redraw the scene.
See also:
renderScene

Reimplemented in GLWinRenderArea, and GLMFCRAWnd.

const nvutil::ProblemLogList & getProblems ( ) [inline]

Get the problem log.

Returns:
Reference to the nvutil::ProblemLogList.
Remarks:
Get a list of all the problems that popped up during initialization of the render area. Check this list after calling init to get an overview of features that the render area could not provide.
See also:
nvutil::ProblemLogList

Member Data Documentation

std::vector<nvtraverser::CullTraverser *> m_cullTraverser [protected]

These traversers cull objects in the tree.

nvtraverser::RenderTraverser* m_renderTraverser [protected]

This traverser renders / displays the tree.

nvtraverser::AppTraverser* m_appTraverser [protected]

This traverser applies all pending changes to the tree.

nvsg::SceneHandle* m_scene [protected]

Pointer to the scene.

m_scene could be NULL !!

nvsg::ViewStateHandle* m_viewState [protected]

Pointer to the view specific controls (camera, animation state,...).

UINT m_features [protected]

All requested features for this render area stereo, multisample, ...

UINT m_numMSBuffers [protected]

Number of multi sample buffers.

bool m_raCreated [protected]

Signal the Create() status.

unsigned int m_raHeight [protected]

Height of the render area.

unsigned int m_raWidth [protected]

Width of the render area.

unsigned int m_idRenderArea [static, protected]

The child window ID for the different CWnd derived render area windows.

Remarks:
Use this ID in the create call (e.g. GLMFCRAWnd)- see CWnd->Create() - Don't forget to increment the ID before using it.

nvutil::ProblemLog m_problemLog [protected]

All problems during the initialization of the render area go here.

The documentation for this class was generated from the following file:
  • RenderArea.h
Generated on Tue Jan 15 10:29:42 2008 for NVSGSDK by NVIDIA


Member List

RenderArea Member List

This is the complete list of members for RenderArea, including all inherited members.
createNewRenderAreaID() | RenderArea | [inline, static]
destroy(void) | RenderArea | [virtual]
getAppTraverser() const | RenderArea | [inline]
getAspectRatio() const | RenderArea | [inline]
getCullTraverser(unsigned int position) const | RenderArea | [inline]
getNumberOfCullTraverser() const | RenderArea | [inline]
getProblems() | RenderArea | [inline]
getRenderTraverser() const | RenderArea | [inline]
getScene() const | RenderArea | [inline]
getViewportHeight() const | RenderArea | [inline]
getViewportWidth() const | RenderArea | [inline]
getViewState() const | RenderArea | [inline]
init(RenderArea *shareArea=NULL) | RenderArea | [virtual]
interruptRender() | RenderArea |
isHWFSAAAvailable() | RenderArea |
isStereoAvailable() | RenderArea |
m_appTraverser | RenderArea | [protected]
m_cullTraverser | RenderArea | [protected]
m_features | RenderArea | [protected]
m_idRenderArea | RenderArea | [protected, static]
m_numMSBuffers | RenderArea | [protected]
m_problemLog | RenderArea | [protected]
m_raCreated | RenderArea | [protected]
m_raHeight | RenderArea | [protected]
m_raWidth | RenderArea | [protected]
m_renderTraverser | RenderArea | [protected]
m_scene | RenderArea | [protected]
m_viewState | RenderArea | [protected]
NVSG_MULTISAMPLE enum value | RenderArea |
NVSG_STEREO enum value | RenderArea |
popCullTraverser() | RenderArea | [inline]
pushCullTraverser(nvtraverser::CullTraverser *tr) | RenderArea | [inline]
RenderArea() | RenderArea | [protected]
renderScene() | RenderArea | [virtual]
requestHWFSAA(bool on, unsigned int numBuffers) | RenderArea |
requestStereoSupport(bool stereo) | RenderArea |
setAppTraverser(nvtraverser::AppTraverser *tr) | RenderArea | [inline]
setRenderTraverser(nvtraverser::RenderTraverser *tr) | RenderArea | [inline]
setScene(nvsg::SceneHandle *scene) | RenderArea | [virtual]
setSceneData(nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState) | RenderArea |
setViewportSize(unsigned int width, unsigned int height) | RenderArea | [virtual]
setViewState(nvsg::ViewStateHandle *viewState) | RenderArea | [virtual]
triggerRedraw(void) | RenderArea | [virtual]
wasRenderInterrupted() const | RenderArea | [inline]
~RenderArea() | RenderArea | [virtual]
Generated on Tue Jan 15 10:29:42 2008 for NVSGSDK by NVIDIA


RenderElement Class Reference

Helper class to hold all the state informations valid for a number of PrimitiveSets. More...

#include <RenderElement.h>

Inheritance diagram for RenderElement:

[legend]
Collaboration diagram for RenderElement:

[legend]
List of all members.

Public Member Functions

NVSG_API | RenderElement (nvsg::StateVariantHandle *svh, ClipPlanesElement *cpe, LightsElement *le, TransformElement *te, bool culling)
Constructor of a RenderElement.

NVSG_API | ~RenderElement ()
Destructor of a RenderElement.

NVSG_API void | addPrimitiveSet (nvsg::PrimitiveSetHandle *psh)
Add a PrimitiveSet to this RenderElement.

NVSG_API ClipPlanesElement * | getClipPlanes () const
Get a pointer to the associated ClipPlanesElement.

NVSG_API LightsElement * | getLights () const
Get a pointer to the associated LightsElement.

NVSG_API unsigned int | getNumberOfPrimitiveSets () const
Get the number of PrimitiveSets in this RenderElement.

NVSG_API unsigned int | getOcclusionCullID () const
Get the occlusion cull ID associated with this RenderElement.

NVSG_API nvsg::PrimitiveSetHandle * | getPrimitiveSet (unsigned int i) const
Get the PrimitiveSet with index i.

NVSG_API float | getSquaredDistance (const nvmath::Mat44f &worldToView)
Get the squared distance of the center of the bounding sphere to the camera.

NVSG_API nvsg::StateVariantHandle * | getStateVariant () const
Get a pointer to the associated StateVariantHandle.

NVSG_API TransformElement * | getTransform () const
Get a pointer to the associated TransformElement.

NVSG_API void | invalidateSquaredDistance ()
Mark the squared distance information as invalid.

NVSG_API bool | isSubjectToCull () const
Query if the PrimitiveSets of this RenderElement are supposed to be culled.

NVSG_API bool | isSquaredDistanceValid () const
Query if the squared distance information is valid.

NVSG_API void | setOcclusionCullID (unsigned int id)
Sets the occlusion cull ID for this RenderElement.

Detailed Description

Helper class to hold all the state informations valid for a number of PrimitiveSets.

Remarks:
This class holds the complete state information valid for a number of PrimitiveSets. This information contains the current StateVariant, and conglomerates informations on the clip planes (ClipPlanesElement), light sources (LightsElement), and transformations (TransformElement).
See also:
BaseRenderElement

Constructor & Destructor Documentation

NVSG_API RenderElement | ( | nvsg::StateVariantHandle * | svh,
 |  | ClipPlanesElement * | cpe,
 |  | LightsElement * | le,
 |  | TransformElement * | te,
 |  | bool | culling
 | ) |

Constructor of a RenderElement.

Parameters:
svh | A pointer to the current StateVariant to be used. May by NULL.
cpe | A pointer to the current ClipPlanesElement to be used.
le | A pointer to the current LightsElement to be used.
te | A pointer to the current TransformElement to be used.
culling | true, if the PrimitiveSets of this RenderElement are allowed to be culled, otherwise false.
Remarks:
To render a scene, all PrimitiveSets in that scene are gathered into a list of RenderElements. Each RenderElement holds a number of PrimitiveSets for which the same states - like clipping, lighting, or transformation - are valid. The StateVariantHandle might be NULL, if there is no valid StateVariant for the following geometries (PrimitiveSets). The other pointers (cpe, le, and te) are not allowed to be NULL, but have to be valid pointers. The reference count of each of those objects is increased.

NVSG_API ~RenderElement ( )

Destructor of a RenderElement.

Remarks:
The reference counts of all the constructor arguments and the added PrimitiveSets are decremented.
See also:
addPrimitiveSet

Member Function Documentation

void addPrimitiveSet ( nvsg::PrimitiveSetHandle * psh ) [inline]

Add a PrimitiveSet to this RenderElement.

Parameters:
psh A pointer to the PrimitiveSet to add.
Remarks:
The reference count of psh is increased.
See also:
getNumberOfPrimitiveSets, getPrimitiveSet

ClipPlanesElement * getClipPlanes ( ) const [inline]

Get a pointer to the associated ClipPlanesElement.

Returns:
A pointer to the associated ClipPlanesElement.
See also:
getLights, getStateVariant, getTransform

LightsElement * getLights ( ) const [inline]

Get a pointer to the associated LightsElement.

Returns:
A pointer to the associated LightsElement.
See also:
getClipPlanes, getStateVariant, getTransform

unsigned int getNumberOfPrimitiveSets ( ) const [inline]

Get the number of PrimitiveSets in this RenderElement.

Returns:
The number of PrimitiveSets in this RenderElement.
See also:
getPrimitiveSet, addPrimitiveSet

unsigned int getOcclusionCullID ( ) const [inline]

Get the occlusion cull ID associated with this RenderElement.

Returns:
The occlusion cull ID associated with this RenderElement.
Remarks:
A RenderElement can have an associated occlusion cull ID. This ID is set and used in the RenderTraverser::occlusionTest, if occlusion culling is on.
See also:
setOcclusionCullID

nvsg::PrimitiveSetHandle * getPrimitiveSet ( unsigned int i ) const [inline]

Get the PrimitiveSet with index i.

Parameters:
i Index of the PrimitiveSet to get.
Returns:
A pointer to the PrimitiveSetHandle that was stored at the i-th position in this RenderElement.
Note:
The behavior is undefined if i is greater or equal to the number of PrimitiveSets in this RenderElement.
See also:
getNumberOfPrimitiveSets, addPrimitveSet

NVSG_API float getSquaredDistance ( const nvmath::Mat44f & worldToView )

Get the squared distance of the center of the bounding sphere to the camera.

Parameters:
worldToView A constant reference to the transformation matrix from world to view space.
Returns:
The squared distance from the center of the bounding sphere of this RenderElement to the camera.
Remarks:
It is assumed, that each call of this function is used with the same worldToView matrix, until the squared distance is explicitly invalidated using invalidateSquaredDistance. This is used, for example, to sort the RenderElements of a render list by distance. In that sorting process, the world to view transformation does not change. That way, the distance can be calculated once, and there is no need to store or compare the transformation matrix.
See also:
invalidateSquaredDistance, isSquaredDistanceValid

nvsg::StateVariantHandle * getStateVariant ( ) const [inline]

Get a pointer to the associated StateVariantHandle.

Returns:
A pointer to the associated StateVariantHandle.
Remarks:
This StateVariant is valid for each PrimitiveSet in this RenderElement.
See also:
getLights, getClipPlanes, getTransform

TransformElement * getTransform ( ) const [inline]

Get a pointer to the associated TransformElement.

Returns:
A pointer to the associated TransformElement.
Remarks:
The TransformElement holds the transformation informations valid for all PrimitiveSets in this RenderElement.
See also:
getLights, getClipPlanes, getStateVariant

void invalidateSquaredDistance ( ) [inline]

Mark the squared distance information as invalid.

Remarks:
Between two frames, the squared distance of each RenderElement should be marked as invalid. That way, they can be sorted by distance to the camera efficiently, without the need to store or compare a world to view transformation.
See also:
getSquaredDistance, isSquaredDistanceValid

bool isSubjectToCull ( ) const [inline]

Query if the PrimitiveSets of this RenderElement are supposed to be culled.

Returns:
true, if the PrimitiveSets of this RenderElement are supposed to be culled, otherwise false.
See also:
getOcclusionCullID, setOcclusionCullID

bool isSquaredDistanceValid ( ) const [inline]

Query if the squared distance information is valid.

Returns:
true, if the squared-distance is of this RenderElement is marked as valid, otherwise false.
Remarks:
While sorting RenderElements by distance, the squared distance to the camera can be queried multiple times, each time with the same world to view transformation matrix. On first calculation of that squared distance, it is marked as valid to make sure the calculation isn't done anymore, until it is explicitly marked as invalid again.
See also:
getSquaredDistance, invalidateSquaredDistance

void setOcclusionCullID ( unsigned int id ) [inline]

Sets the occlusion cull ID for this RenderElement.

Parameters:
id The occlusion cull ID associated to this RenderElement.
Remarks:
A RenderElement can have an associated occlusion cull ID. This ID is set and used in the RenderTraverser::occlusionTest, if occlusion culling is on.
See also:
getOcclusionCullID

The documentation for this class was generated from the following file:
  • RenderElement.h
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


Member List

RenderElement Member List

This is the complete list of members for RenderElement, including all inherited members.
addPrimitiveSet(nvsg::PrimitiveSetHandle *psh) | RenderElement | [inline]
addRef() | BaseRenderElement | [inline]
BaseRenderElement() | BaseRenderElement | [inline, protected]
BaseRenderElement(const BaseRenderElement &rhs) | BaseRenderElement | [inline, protected]
getClipPlanes() const | RenderElement | [inline]
getLights() const | RenderElement | [inline]
getNumberOfPrimitiveSets() const | RenderElement | [inline]
getOcclusionCullID() const | RenderElement | [inline]
getPrimitiveSet(unsigned int i) const | RenderElement | [inline]
getRefCnt() const | BaseRenderElement | [inline]
getSquaredDistance(const nvmath::Mat44f &worldToView) | RenderElement |
getStateVariant() const | RenderElement | [inline]
getTransform() const | RenderElement | [inline]
invalidateSquaredDistance() | RenderElement | [inline]
isSquaredDistanceValid() const | RenderElement | [inline]
isSubjectToCull() const | RenderElement | [inline]
removeRef() | BaseRenderElement | [inline]
RenderElement(nvsg::StateVariantHandle *svh, ClipPlanesElement *cpe, LightsElement *le, TransformElement *te, bool culling) | RenderElement |
setOcclusionCullID(unsigned int id) | RenderElement | [inline]
~BaseRenderElement() | BaseRenderElement | [inline, protected, virtual]
~RenderElement() | RenderElement |
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


RenderElementCompareBackToFront Class Reference

Comparison functor to sort RenderElements from back to front. More...

#include <RenderElement.h>

Collaboration diagram for RenderElementCompareBackToFront:

[legend]
List of all members.

Public Member Functions

NVSG_API | RenderElementCompareBackToFront (const nvmath::Mat44f &worldToView)
Constructor of the functor with world-to-view transformation matrix.

NVSG_API bool | operator() (RenderElement *re0, RenderElement *re1) const
Function-call operator to compare back to front on distance.

Detailed Description

Comparison functor to sort RenderElements from back to front.

Remarks:
This functor class is used to sort RenderElements from back to front. It is used for example to sort the transparent objects in a scene.
See also:
RenderElementCompareFrontToBack

Constructor & Destructor Documentation

NVSG_API RenderElementCompareBackToFront ( const nvmath::Mat44f & worldToView )

Constructor of the functor with world-to-view transformation matrix.

Parameters:
worldToView A reference to the constant world-to-view transformation matrix.
Remarks:
The matrix worldToView is used to determine the distances of the RenderElements to the camera.
See also:
RenderElementCompareFrontToBack

Member Function Documentation

bool operator() | ( | RenderElement * | re0,
 |  | RenderElement * | re1
 | ) | const [inline]

Function-call operator to compare back to front on distance.

Parameters:
re0 | A pointer to the first RenderElement to compare.
re1 | A pointer to the second RenderElement to compare.
Returns:
true, if the squareDistance of re0 is larger than that of re1, otherwise false.

The documentation for this class was generated from the following file:
  • RenderElement.h
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


Member List

RenderElementCompareBackToFront Member List

This is the complete list of members for RenderElementCompareBackToFront, including all inherited members.
operator()(RenderElement *re0, RenderElement *re1) const | RenderElementCompareBackToFront | [inline]
RenderElementCompareBackToFront(const nvmath::Mat44f &worldToView) | RenderElementCompareBackToFront |
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


RenderElementCompareFrontToBack Class Reference

Comparison functor to sort RenderElements from front to back. More...

#include <RenderElement.h>

Collaboration diagram for RenderElementCompareFrontToBack:

[legend]
List of all members.

Public Member Functions

NVSG_API | RenderElementCompareFrontToBack (nvmath::Mat44f &worldToView)
Constructor of the functor with world-to-view transformation matrix.

NVSG_API bool | operator() (RenderElement *re0, RenderElement *re1) const
Function-call operator to compare front to back on distance.

Detailed Description

Comparison functor to sort RenderElements from front to back.

Remarks:
This functor class is used to sort RenderElements from front to back. It is used for example to sort the opaque objects in a scene, when depth sorting is enabled.
See also:
RenderElementCompareFrontToBack

Constructor & Destructor Documentation

NVSG_API RenderElementCompareFrontToBack ( nvmath::Mat44f & worldToView )

Constructor of the functor with world-to-view transformation matrix.

Parameters:
worldToView A reference to the constant world-to-view transformation matrix.
Remarks:
The matrix worldToView is used to determine the distances of the RenderElements to the camera.
See also:
RenderElementCompareBackToFront

Member Function Documentation

bool operator() | ( | RenderElement * | re0,
 |  | RenderElement * | re1
 | ) | const [inline]

Function-call operator to compare front to back on distance.

Parameters:
re0 | A pointer to the first RenderElement to compare.
re1 | A pointer to the second RenderElement to compare.
Returns:
true, if the squareDistance of re0 is smaller than that of re1, otherwise false.

The documentation for this class was generated from the following file:
  • RenderElement.h
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


Member List

RenderElementCompareFrontToBack Member List

This is the complete list of members for RenderElementCompareFrontToBack, including all inherited members.
operator()(RenderElement *re0, RenderElement *re1) const | RenderElementCompareFrontToBack | [inline]
RenderElementCompareFrontToBack(nvmath::Mat44f &worldToView) | RenderElementCompareFrontToBack |
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


RenderElementCompareStateAttributes Class Reference

Comparison functor to sort RenderElements by material. More...

#include <RenderElement.h>

List of all members.

Public Member Functions

NVSG_API bool operator() (RenderElement *re0, RenderElement *re1) const
Function-call operator to compare on StateAttributes in the RenderElements.

Detailed Description

Comparison functor to sort RenderElements by material.

Remarks:
This functor class is used to sort RenderElements from front to back. It is used for example to sort the opaque objects in a scene, when depth sorting is enabled.
See also:
RenderElementCompareFrontToBack, RenderElementBackToFront

Member Function Documentation

bool operator() | ( | RenderElement * | re0,
 |  | RenderElement * | re1
 | ) | const [inline]

Function-call operator to compare on StateAttributes in the RenderElements.

Parameters:
re0 | A pointer to the first RenderElement to compare.
re1 | A pointer to the second RenderElement to compare.
Returns:
true, if re0 is considered to be "less than" re1, in terms of StateAttributes, otherwise false.

The documentation for this class was generated from the following file:
  • RenderElement.h
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


Member List

RenderElementCompareStateAttributes Member List

This is the complete list of members for RenderElementCompareStateAttributes, including all inherited members.
operator()(RenderElement *re0, RenderElement *re1) const RenderElementCompareStateAttributes [inline]
Generated on Tue Jan 15 10:29:34 2008 for NVSGSDK by NVIDIA


RenderTraverser Class Reference

Pure virtual render traverser class. More...

#include <RenderTraverser.h>

Inheritance diagram for RenderTraverser:

[legend]
Collaboration diagram for RenderTraverser:

[legend]
List of all members.

Public Types

enum | GeometryCacheTechnique { GCT_NONE, GCT_DL, GCT_VBO }
enum JitterTechnique {
JT_NONE, JT_READ_PIXELS, JT_ACCUM, JT_PBUFFER,
JT_FBO
}
enum | RenderTechnique { RT_UNLIT, RT_SHADED, RT_TEXTURED, RT_EFFECTED }
enum | ShadowTechnique { ST_NONE, ST_SHADOW_MAP }
Enumeration of supported shadowing techniques. More...

enum | SortingPolicy { SP_NONE, SP_DEPTH, SP_STATE }
Enumeration of supported sorting policies. More...

enum TransparencyTechnique {
TT_NONE, TT_STIPPLED, TT_BLENDED, TT_SORTED_BLENDED,
TT_ORDER_INDEPENDENT, TT_MULTISAMPLE
}
enum | OITTechnique { OT_TEXTURE, OT_PBUFFER, OT_FBO }

Public Member Functions

NVSG_API GeometryCacheTechnique | getGeometryCacheTechnique (void) const
Get the current geometry caching technique.

virtual NVSG_API bool | isGeometryCacheTechniqueSupported (GeometryCacheTechnique gct) const
Test on supported geometry caching techniques.

virtual NVSG_API void | setGeometryCacheTechnique (GeometryCacheTechnique gct)
Set the geometry caching technique the render should use.

NVSG_API JitterTechnique | getJitterTechnique (void) const
Get the current jitter technique.

virtual NVSG_API bool | isJitterTechniqueSupported (JitterTechnique jt) const
Interface to test for support of a jitter technique.

NVSG_API void | setJitterTechnique (JitterTechnique jt)
Set the jitter technique the render should use. Set the jitter technique to use.

NVSG_API bool | isFrontFaceCulling () const
Get the front face culling state.

NVSG_API bool | isBackFaceCulling () const
Get the back face culling state.

NVSG_API void | setFaceCulling (bool front, bool back)
Set the face culling states.

NVSG_API bool | isFaceCullingOverwrite () const
Ask if the face culling states of the RenderTraverser overwrites the face culling states of a FaceAttribute.

NVSG_API void | setFaceCullingOverwrite (bool overwrite)
Set the face culling states of the RenderTraverser to overwrite the face culling states of a FaceAttribute.

NVSG_API nvsg::FaceMode | getFaceMode (void) const
Get the FaceMode to use for faces.

NVSG_API void | setFaceMode (nvsg::FaceMode mode)
Set the FaceMode to use for faces.

NVSG_API bool | isFaceModeOverwrite () const
Ask if the FaceMode of the RenderTraverser overwrites the FaceMode of a FaceAttribute.

NVSG_API void | setFaceModeOverwrite (bool overwrite)
Set if the FaceMode of the RenderTraverser overwrites the FaceMode of a FaceAttribute.

NVSG_API bool | isTwoSidedLighting () const
Ask if two sided lighting is on.

NVSG_API void | setTwoSidedLighting (bool enable)
Set the two sided lighting state.

NVSG_API bool | isTwoSidedLightingOverwrite () const
Ask if the two-sided lighting state of the RenderTraverser overwrite the state of a FaceAttribute. */.

NVSG_API void | setTwoSidedLightingOverwrite (bool overwrite)
Set if the two-sided lighting state of the RenderTraverser overwrites the state of a FaceAttribute. */.

NVSG_API RenderTechnique | getRenderTechnique (void) const
Get the current render technique.

virtual NVSG_API bool | isRenderTechniqueSupported (RenderTechnique rt) const
Test on supported render techniques.

NVSG_API void | setRenderTechnique (RenderTechnique rt)
Set the render technique the render should use.

NVSG_API ShadowTechnique | getShadowTechnique (void) const
Get the current shadowing technique.

virtual NVSG_API bool | isShadowTechniqueSupported (ShadowTechnique st) const
Test on supported shadowing techniques.

virtual NVSG_API void | setShadowTechnique (ShadowTechnique st)
Set the shadow technique to use.

NVSG_API unsigned int | getShadowMapSize (void) const
Get the size of the shadow maps.

virtual NVSG_API void | setShadowMapSize (unsigned int size)
Set the size of the shadow maps.

NVSG_API float | getShadowMapIntensity (void) const
Get the shadow map intensity.

NVSG_API void | setShadowMapIntensity (float intensity)
Set the shadow map intensity.

NVSG_API unsigned int | getTextureSizeLimit (void) const
Get the texture size limit.

virtual NVSG_API void | setTextureSizeLimit (unsigned int size)
Set the texture size limit.

NVSG_API TransparencyTechnique | getTransparencyTechnique (void) const
Get the current transparency technique.

virtual NVSG_API bool | isTransparencyTechniqueSupported (TransparencyTechnique tt) const
Test on supported transparency techniques.

virtual NVSG_API void | setTransparencyTechnique (TransparencyTechnique tt)
Set the transparency technique the render should use.

NVSG_API OITTechnique | getOITTechnique (void) const
Get the current OIT (Order Independent Transparency) technique.

virtual NVSG_API bool | isOITTechniqueSupported (OITTechnique ot) const
Test on supported OIT techniques.

virtual NVSG_API void | setOITTechnique (OITTechnique ot)
Set the OIT technique the render should use.

NVSG_API unsigned int | getOITMaxPasses (void) const
Get maximum OIT passes.

virtual NVSG_API void | setOITMaxPasses (unsigned int maxPasses)
Set the number of maximum passes to achieve the desired transparency effect.

NVSG_API float | getOITThreshold (void) const
Get the current threshold.

NVSG_API void | setOITThreshold (float threshold)
Set the threshold.

NVSG_API void | setLineAntiAliasing (bool onOff)
Set the anti-aliasing mode for wire frame drawings.

NVSG_API bool | isLineAntiAliasingEnabled (void) const
Test if the line anti-aliasing is turned on / off.

NVSG_API float | getLineWidth (void) const
Get the line width for wire frame drawings.

NVSG_API void | setLineWidth (float width)
Set the line width for wire frame drawings.

NVSG_API void | setPointAntiAliasing (bool onOff)
Set the anti-aliasing mode for point mode drawings.

NVSG_API bool | isPointAntiAliasingEnabled (void) const
Get the anti-aliasing mode for point mode drawings.

NVSG_API float | getPointSize (void) const
Get the point size for point mode drawings.

NVSG_API void | setPointSize (float size)
Set the point size for point mode drawings.

NVSG_API void | setSortingPolicy (SortingPolicy sp)
Set the sorting policy.

NVSG_API SortingPolicy | getSortingPolicy (void) const
Get the current sorting policy.

virtual NVSG_API bool | isOcclusionCullingSupported (void) const
Test on occlusion culling support.

virtual NVSG_API void | setOcclusionCulling (bool onOff)
Set occlusion Culling.

NVSG_API bool | isOcclusionCulling (void) const
Test if occlusion culling is on.

Protected Member Functions

NVSG_API | RenderTraverser (void)
Default constructor.

virtual NVSG_API | ~RenderTraverser (void)
Default destructor.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Initiate traversing a given scene graph.

virtual NVSG_API void | doRender (nvsg::NodeHandle *root)=0
Initiate rendering the prepared scene.

virtual NVSG_API void | handleAnimatedVertexAttributeSet (const nvsg::AnimatedVertexAttributeSet *p)
handleAnimatedVertexAttributeSet override for specialized handling of AnimatedVertexAttributeSet.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Traverse a Billboard.

virtual NVSG_API void | handleStateVariant (const nvsg::StateVariant *p)
Traverse a StateVariant.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Traverse a Billboard.

virtual NVSG_API void | handleVolumeNode (const nvsg::VolumeNode *p)
Traverse a VolumeNode.

virtual NVSG_API bool | preTraverseDrawables (const nvsg::GeoNode *p, unsigned int i)
Prepares render list setup for coherent Drawables.

virtual NVSG_API void | postTraverseDrawables (const nvsg::GeoNode *p, unsigned int i)
Does post-processing after coherent Drawables have been compiled into a render list. */.

virtual NVSG_API bool | preTraverseGroup (const nvsg::Group *p)
Handle a Group before traversing it.

virtual NVSG_API void | postTraverseGroup (const nvsg::Group *p)
Handle a Group after traversing it.

virtual NVSG_API bool | preTraverseTransform (const nvmath::Trafo *p)
Handle a Transform before traversing it.

virtual NVSG_API void | postTraverseTransform (const nvmath::Trafo *p)
Handle a Transform after traversing it.

virtual NVSG_API void | traverseLight (const nvsg::LightSource *p)
Handle a LightSource on traversal.

virtual NVSG_API void | traversePrimitiveSet (const nvsg::PrimitiveSet *p)
Handle a PrimitiveSet on traversal.

NVSG_API bool | isHighlightPass (void) const
Returns whether the RenderTraverser is currently processing highlights.

NVSG_API bool | isOverlayPass (void) const
Determine if the rendering is in the overlay pass.

NVSG_API bool | isTransparentPass (void) const
Determine if the rendering is in the transparent pass.

virtual NVSG_API void | renderBegin (void)
Initiates rendering of the built render lists.

NVSG_API virtual void render( const nvsg::Camera * cam );.

virtual NVSG_API void | renderEnd (void)
End the rendering process.

void | renderObject (nvsg::ObjectHandle *oh)
Start rendering a general object.

template<typename RendererType> void | addObjectRenderer (unsigned int objectCode, RendererType renderer)
Add a render routine for a concrete Object derived object.

template<typename T> void | renderObject (nvsg::ObjectHandle *oh, T arg)
Start rendering a general object.

virtual NVSG_API void | renderBillboard (const nvsg::Billboard *p)
Evaluate the Trafo of a Billboard while rendering from a render list.

virtual NVSG_API void | renderBlendAttribute (const nvsg::BlendAttribute *p, bool enable)
Render a BlendAttribute out of a render list.

virtual NVSG_API void | renderAlphaTestAttribute (const nvsg::AlphaTestAttribute *p, bool enable)
Render a AlphaTestAttribute out of a render list.

virtual NVSG_API void | renderCgFx (const nvsg::CgFx *p, bool enable)
Render a CgFx out of a render list.

virtual NVSG_API void | renderDepthAttribute (const nvsg::DepthAttribute *p, bool enable)
Render a DepthAttribute out of a render list.

virtual NVSG_API void | renderDirectedLight (const nvsg::DirectedLight *p, bool enable)
Render a DirectedLight out of a render list.

virtual NVSG_API void | renderFaceAttribute (const nvsg::FaceAttribute *p, bool enable)
Render a FaceAttribute out of a render list.

virtual NVSG_API void | renderHighlightBox (const nvsg::HighlightBox *p)
Render a HighlightBox out of a render list.

virtual NVSG_API void | renderHighlightEdges (const nvsg::HighlightEdges *p)
Render a HighlightEdges out of a render list.

virtual NVSG_API void | renderLightingAttribute (const nvsg::LightingAttribute *p, bool enable)
Render a LineAttribute out of a render list.

virtual NVSG_API void | renderLineAttribute (const nvsg::LineAttribute *p, bool enable)
Render a LineAttribute out of a render list.

virtual NVSG_API void | renderLines (const nvsg::Lines *p)
Render a Lines out of a render list.

virtual NVSG_API void | renderLineStrips (const nvsg::LineStrips *p)
Render a LineStrips out of a render list.

virtual NVSG_API void | renderPointAttribute (const nvsg::PointAttribute *p, bool enable)
Render a PointAttribute out of a render list.

virtual NVSG_API void | renderPoints (const nvsg::Points *p)
Render a Points out of a render list.

virtual NVSG_API void | renderMaterial (const nvsg::Material *p, bool enable)
Render a Material out of a render list.

virtual NVSG_API void | renderParallelCamera (const nvsg::ParallelCamera *p)
Render a ParallelCamera out of a render list.

virtual NVSG_API void | renderPerspectiveCamera (const nvsg::PerspectiveCamera *p)
Render a PerspectiveCamera out of a render list.

virtual NVSG_API void | renderPointLight (const nvsg::PointLight *p, bool enable)
Render a PointLight out of a render list.

virtual NVSG_API void | renderQuads (const nvsg::Quads *p)
Render a Quads out of a render list.

virtual NVSG_API void | renderQuadMeshes (const nvsg::QuadMeshes *p)
Render a QuadMeshes out of a render list.

virtual NVSG_API void | renderQuadStrips (const nvsg::QuadStrips *p)
Render a QuadStrips out of a render list.

virtual NVSG_API void | renderSkinnedTriangles (const nvsg::SkinnedTriangles *p)
Render a SkinnedTriangles out of a render list.

virtual NVSG_API void | renderSpotLight (const nvsg::SpotLight *p, bool enable)
Render a SpotLight out of a render list.

virtual NVSG_API void | renderStatePass (const nvsg::StatePass *p)
Render a StatePass out of a render list.

virtual NVSG_API void | renderTextureAttribute (const nvsg::TextureAttribute *p, bool enable)
Render a TextureAttribute out of a render list.

virtual NVSG_API void | renderTextureAttributeItem (const nvsg::TextureAttributeItem *p, unsigned int tu)
Render a TextureAttributeItem out of a render list.

virtual NVSG_API void | renderTransform (const nvsg::Transform *p)
Evaluate the Trafo of a Transform while rendering from a render list.

virtual NVSG_API void | renderTriangles (const nvsg::Triangles *p)
Render a Triangles out of a render list.

virtual NVSG_API void | renderTriFans (const nvsg::TriFans *p)
Render a TriFans out of a render list.

virtual NVSG_API void | renderTriStrips (const nvsg::TriStrips *p)
Render a TriStrips out of a render list.

virtual NVSG_API void | renderUnlitColorAttribute (const nvsg::UnlitColorAttribute *p, bool enable)
Render an UnlitColorAttribute out of a render list.

virtual NVSG_API void | setClipPlane (unsigned int index, const nvmath::Plane3f &plane, bool enable)
Set a clipping plane.

virtual NVSG_API void | setTransforms (const nvmath::Mat44f &modelToWorld, const nvmath::Mat44f &worldToModel, bool needsNormalize, bool needsMirror)
Set the current model to world and world to model transforms.

virtual NVSG_API void | overlayBegin (void)
Indication of the beginning of the overlay parts.

virtual NVSG_API void | overlayEnd (void)
Indication of the end of the overlay parts.

virtual NVSG_API void | transparentBegin (void)
Indication of the beginning of rendering transparent parts.

virtual NVSG_API void | transparentEnd (void)
Indication of the end of rendering transparent parts.

virtual NVSG_API void | highlightBegin (void)
Indication of the beginning of rendering highlighted parts.

virtual NVSG_API void | highlightEnd (void)
Indication of the end of rendering highlighted parts.

virtual NVSG_API void | primitiveSetsBegin ()
Initiates PrimitiveSet rendering.

virtual NVSG_API bool | primitiveSetsEnd ()
Post-processes PrimitiveSet rendering.

NVSG_API nvsg::CgFxHandle * | getCurrentCgFx (void) const
Get the current CgFx while rendering.

virtual NVSG_API void | assignDirectedLightToEffectLight (nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::DirectedLight *directedLight, const nvmath::Mat44f &modelToWorld)
Assigns current settings of a DirectedLight to the specified effect light parameter.

virtual NVSG_API void | assignPointLightToEffectLight (nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::PointLight *pointLight, const nvmath::Mat44f &modelToWorld)
Assigns current settings of a PointLight to the specified effect light parameter.

virtual NVSG_API void | assignSpotLightToEffectLight (nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::SpotLight *spotLight, const nvmath::Mat44f &modelToWorld)
Assigns current settings of a SpotLight to the specified effect light parameter.

virtual NVSG_API void | assignCustomLightToEffectLight (nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::LightSource *customLight, const nvmath::Mat44f &modelToWorld)
Assigns current settings of a custom LightSource to the specified effect light parameter.

virtual NVSG_API unsigned int | createOcclusionCullID (void)
Create an occlusion culling ID.

virtual NVSG_API void | destroyOcclusionCullID (unsigned int id)
Destroy an occlusion culling ID.

virtual NVSG_API void | beginOcclusionCullQuery (unsigned int id)
Begin an occlusion culling test.

virtual NVSG_API void | endOcclusionCullQuery (unsigned int id)
End an occlusion culling test.

virtual NVSG_API unsigned int | getOcclusionCullResult (unsigned int id)
Get the result of an occlusion culling test.

virtual NVSG_API void | hiddenBegin (void)
Begin rendering of the hidden drawing elements.

virtual NVSG_API void | hiddenEnd (void)
End rendering of the hidden drawing elements.

NVSG_API void | clearRenderLists (void)
Clears all render lists.

NVSG_API unsigned int | getRasterOffsetX () const
Get the raster offset in x direction of this render traversal.

NVSG_API unsigned int | getRasterOffsetY () const
Get the raster offset in y direction of this render traversal.

NVSG_API void | setCollectRenderElements (bool value)
Set whether RenderElements should be collected.

NVSG_API bool | getCollectRenderElements (void) const
Get whether RenderElements are collected.

NVSG_API void | occlusionTest (std::list< RenderElement * > &visibleList, std::list< RenderElement * > &hiddenList)
Update visible and hidden list by the occlusion test results.

Protected Attributes

std::list< RenderElement * > | m_visibleOpaqueList
std::list< RenderElement * > | m_hiddenOpaqueList
std::list< RenderElement * > | m_visibleTransparentList
std::list< RenderElement * > | m_hiddenTransparentList
bool | m_collectRenderElements
RenderElement * | m_currentRenderElement
RenderElement * | m_lastRenderElement

Detailed Description

Pure virtual render traverser class.

Use this pure virtual class as a base class to derive your own render traverser. Render traverser are not allowed to apply changes to the given scenegraph. This base class contains the model matrix and inverse model matrix stack. This is very handy, because you do not have to ask e.g. OpenGL which would be normally very expensive. So your special render traverser has to take care of these stacks.

Note:
The render traverser object must not survive the render area it works on. For e.g. RenderArea and GLTraverser make sure to make the render area current before destroying the traverser.

Needs a valid ViewState. Call setViewState prior to apply().

Member Enumeration Documentation

enum GeometryCacheTechnique

Enumeration values:
GCT_NONE | no geometry caching
GCT_DL | cache geometries in display lists
GCT_VBO | cache geometries in vertex buffer objects

enum JitterTechnique

Enumeration values:
JT_NONE | Render non-jittered.
JT_READ_PIXELS | Render to backbuffer and use e.g. OpenGL read pixels to read it back.
JT_ACCUM | Render to accumulation buffer.
JT_PBUFFER | Render to PBuffer.
JT_FBO | Render to an FBO.

enum RenderTechnique

Enumeration values:
RT_UNLIT | Render scene without lighting.
RT_SHADED | Render scene in simple shading mode.
RT_TEXTURED | Render scene in simple shading mode plus textures.
RT_EFFECTED | Render scene fully effected and shaded.

enum ShadowTechnique

Enumeration of supported shadowing techniques.

Enumeration values:
ST_NONE | don't do any shadowing
ST_SHADOW_MAP | shadow using shadow maps

enum SortingPolicy

Enumeration of supported sorting policies.

Enumeration values:
SP_NONE | don't sort
SP_DEPTH | depth sort
SP_STATE | state sort

enum TransparencyTechnique

Enumeration values:
TT_NONE | Ignore transparency, draw opaque.
TT_STIPPLED | Use stipple patterns to simulate transparency.
TT_BLENDED | Use blending to render transparent objects.
TT_SORTED_BLENDED | Sort transparent objects and use blending to render them.
TT_ORDER_INDEPENDENT | Use the "Order Independent Transparency" approach to render transparent objects.
TT_MULTISAMPLE | Use MultiSample ALPHA_TO_COVERAGE to render transparent objects.

enum OITTechnique

Enumeration values:
OT_TEXTURE | Use textures for OIT.
OT_PBUFFER | Use PBuffers for OIT.
OT_FBO | Use FBOs for OIT.

Constructor & Destructor Documentation

NVSG_API RenderTraverser ( void ) [protected]

Default constructor.

virtual NVSG_API ~RenderTraverser ( void ) [protected, virtual]

Default destructor.

Member Function Documentation

RenderTraverser::GeometryCacheTechnique getGeometryCacheTechnique ( void ) const [inline]

Get the current geometry caching technique.

virtual NVSG_API bool isGeometryCacheTechniqueSupported ( GeometryCacheTechnique gct ) const [virtual]

Test on supported geometry caching techniques.

Use this method to test if this special geometry caching technique is supported.

Returns:
true - supported, false - not supported.
Parameters:
gct GeometryCache technique.

Reimplemented in GLTraverser.

virtual NVSG_API void setGeometryCacheTechnique ( GeometryCacheTechnique gct ) [virtual]

Set the geometry caching technique the render should use.

Parameters:
gct GeometryCache technique.

Reimplemented in GLTraverser.

RenderTraverser::JitterTechnique getJitterTechnique ( void ) const [inline]

Get the current jitter technique.

Returns:
the currently used jitter technique.
See also:
isJitterTechniqueSupported, setJitterTechnique

virtual NVSG_API bool isJitterTechniqueSupported ( JitterTechnique jt ) const [virtual]

Interface to test for support of a jitter technique.

Parameters:
jt The jitter technique to test for support.
Returns:
true if the jitter technique jt is supported, otherwise false.
Remarks:
Depending on the current graphics hardware, some jitter techniques might not be supported. Only supported jitter techniques should be used.
See also:
getJitterTechnique, setJitterTechnique

Reimplemented in GLTraverser.

void setJitterTechnique ( JitterTechnique jt ) [inline]

Set the jitter technique the render should use. Set the jitter technique to use.

Parameters:
jt The jitter technique to use.
Remarks:
The behavior is undefined if the jitter technique jt is not supported.
See also:
getJitterTechnique, isJitterTechniqueSupported

bool isFrontFaceCulling ( ) const [inline]

Get the front face culling state.

The front face culling state of the RenderTraverser can overwrite any front face culling state in a FaceAttribute.

bool isBackFaceCulling ( ) const [inline]

Get the back face culling state.

The back face culling state of the RenderTraverser can overwrite any back face culling state in a FaceAttribute.

void setFaceCulling | ( | bool | front,
 |  | bool | back
 | ) | [inline]

Set the face culling states.

The face culling states of the RenderTraverser can overwrite any face culling states in a FaceAttribute.

bool isFaceCullingOverwrite ( ) const [inline]

Ask if the face culling states of the RenderTraverser overwrites the face culling states of a FaceAttribute.

void setFaceCullingOverwrite ( bool overwrite ) [inline]

Set the face culling states of the RenderTraverser to overwrite the face culling states of a FaceAttribute.

nvsg::FaceMode getFaceMode ( void ) const [inline]

Get the FaceMode to use for faces.

The FaceMode of the RenderTraverser can overwrite any FaceMode in a FaceAttribute.

void setFaceMode ( nvsg::FaceMode mode ) [inline]

Set the FaceMode to use for faces.

The FaceMode of the RenderTraverser can overwrite any FaceMode in a FaceAttribute.

bool isFaceModeOverwrite ( ) const [inline]

Ask if the FaceMode of the RenderTraverser overwrites the FaceMode of a FaceAttribute.

void setFaceModeOverwrite ( bool overwrite ) [inline]

Set if the FaceMode of the RenderTraverser overwrites the FaceMode of a FaceAttribute.

bool isTwoSidedLighting ( ) const [inline]

Ask if two sided lighting is on.

The two sided lighting state of the RenderTraverser can overwrite and FaceAttribute.

void setTwoSidedLighting ( bool enable ) [inline]

Set the two sided lighting state.

The two sided lighting state of the RenderTraverser can overwrite and FaceAttribute.

bool isTwoSidedLightingOverwrite ( ) const [inline]

Ask if the two-sided lighting state of the RenderTraverser overwrite the state of a FaceAttribute. */.

void setTwoSidedLightingOverwrite ( bool overwrite ) [inline]

Set if the two-sided lighting state of the RenderTraverser overwrites the state of a FaceAttribute. */.

RenderTraverser::RenderTechnique getRenderTechnique ( void ) const [inline]

Get the current render technique.

virtual NVSG_API bool isRenderTechniqueSupported ( RenderTechnique rt ) const [virtual]

Test on supported render techniques.

Use this technique to test if this special render technique is currently available.

Returns:
true - supported, false - not supported.
Parameters:
rt Render technique.

Reimplemented in GLTraverser.

NVSG_API void setRenderTechnique ( RenderTechnique rt )

Set the render technique the render should use.

Parameters:
rt Render technique.

RenderTraverser::ShadowTechnique getShadowTechnique ( void ) const [inline]

Get the current shadowing technique.

Returns:
the currently used shadowing technique.

virtual NVSG_API bool isShadowTechniqueSupported ( ShadowTechnique st ) const [virtual]

Test on supported shadowing techniques.

Use this to test if this special shadow technique is currently available.

Returns:
true - supported, false - not supported.
Parameters:
st shadow technique to test

Reimplemented in GLTraverser.

virtual NVSG_API void setShadowTechnique ( ShadowTechnique st ) [virtual]

Set the shadow technique to use.

Returns:
true - everything went fine, false - not set
Parameters:
st shadow technique to use

Reimplemented in GLTraverser.

unsigned int getShadowMapSize ( void ) const [inline]

Get the size of the shadow maps.

Returns:
the size of the shadow maps.

virtual NVSG_API void setShadowMapSize ( unsigned int size ) [virtual]

Set the size of the shadow maps.

The size must be a power of two. The default size is 1024.

Parameters:
size size of shadow maps

Reimplemented in GLTraverser.

float getShadowMapIntensity ( void ) const [inline]

Get the shadow map intensity.

The shadow map intensity describes the depth of the shadows. The intensity is between 0.0 and 1.0. With intensity 0.0 there are no shadows at all. With intensity 1.0 the shadows are completely black. With an intensity in between the darkness (or depth) of the shadows varies linear. The default is 0.9, resulting in a rather dark shadow.

void setShadowMapIntensity ( float intensity ) [inline]

Set the shadow map intensity.

The shadow map intensity has to be between 0.0 and 1.0 (inclusive). With intensity 0.0 there are no shadows at all. With intensity 1.0 the shadows are completely black. With an intensity in between the darkness (or depth) of the shadows varies linear.

unsigned int getTextureSizeLimit ( void ) const [inline]

Get the texture size limit.

Textures are scaled down to that limit if they are larger.

Returns:
the current texture size limit.

virtual NVSG_API void setTextureSizeLimit ( unsigned int size ) [virtual]

Set the texture size limit.

Textures are scaled down to that limit if they are larger.

Note:
Setting the size to 0 (zero), disables texture size limit.
Parameters:
size texture size limit

Reimplemented in GLTraverser.

RenderTraverser::TransparencyTechnique getTransparencyTechnique ( void ) const [inline]

Get the current transparency technique.

virtual NVSG_API bool isTransparencyTechniqueSupported ( TransparencyTechnique tt ) const [virtual]

Test on supported transparency techniques.

Use this technique to test if this special transparency technique is currently available.

Returns:
true - supported, false - not supported.
Parameters:
tt Transparency technique.

Reimplemented in GLTraverser.

virtual NVSG_API void setTransparencyTechnique ( TransparencyTechnique tt ) [virtual]

Set the transparency technique the render should use.

Parameters:
tt Transparency technique.

Reimplemented in GLTraverser.

RenderTraverser::OITTechnique getOITTechnique ( void ) const [inline]

Get the current OIT (Order Independent Transparency) technique.

virtual NVSG_API bool isOITTechniqueSupported ( OITTechnique ot ) const [virtual]

Test on supported OIT techniques.

Use this technique to test if this special OIT technique is currently available.

Returns:
true - supported, false - not supported.
Parameters:
ot OIT technique

Reimplemented in GLTraverser.

virtual NVSG_API void setOITTechnique ( OITTechnique ot ) [virtual]

Set the OIT technique the render should use.

Returns:
true - everything went fine, false - not set
Parameters:
ot OIT technique

Reimplemented in GLTraverser.

unsigned int getOITMaxPasses ( void ) const [inline]

Get maximum OIT passes.

Returns:
Maximum rendering passes to archive the desired effect.

virtual NVSG_API void setOITMaxPasses ( unsigned int maxPasses ) [virtual]

Set the number of maximum passes to achieve the desired transparency effect.

Parameters:
maxPasses Maximum passes to render, even when threshold is not reached.

Reimplemented in GLTraverser.

float getOITThreshold ( void ) const [inline]

Get the current threshold.

Returns:
threshold [0,1]

void setOITThreshold ( float threshold ) [inline]

Set the threshold.

The threshold tells the refinement step of the OIT algorithm if it needs another pass or if it is good enough to show the rendered result. The value lies between 0 and 1 (0%-100%). The refinement step compares the percentage of drawn pixels with the threshold and stops if it is smaller than the user defined value.

Parameters:
threshold Threshold [0,1]

void setLineAntiAliasing ( bool onOff ) [inline]

Set the anti-aliasing mode for wire frame drawings.

Parameters:
onOff enables/disables line anti-aliasing

bool isLineAntiAliasingEnabled ( void ) const [inline]

Test if the line anti-aliasing is turned on / off.

Returns:
true, if line anti-aliasing is on, otherwise false.

float getLineWidth ( void ) const [inline]

Get the line width for wire frame drawings.

Returns:
the line width for wire frame drawings.

void setLineWidth ( float width ) [inline]

Set the line width for wire frame drawings.

Parameters:
width line width to set

void setPointAntiAliasing ( bool onOff ) [inline]

Set the anti-aliasing mode for point mode drawings.

Parameters:
onOff enables/disables point anti-aliasing

bool isPointAntiAliasingEnabled ( void ) const [inline]

Get the anti-aliasing mode for point mode drawings.

Returns:
true, if point anti-aliasing is on, otherwise false.

float getPointSize ( void ) const [inline]

Get the point size for point mode drawings.

Returns:
the point size for point mode drawings.

void setPointSize ( float size ) [inline]

Set the point size for point mode drawings.

Parameters:
size point size to set

void setSortingPolicy ( SortingPolicy sp ) [inline]

Set the sorting policy.

Opaque elements can be sorted by a number of policies. Currently you can switch off any sorting, sort them by states, thus minimizing state switches which can hurt performance, or you can sort by depth from front to back. Sorting by depth is highly recommended if you also enable occlusion culling.

Parameters:
sp sorting policy to use

RenderTraverser::SortingPolicy getSortingPolicy ( void ) const [inline]

Get the current sorting policy.

Returns:
The current sorting policy.

virtual NVSG_API bool isOcclusionCullingSupported ( void ) const [virtual]

Test on occlusion culling support.

Any render traverser supporting occlusion culling, should return true here.

Returns:
The base implementation returns false.

Reimplemented in GLTraverser.

virtual NVSG_API void setOcclusionCulling ( bool onOff ) [virtual]

Set occlusion Culling.

Parameters:
onOff enables/disables occlusion culling

bool isOcclusionCulling ( void ) const [inline]

Test if occlusion culling is on.

Returns:
true, if occlusion culling is on, otherwise false.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Initiate traversing a given scene graph.

See nvtraverser::Traverser::doApply for more information.

Note:
All RenderTraverser based classes need a valid nvsg::ViewState . If the ViewState is not valid the runtime behavior is not defined. Call setViewState() with a valid ViewState prior calling apply().

Reimplemented from SharedTraverser.

Reimplemented in GLTraverser, and GLUploadTraverser.

virtual NVSG_API void doRender ( nvsg::NodeHandle * root ) [protected, pure virtual]

Initiate rendering the prepared scene.

Implemented in GLTraverser, and GLUploadTraverser.

virtual NVSG_API void handleAnimatedVertexAttributeSet ( const nvsg::AnimatedVertexAttributeSet * p ) [protected, virtual]

handleAnimatedVertexAttributeSet override for specialized handling of AnimatedVertexAttributeSet.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Traverse a Billboard.

Store p as the current transform and continue traversal with ModelViewTraverser::handleBillboard.

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleStateVariant ( const nvsg::StateVariant * p ) [protected, virtual]

Traverse a StateVariant.

Stores some informations of this StateVariant as current. Because it is not necessary to further traverse down the tree, ModelViewTraverser::handleStateVariant is not called here.

Parameters:
p StateVariant to traverse

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Traverse a Billboard.

Store p as the current transform and continue traversal with ModelViewTraverser::handleTranform.

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void handleVolumeNode ( const nvsg::VolumeNode * p ) [protected, virtual]

Traverse a VolumeNode.

Sets the "volumeSize" of the volume CgFx, traverses using SharedModelTraverser::handleVolumeNode(), and handles highlighting of the VolumeNode if the level to display is not the top level (0).

Reimplemented from SharedTraverser.

virtual NVSG_API bool preTraverseDrawables | ( | const nvsg::GeoNode * | p,
 |  | unsigned int | i
 | ) | [protected, virtual]

Prepares render list setup for coherent Drawables.

Parameters:
p | The GeoNode which owns the Drawables.
i | Geometry index to the coherent Drawables.

Reimplemented from Traverser.

virtual NVSG_API void postTraverseDrawables | ( | const nvsg::GeoNode * | p,
 |  | unsigned int | i
 | ) | [protected, virtual]

Does post-processing after coherent Drawables have been compiled into a render list. */.

Parameters:
p | The GeoNode which owns the Drawables.
i | Geometry index to the coherent Drawables.

Reimplemented from Traverser.

virtual NVSG_API bool preTraverseGroup ( const nvsg::Group * p ) [protected, virtual]

Handle a Group before traversing it.

The information on currently active lights is stored, then ModelViewTraverser::preTraverseGroup() is called for further pre traversal processing.

Parameters:
p Group to handle pre-traversal

Reimplemented from Traverser.

virtual NVSG_API void postTraverseGroup ( const nvsg::Group * p ) [protected, virtual]

Handle a Group after traversing it.

After calling ModelViewTraverser::postTraverseGroup() for other post traversal processing on that Group, the information on the currently active lights is restored from what was current before traversing that Group.

Parameters:
p Group to handle post-traversal

Reimplemented from Traverser.

virtual NVSG_API bool preTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handle a Transform before traversing it.

The information on the current transform is stored, then ModelViewTraverser::preTraverseTransform() is called for further pre traversal processing.

Parameters:
p Trafo of node to handle pre-traversal

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void postTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handle a Transform after traversing it.

After calling ModelViewTraverser::postTraverseTransform() for other post traversal processing on that Transform, transformation informations are restored from what was current before traversing that Transform.

Parameters:
p Trafo of node to handle post-traversal

Reimplemented from SharedModelViewTraverser.

virtual NVSG_API void traverseLight ( const nvsg::LightSource * p ) [protected, virtual]

Handle a LightSource on traversal.

The currently active lights are extended by this LightSource, then ModelViewTraverser::traverseLight() is called for further traversal.

Parameters:
p LightSource to traverse

Reimplemented from SharedTraverser.

virtual NVSG_API void traversePrimitiveSet ( const nvsg::PrimitiveSet * p ) [protected, virtual]

Handle a PrimitiveSet on traversal.

Depending on a variety of transparency informations, that PrimitiveSet, together with informations on the currently active lights, StateSet, and transformations is stored in either the transparent or the opaque render list. Then ModelViewTraverser::traversePrimitiveSet() is called for further traversal.

Parameters:
p PrimitiveSet to traverse

Reimplemented from SharedTraverser.

bool isHighlightPass ( void ) const [inline, protected]

Returns whether the RenderTraverser is currently processing highlights.

Returns:
true if the RenderTraverser is currently rendering the highlight list, otherwise the function returns false.

bool isOverlayPass ( void ) const [inline, protected]

Determine if the rendering is in the overlay pass.

Returns:
true if currently the overlay geometries are rendered, otherwise false.

bool isTransparentPass ( void ) const [inline, protected]

Determine if the rendering is in the transparent pass.

Returns:
true if currently the transparent geometries are rendered, otherwise false.

virtual NVSG_API void renderBegin ( void ) [protected, virtual]

Initiates rendering of the built render lists.

NVSG_API virtual void render( const nvsg::Camera * cam );.

! Begin the rendering process. /** Before rendering the first object, this function is called.

Reimplemented in GLTraverser.

virtual NVSG_API void renderEnd ( void ) [protected, virtual]

End the rendering process.

After rendering the last object, this function is called.

Reimplemented in GLTraverser.

void renderObject ( nvsg::ObjectHandle * oh ) [inline, protected]

Start rendering a general object.

The function first waits to gain read access to the object pointed to by object. After that, it calls the corresponding and overloadable render routine. After the render routine returns, the function releases the read access to the object.

Note:
The behavior is undefined if p points to an invalid location.

void addObjectRenderer | ( | unsigned int | objectCode,
 |  | RendererType | renderer
 | ) | [inline, protected]

Add a render routine for a concrete Object derived object.

The function registers the render routine specified by render to render a concrete Object that is explicitly identified by objectCode.

A render routine must be a member function of a RenderTraverser-derived class. It must return void and expect a pointer to the concrete object as the parameter. A render routine must not have a default argument! If a render routine is intended to remain overloadable, it should be declared virtual.

Note:
A possibly pre-registered render routine for the specified object will be overridden by the new renderer.
Remarks:
For derived classes intended to provide new operations for known objects arranged in a scene graph, it is strongly recommended not to add new render routines for a certain known objects but to overload the corresponding render routines. In this context, we refer to 'known objects' as objects that are known by the RenderTraverser base class and for which a corresponding render routine is provided.
However, addObjectRenderer is indispensable if newly invented objects, and hence, objects that are unknown by the RenderTraverser base class, need to be considered for rendering.
Parameters:
objectCode | Object code to identify an object type at run-time.
renderer | Specifies the address of the handler routine.

void renderObject | ( | nvsg::ObjectHandle * | oh,
 |  | T | arg
 | ) | [inline, protected]

Start rendering a general object.

The function first waits to gain read access to the object pointed to by object. After that, it calls the corresponding and overloadable render routine with the additional argument arg. After the render routine returns, the function releases the read access to the object.

Note:
The behavior is undefined if p points to an invalid location. The behavior is also undefined if the additional argument doesn't match that of the corresponding render routine.

virtual NVSG_API void renderBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Evaluate the Trafo of a Billboard while rendering from a render list.

Parameters:
p The read-locked Billboard to evaluate.
Remarks:
The framework maintains a list of transformations that might change on every frame (for example due to being part of a Billboard node). Those transforms are re-evaluated on each frame, and this function is used to do this. This function sets the member variable m_currentTrafo of the RenderTraverser to the current Trafo of p.
See also:
setTransform

virtual NVSG_API void renderBlendAttribute | ( | const nvsg::BlendAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a BlendAttribute out of a render list.

This base implementation is a NOP.

Parameters:
p | BlendAttribute to render
enable | enable (true) or disable (false) this BlendAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void renderAlphaTestAttribute | ( | const nvsg::AlphaTestAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a AlphaTestAttribute out of a render list.

This base implementation is a NOP.

Parameters:
p | AlphaTestAttribute to render
enable | enable (true) or disable (false) this AlphaTestAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void renderCgFx | ( | const nvsg::CgFx * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a CgFx out of a render list.

This base implementation determines if there is a current CgFx available now.

Parameters:
p | CgFx to render
enable | enable (true) or disable (false) this CgFx

virtual NVSG_API void renderDepthAttribute | ( | const nvsg::DepthAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a DepthAttribute out of a render list.

This base implementation is a NOP.

Parameters:
p | DepthAttribute to render
enable | enable (true) or disable (false) this DepthAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void renderDirectedLight | ( | const nvsg::DirectedLight * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a DirectedLight out of a render list.

This base implementation is a NOP.

Parameters:
p | DirectedLight to render
enable | enable (true) or disable (false) this DirectedLight

Reimplemented in GLTraverser.

virtual NVSG_API void renderFaceAttribute | ( | const nvsg::FaceAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a FaceAttribute out of a render list.

This base implementation is a NOP.

Parameters:
p | FaceAttribute to render
enable | enable (true) or disable (false) this FaceAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void renderHighlightBox ( const nvsg::HighlightBox * p ) [protected, virtual]

Render a HighlightBox out of a render list.

This base implementation is a NOP.

Parameters:
p HighlightBox to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderHighlightEdges ( const nvsg::HighlightEdges * p ) [protected, virtual]

Render a HighlightEdges out of a render list.

This base implementation is a NOP.

Parameters:
p HighlightEdges to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderLightingAttribute | ( | const nvsg::LightingAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a LineAttribute out of a render list.

This base implementation is a NOP.

Parameters:
p | LightingAttribute to render
enable | enable (true) or disable (false) this PointAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void renderLineAttribute | ( | const nvsg::LineAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a LineAttribute out of a render list.

This base implementation is a NOP.

Parameters:
p | LineAttribute to render
enable | enable (true) or disable (false) this PointAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void renderLines ( const nvsg::Lines * p ) [protected, virtual]

Render a Lines out of a render list.

This base implementation is a NOP.

Parameters:
p Lines to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Render a LineStrips out of a render list.

This base implementation is a NOP.

Parameters:
p LineStrips to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderPointAttribute | ( | const nvsg::PointAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a PointAttribute out of a render list.

This base implementation is a NOP.

Parameters:
p | PointAttribute to render
enable | enable (true) or disable (false) this PointAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void renderPoints ( const nvsg::Points * p ) [protected, virtual]

Render a Points out of a render list.

This base implementation is a NOP.

Parameters:
p Points to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderMaterial | ( | const nvsg::Material * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a Material out of a render list.

This base implementation is a NOP.

Parameters:
p | Material to render
enable | enable (true) or disable (false) this Material

Reimplemented in GLTraverser.

virtual NVSG_API void renderParallelCamera ( const nvsg::ParallelCamera * p ) [protected, virtual]

Render a ParallelCamera out of a render list.

This base implementation is a NOP.

Parameters:
p ParallelCamera to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderPerspectiveCamera ( const nvsg::PerspectiveCamera * p ) [protected, virtual]

Render a PerspectiveCamera out of a render list.

This base implementation is a NOP.

Parameters:
p PerspectiveCamera to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderPointLight | ( | const nvsg::PointLight * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a PointLight out of a render list.

This base implementation is a NOP.

Parameters:
p | PointLight to render
enable | enable (true) or disable (false) this PointLight

Reimplemented in GLTraverser.

virtual NVSG_API void renderQuads ( const nvsg::Quads * p ) [protected, virtual]

Render a Quads out of a render list.

This base implementation is a NOP.

Parameters:
p Quads to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Render a QuadMeshes out of a render list.

This base implementation is a NOP.

Parameters:
p QuadMeshes to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Render a QuadStrips out of a render list.

This base implementation is a NOP.

Parameters:
p QuadStrips to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Render a SkinnedTriangles out of a render list.

This base implementation calls renderTriangles().

Parameters:
p SkinnedTriangles to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderSpotLight | ( | const nvsg::SpotLight * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a SpotLight out of a render list.

This base implementation is a NOP.

Parameters:
p | SpotLight to render
enable | enable (true) or disable (false) this SpotLight

Reimplemented in GLTraverser.

virtual NVSG_API void renderStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Render a StatePass out of a render list.

First all currently enabled StateAttributes, that are not part of this StatePass are disabled. All StateAttributes in this StatePass are enabled then.

Parameters:
p StatePass to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderTextureAttribute | ( | const nvsg::TextureAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render a TextureAttribute out of a render list.

If this TextureAttribute is to be enabled, all its TextureAttributeItems are enabled. Otherwise, this base implementation is a NOP.

Parameters:
p | TextureAttribute to render
enable | enable (true) or disable (false) this TextureAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void renderTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | p,
 |  | unsigned int | tu
 | ) | [protected, virtual]

Render a TextureAttributeItem out of a render list.

This base implementation is a NOP.

Parameters:
p | TextureAttributeItem to render
tu | texture unit to use

Reimplemented in GLTraverser.

virtual NVSG_API void renderTransform ( const nvsg::Transform * p ) [protected, virtual]

Evaluate the Trafo of a Transform while rendering from a render list.

Parameters:
p The read-locked Transform to evaluate.
Remarks:
The framework maintains a list of transformations that might change on every frame (for example due to being part of a Billboard node). Those transforms are re-evaluated on each frame, and this function is used to do this. This function sets the member variable m_currentTrafo of the RenderTraverser to the Trafo of p.
See also:
renderBillboard

virtual NVSG_API void renderTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Render a Triangles out of a render list.

This base implementation is a NOP.

Parameters:
p Triangles to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Render a TriFans out of a render list.

This base implementation is a NOP.

Parameters:
p TriFans to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Render a TriStrips out of a render list.

This base implementation is a NOP.

Parameters:
p TriStrips to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderUnlitColorAttribute | ( | const nvsg::UnlitColorAttribute * | p,
 |  | bool | enable
 | ) | [protected, virtual]

Render an UnlitColorAttribute out of a render list.

This base implementation is a NOP.

Parameters:
p | UnlitColorAttribute to render
enable | enable (true) or disable (false) this UnlitColorAttribute

Reimplemented in GLTraverser.

virtual NVSG_API void setClipPlane | ( | unsigned int | index,
 |  | const nvmath::Plane3f & | plane,
 |  | bool | enable
 | ) | [protected, virtual]

Set a clipping plane.

This base implementation is a NOP.

Parameters:
index | index of the plane
plane | plane to use
enable | enable/disable it

Reimplemented in GLTraverser.

virtual NVSG_API void setTransforms | ( | const nvmath::Mat44f & | modelToWorld,
 |  | const nvmath::Mat44f & | worldToModel,
 |  | bool | needsNormalize,
 |  | bool | needsMirror
 | ) | [protected, virtual]

Set the current model to world and world to model transforms.

This base implementation is a NOP.

Parameters:
modelToWorld | current model to world transform
worldToModel | current world to model transform
needsNormalize | true if these transforms include a scaling
needsMirror | true if these transforms includes a negative scaling

Reimplemented in GLTraverser.

virtual NVSG_API void overlayBegin ( void ) [protected, virtual]

Indication of the beginning of the overlay parts.

Reimplemented in GLTraverser.

virtual NVSG_API void overlayEnd ( void ) [protected, virtual]

Indication of the end of the overlay parts.

Reimplemented in GLTraverser.

virtual NVSG_API void transparentBegin ( void ) [protected, virtual]

Indication of the beginning of rendering transparent parts.

Reimplemented in GLTraverser.

virtual NVSG_API void transparentEnd ( void ) [protected, virtual]

Indication of the end of rendering transparent parts.

Reimplemented in GLTraverser.

virtual NVSG_API void highlightBegin ( void ) [protected, virtual]

Indication of the beginning of rendering highlighted parts.

Reimplemented in GLTraverser.

virtual NVSG_API void highlightEnd ( void ) [protected, virtual]

Indication of the end of rendering highlighted parts.

Reimplemented in GLTraverser.

virtual NVSG_API void primitiveSetsBegin ( ) [protected, virtual]

Initiates PrimitiveSet rendering.

Reimplemented in GLTraverser.

virtual NVSG_API bool primitiveSetsEnd ( ) [protected, virtual]

Post-processes PrimitiveSet rendering.

If the function returns true, the PrimitiveSets will be re-processed again.

Reimplemented in GLTraverser.

nvsg::CgFxHandle * getCurrentCgFx ( void ) const [inline, protected]

Get the current CgFx while rendering.

Returns:
The current CgFx, or NULL if there is none.
Note:
The current CgFx is valid only while rendering (inside render()).

virtual NVSG_API void assignDirectedLightToEffectLight | ( | nvsg::CgFxEffect * | effect,
 |  | nvsg::CgFxParameter | lightParam,
 |  | const nvsg::DirectedLight * | directedLight,
 |  | const nvmath::Mat44f & | modelToWorld
 | ) | [protected, virtual]

Assigns current settings of a DirectedLight to the specified effect light parameter.

The purpose of this function is to transmit the settings of the specified DirectedLight to the specified effect light through the CgFxEffect interface.

NVSG effect light is always expected to be in world space. The model-to-world transformation passed as last argument specifies how the light source is oriented in world space given its inherent orientation in model space.

The orientation of coordinate systems is dependent on the graphic library system used for rendering. Therefore, the default implementation does nothing here and it is recommended for a derived RenderTraverser to override this function to get the effect light oriented in the right way.

The behavior is undefined if either light does not specify an effect light parameter, or if light is no parameter of the specified effect.

Reimplemented in GLTraverser.

virtual NVSG_API void assignPointLightToEffectLight | ( | nvsg::CgFxEffect * | effect,
 |  | nvsg::CgFxParameter | lightParam,
 |  | const nvsg::PointLight * | pointLight,
 |  | const nvmath::Mat44f & | modelToWorld
 | ) | [protected, virtual]

Assigns current settings of a PointLight to the specified effect light parameter.

The purpose of this function is to transmit the settings of the specified PointLight to the specified effect light through the CgFxEffect interface.

NVSG effect light is always expected to be in world space. The model-to-world transformation passed as last argument specifies how the light source is positioned in world space given its inherent position in model space.

The orientation of coordinate systems is dependent on the graphic library system used for rendering. Therefore, the default implementation does nothing here and it is recommended for a derived RenderTraverser to override this function to get the effect light positioned in the right way.

The behavior is undefined if either light does not specify an effect light parameter, or if light is no parameter of the specified effect.

Reimplemented in GLTraverser.

virtual NVSG_API void assignSpotLightToEffectLight | ( | nvsg::CgFxEffect * | effect,
 |  | nvsg::CgFxParameter | lightParam,
 |  | const nvsg::SpotLight * | spotLight,
 |  | const nvmath::Mat44f & | modelToWorld
 | ) | [protected, virtual]

Assigns current settings of a SpotLight to the specified effect light parameter.

The purpose of this function is to transmit the settings of the specified SpotLight to the specified effect light through the CgFxEffect interface.

NVSG effect light is always expected to be in world space. The model-to-world transformation passed as last argument specifies how the light source is positioned and oriented in world space given its inherent position and orientation in model space.

The orientation of coordinate systems is dependent on the graphic library system used for rendering. Therefore, the default implementation does nothing here and it is recommended for a derived RenderTraverser to override this function to get the effect light positioned in the right way.

The behavior is undefined if either light does not specify an effect light parameter, or if light is no parameter of the specified effect.

Reimplemented in GLTraverser.

virtual NVSG_API void assignCustomLightToEffectLight | ( | nvsg::CgFxEffect * | effect,
 |  | nvsg::CgFxParameter | lightParam,
 |  | const nvsg::LightSource * | customLight,
 |  | const nvmath::Mat44f & | modelToWorld
 | ) | [protected, virtual]

Assigns current settings of a custom LightSource to the specified effect light parameter.

The purpose of this function is to transmit the settings of the specified LightSource to the specified effect light through the CgFxEffect interface.

NVSG effect light is always expected to be in world space. The model-to-world transformation passed as last argument specifies how the light source is positioned and oriented in world space given its inherent position and orientation in model space.

The orientation of coordinate systems is dependent on the graphic library system used for rendering. Therefore, the default implementation does nothing here and it is recommended for a derived RenderTraverser to override this function to get the effect light positioned in the right way.

The behavior is undefined if either light does not specify an effect light parameter, or if light is no parameter of the specified effect.

virtual NVSG_API unsigned int createOcclusionCullID ( void ) [protected, virtual]

Create an occlusion culling ID.

Any RenderTraverser that supports occlusion culling should overwrite this function. It should return an ID to identify one block of occlusion culling, usually one set of PrimitiveSets. This base implementation always returns 0, that is an invalid ID.

Returns:
new occlusion cull ID.

Reimplemented in GLTraverser.

virtual NVSG_API void destroyOcclusionCullID ( unsigned int id ) [protected, virtual]

Destroy an occlusion culling ID.

Any RenderTraverser that supports occlusion culling should overwrite this function. It should destroy any information held with the occlusion culling ID id. id was previously returned by createOcclusionCullID(). This base implementation is a NOP.

Parameters:
id occlusion culling ID to destroy

Reimplemented in GLTraverser.

virtual NVSG_API void beginOcclusionCullQuery ( unsigned int id ) [protected, virtual]

Begin an occlusion culling test.

Any RenderTraverser that supports occlusion culling should overwrite this function. This function is called before a block of drawing elements to be tested for occlusion culling. The RenderTraverser should start to gather occlusion culling informations for the occlusion culling ID id. This base implementation is a NOP.

Parameters:
id occlusion culling ID to begin with

Reimplemented in GLTraverser.

virtual NVSG_API void endOcclusionCullQuery ( unsigned int id ) [protected, virtual]

End an occlusion culling test.

Any RenderTraverser that supports occlusion culling should overwrite this function. This function is called after a block of drawing elements to be tested for occlusion culling. The RenderTraverser should stop gathering occlusion culling informations for the occlusion culling ID id. This base implementation is a NOP.

Parameters:
id occlusion culling ID to end with

Reimplemented in GLTraverser.

virtual NVSG_API unsigned int getOcclusionCullResult ( unsigned int id ) [protected, virtual]

Get the result of an occlusion culling test.

Any RenderTraverser that supports occlusion culling should overwrite this function. This function is called to determine the occlusion culling result with the occlusion culling ID id. It should return the number of samples that were rendered between the corresponding calls to beginOcclusionCullQuery and endOcclusionCullQuery. This base implementation always returns a large number, indicating the tested drawing elements would be visible.

Returns:
The number of samples drawn with the occlusion cull test for the ID id.
Parameters:
id occlusion culling ID to get result of

Reimplemented in GLTraverser.

virtual NVSG_API void hiddenBegin ( void ) [protected, virtual]

Begin rendering of the hidden drawing elements.

Any RenderTraverser that supports occlusion culling should overwrite this function. The base implementation is a NOP.

Reimplemented in GLTraverser.

virtual NVSG_API void hiddenEnd ( void ) [protected, virtual]

End rendering of the hidden drawing elements.

Any RenderTraverser that supports occlusion culling should overwrite this function. The base implementation is a NOP.

Reimplemented in GLTraverser.

NVSG_API void clearRenderLists ( void ) [protected]

Clears all render lists.

unsigned int getRasterOffsetX ( ) const [inline, protected]

Get the raster offset in x direction of this render traversal.

Returns:
The raster offset in x direction.
Remarks:
The raster offset is used for drawing the raster aligned maps in a clustered view. If the currently used camera does not represent the complete viewing window, i.e. its window region is not the complete viewing window. Then the window region and the viewport size is used to determine the raster offset, i.e. offset of the lower left pixel of that viewport relative to the lower left pixel of the complete viewport that represents the complete viewing window.
See also:
getRasterOffsetY, Camera::getWindowRegion

unsigned int getRasterOffsetY ( ) const [inline, protected]

Get the raster offset in y direction of this render traversal.

Returns:
The raster offset in y direction.
Remarks:
The raster offset is used for drawing the raster aligned maps in a clustered view. If the currently used camera does not represent the complete viewing window, i.e. its window region is not the complete viewing window. Then the window region and the viewport size is used to determine the raster offset, i.e. offset of the lower left pixel of that viewport relative to the lower left pixel of the complete viewport that represents the complete viewing window.
See also:
getRasterOffsetX, Camera::getWindowRegion

NVSG_API void setCollectRenderElements ( bool value ) [protected]

Set whether RenderElements should be collected.

NVSG_API bool getCollectRenderElements ( void ) const [protected]

Get whether RenderElements are collected.

NVSG_API void occlusionTest | ( | std::list< RenderElement * > & | visibleList,
 |  | std::list< RenderElement * > & | hiddenList
 | ) | [protected]

Update visible and hidden list by the occlusion test results.

The documentation for this class was generated from the following file:
  • RenderTraverser.h
Generated on Tue Jan 15 10:29:36 2008 for NVSGSDK by NVIDIA


Member List

RenderTraverser Member List

This is the complete list of members for RenderTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addObjectRenderer(unsigned int objectCode, RendererType renderer) | RenderTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
assignCustomLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::LightSource *customLight, const nvmath::Mat44f &modelToWorld) | RenderTraverser | [protected, virtual]
assignDirectedLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::DirectedLight *directedLight, const nvmath::Mat44f &modelToWorld) | RenderTraverser | [protected, virtual]
assignPointLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::PointLight *pointLight, const nvmath::Mat44f &modelToWorld) | RenderTraverser | [protected, virtual]
assignSpotLightToEffectLight(nvsg::CgFxEffect *effect, nvsg::CgFxParameter lightParam, const nvsg::SpotLight *spotLight, const nvmath::Mat44f &modelToWorld) | RenderTraverser | [protected, virtual]
beginOcclusionCullQuery(unsigned int id) | RenderTraverser | [protected, virtual]
clearRenderLists(void) | RenderTraverser | [protected]
createOcclusionCullID(void) | RenderTraverser | [protected, virtual]
destroyOcclusionCullID(unsigned int id) | RenderTraverser | [protected, virtual]
doApply(nvsg::NodeHandle *root) | RenderTraverser | [protected, virtual]
doRender(nvsg::NodeHandle *root)=0 | RenderTraverser | [protected, pure virtual]
endOcclusionCullQuery(unsigned int id) | RenderTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
GCT_DL enum value | RenderTraverser |
GCT_NONE enum value | RenderTraverser |
GCT_VBO enum value | RenderTraverser |
GeometryCacheTechnique enum name | RenderTraverser |
getCollectRenderElements(void) const | RenderTraverser | [protected]
getCurrentCgFx(void) const | RenderTraverser | [inline, protected]
getFaceMode(void) const | RenderTraverser | [inline]
getGeometryCacheTechnique(void) const | RenderTraverser | [inline]
getJitterTechnique(void) const | RenderTraverser | [inline]
getLineWidth(void) const | RenderTraverser | [inline]
getOcclusionCullResult(unsigned int id) | RenderTraverser | [protected, virtual]
getOITMaxPasses(void) const | RenderTraverser | [inline]
getOITTechnique(void) const | RenderTraverser | [inline]
getOITThreshold(void) const | RenderTraverser | [inline]
getPointSize(void) const | RenderTraverser | [inline]
getRasterOffsetX() const | RenderTraverser | [inline, protected]
getRasterOffsetY() const | RenderTraverser | [inline, protected]
getRenderTechnique(void) const | RenderTraverser | [inline]
getShadowMapIntensity(void) const | RenderTraverser | [inline]
getShadowMapSize(void) const | RenderTraverser | [inline]
getShadowTechnique(void) const | RenderTraverser | [inline]
getSortingPolicy(void) const | RenderTraverser | [inline]
getTextureSizeLimit(void) const | RenderTraverser | [inline]
getTransparencyTechnique(void) const | RenderTraverser | [inline]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SharedModelViewTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *p) | RenderTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | RenderTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *anim) | SharedTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *gnode) | SharedTraverser | [protected, virtual]
handleGroup(const nvsg::Group *group) | SharedTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | SharedTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | SharedTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *lod) | SharedModelViewTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | SharedTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | SharedTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | SharedTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | SharedTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | RenderTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *swtch) | SharedTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | RenderTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | SharedTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | SharedTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | SharedTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SharedTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *p) | RenderTraverser | [protected, virtual]
hiddenBegin(void) | RenderTraverser | [protected, virtual]
hiddenEnd(void) | RenderTraverser | [protected, virtual]
highlightBegin(void) | RenderTraverser | [protected, virtual]
highlightEnd(void) | RenderTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isBackFaceCulling() const | RenderTraverser | [inline]
isFaceCullingOverwrite() const | RenderTraverser | [inline]
isFaceModeOverwrite() const | RenderTraverser | [inline]
isFrontFaceCulling() const | RenderTraverser | [inline]
isGeometryCacheTechniqueSupported(GeometryCacheTechnique gct) const | RenderTraverser | [virtual]
isHighlightPass(void) const | RenderTraverser | [inline, protected]
isJitterTechniqueSupported(JitterTechnique jt) const | RenderTraverser | [virtual]
isLineAntiAliasingEnabled(void) const | RenderTraverser | [inline]
isOcclusionCulling(void) const | RenderTraverser | [inline]
isOcclusionCullingSupported(void) const | RenderTraverser | [virtual]
isOITTechniqueSupported(OITTechnique ot) const | RenderTraverser | [virtual]
isOverlayPass(void) const | RenderTraverser | [inline, protected]
isPointAntiAliasingEnabled(void) const | RenderTraverser | [inline]
isRenderTechniqueSupported(RenderTechnique rt) const | RenderTraverser | [virtual]
isShadowTechniqueSupported(ShadowTechnique st) const | RenderTraverser | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparencyTechniqueSupported(TransparencyTechnique tt) const | RenderTraverser | [virtual]
isTransparentPass(void) const | RenderTraverser | [inline, protected]
isTwoSidedLighting() const | RenderTraverser | [inline]
isTwoSidedLightingOverwrite() const | RenderTraverser | [inline]
JitterTechnique enum name | RenderTraverser |
JT_ACCUM enum value | RenderTraverser |
JT_FBO enum value | RenderTraverser |
JT_NONE enum value | RenderTraverser |
JT_PBUFFER enum value | RenderTraverser |
JT_READ_PIXELS enum value | RenderTraverser |
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedModelViewTraverser | [protected, virtual]
m_collectRenderElements (defined in RenderTraverser) | RenderTraverser | [protected]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_currentRenderElement (defined in RenderTraverser) | RenderTraverser | [protected]
m_hiddenOpaqueList (defined in RenderTraverser) | RenderTraverser | [protected]
m_hiddenTransparentList (defined in RenderTraverser) | RenderTraverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lastRenderElement (defined in RenderTraverser) | RenderTraverser | [protected]
m_lockedCamera | SharedModelViewTraverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | SharedModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
m_visibleOpaqueList (defined in RenderTraverser) | RenderTraverser | [protected]
m_visibleTransparentList (defined in RenderTraverser) | RenderTraverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
occlusionTest(std::list< RenderElement * > &visibleList, std::list< RenderElement * > &hiddenList) | RenderTraverser | [protected]
OITTechnique enum name | RenderTraverser |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OT_FBO enum value | RenderTraverser |
OT_PBUFFER enum value | RenderTraverser |
OT_TEXTURE enum value | RenderTraverser |
overlayBegin(void) | RenderTraverser | [protected, virtual]
overlayEnd(void) | RenderTraverser | [protected, virtual]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, unsigned int i) | RenderTraverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | RenderTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, unsigned int i) | RenderTraverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | RenderTraverser | [protected, virtual]
primitiveSetsBegin() | RenderTraverser | [protected, virtual]
primitiveSetsEnd() | RenderTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
renderAlphaTestAttribute(const nvsg::AlphaTestAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
renderBegin(void) | RenderTraverser | [protected, virtual]
renderBillboard(const nvsg::Billboard *p) | RenderTraverser | [protected, virtual]
renderBlendAttribute(const nvsg::BlendAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
renderCgFx(const nvsg::CgFx *p, bool enable) | RenderTraverser | [protected, virtual]
renderDepthAttribute(const nvsg::DepthAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
renderDirectedLight(const nvsg::DirectedLight *p, bool enable) | RenderTraverser | [protected, virtual]
renderEnd(void) | RenderTraverser | [protected, virtual]
renderFaceAttribute(const nvsg::FaceAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
renderHighlightBox(const nvsg::HighlightBox *p) | RenderTraverser | [protected, virtual]
renderHighlightEdges(const nvsg::HighlightEdges *p) | RenderTraverser | [protected, virtual]
renderLightingAttribute(const nvsg::LightingAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
renderLineAttribute(const nvsg::LineAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
renderLines(const nvsg::Lines *p) | RenderTraverser | [protected, virtual]
renderLineStrips(const nvsg::LineStrips *p) | RenderTraverser | [protected, virtual]
renderMaterial(const nvsg::Material *p, bool enable) | RenderTraverser | [protected, virtual]
renderObject(nvsg::ObjectHandle *oh) | RenderTraverser | [inline, protected]
renderObject(nvsg::ObjectHandle *oh, T arg) | RenderTraverser | [inline, protected]
renderParallelCamera(const nvsg::ParallelCamera *p) | RenderTraverser | [protected, virtual]
renderPerspectiveCamera(const nvsg::PerspectiveCamera *p) | RenderTraverser | [protected, virtual]
renderPointAttribute(const nvsg::PointAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
renderPointLight(const nvsg::PointLight *p, bool enable) | RenderTraverser | [protected, virtual]
renderPoints(const nvsg::Points *p) | RenderTraverser | [protected, virtual]
renderQuadMeshes(const nvsg::QuadMeshes *p) | RenderTraverser | [protected, virtual]
renderQuads(const nvsg::Quads *p) | RenderTraverser | [protected, virtual]
renderQuadStrips(const nvsg::QuadStrips *p) | RenderTraverser | [protected, virtual]
renderSkinnedTriangles(const nvsg::SkinnedTriangles *p) | RenderTraverser | [protected, virtual]
renderSpotLight(const nvsg::SpotLight *p, bool enable) | RenderTraverser | [protected, virtual]
renderStatePass(const nvsg::StatePass *p) | RenderTraverser | [protected, virtual]
RenderTechnique enum name | RenderTraverser |
renderTextureAttribute(const nvsg::TextureAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
renderTextureAttributeItem(const nvsg::TextureAttributeItem *p, unsigned int tu) | RenderTraverser | [protected, virtual]
renderTransform(const nvsg::Transform *p) | RenderTraverser | [protected, virtual]
RenderTraverser(void) | RenderTraverser | [protected]
renderTriangles(const nvsg::Triangles *p) | RenderTraverser | [protected, virtual]
renderTriFans(const nvsg::TriFans *p) | RenderTraverser | [protected, virtual]
renderTriStrips(const nvsg::TriStrips *p) | RenderTraverser | [protected, virtual]
renderUnlitColorAttribute(const nvsg::UnlitColorAttribute *p, bool enable) | RenderTraverser | [protected, virtual]
RT_EFFECTED enum value | RenderTraverser |
RT_SHADED enum value | RenderTraverser |
RT_TEXTURED enum value | RenderTraverser |
RT_UNLIT enum value | RenderTraverser |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane, bool enable) | RenderTraverser | [protected, virtual]
setCollectRenderElements(bool value) | RenderTraverser | [protected]
setFaceCulling(bool front, bool back) | RenderTraverser | [inline]
setFaceCullingOverwrite(bool overwrite) | RenderTraverser | [inline]
setFaceMode(nvsg::FaceMode mode) | RenderTraverser | [inline]
setFaceModeOverwrite(bool overwrite) | RenderTraverser | [inline]
setGeometryCacheTechnique(GeometryCacheTechnique gct) | RenderTraverser | [virtual]
setJitterTechnique(JitterTechnique jt) | RenderTraverser | [inline]
setLineAntiAliasing(bool onOff) | RenderTraverser | [inline]
setLineWidth(float width) | RenderTraverser | [inline]
setOcclusionCulling(bool onOff) | RenderTraverser | [virtual]
setOITMaxPasses(unsigned int maxPasses) | RenderTraverser | [virtual]
setOITTechnique(OITTechnique ot) | RenderTraverser | [virtual]
setOITThreshold(float threshold) | RenderTraverser | [inline]
setPointAntiAliasing(bool onOff) | RenderTraverser | [inline]
setPointSize(float size) | RenderTraverser | [inline]
setRenderTechnique(RenderTechnique rt) | RenderTraverser |
setScene(nvsg::SceneHandle *scene) | Traverser |
setShadowMapIntensity(float intensity) | RenderTraverser | [inline]
setShadowMapSize(unsigned int size) | RenderTraverser | [virtual]
setShadowTechnique(ShadowTechnique st) | RenderTraverser | [virtual]
setSortingPolicy(SortingPolicy sp) | RenderTraverser | [inline]
setTextureSizeLimit(unsigned int size) | RenderTraverser | [virtual]
setTransforms(const nvmath::Mat44f &modelToWorld, const nvmath::Mat44f &worldToModel, bool needsNormalize, bool needsMirror) | RenderTraverser | [protected, virtual]
setTransparencyTechnique(TransparencyTechnique tt) | RenderTraverser | [virtual]
setTwoSidedLighting(bool enable) | RenderTraverser | [inline]
setTwoSidedLightingOverwrite(bool overwrite) | RenderTraverser | [inline]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
ShadowTechnique enum name | RenderTraverser |
SharedModelViewTraverser() | SharedModelViewTraverser | [protected]
SharedTraverser() | SharedTraverser |
SortingPolicy enum name | RenderTraverser |
SP_DEPTH enum value | RenderTraverser |
SP_NONE enum value | RenderTraverser |
SP_STATE enum value | RenderTraverser |
ST_NONE enum value | RenderTraverser |
ST_SHADOW_MAP enum value | RenderTraverser |
theAllocator typedef | IAllocator |
TransparencyTechnique enum name | RenderTraverser |
transparentBegin(void) | RenderTraverser | [protected, virtual]
transparentEnd(void) | RenderTraverser | [protected, virtual]
traverseCamera(const nvsg::Camera *camera) | SharedModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | RenderTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | RenderTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
TT_BLENDED enum value | RenderTraverser |
TT_MULTISAMPLE enum value | RenderTraverser |
TT_NONE enum value | RenderTraverser |
TT_ORDER_INDEPENDENT enum value | RenderTraverser |
TT_SORTED_BLENDED enum value | RenderTraverser |
TT_STIPPLED enum value | RenderTraverser |
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~RenderTraverser(void) | RenderTraverser | [protected, virtual]
~SharedModelViewTraverser() | SharedModelViewTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:36 2008 for NVSGSDK by NVIDIA


sampler_t Struct Reference

The sampler_t structure specifies how a sampler parameter is stored in a .NBF file. More...

#include <NBF.h>

Collaboration diagram for sampler_t:

[legend]
List of all members.

Public Attributes

str_t name
Specifies the sampler's name as it appears in the effect source.

uint_t texImg
Specifies the file offset to the corresponding texture image.

Detailed Description

The sampler_t structure specifies how a sampler parameter is stored in a .NBF file.

Samplers need to be considered in conjunction with NBFCgFx objects.

Member Data Documentation

str_t name

Specifies the sampler's name as it appears in the effect source.

uint_t texImg

Specifies the file offset to the corresponding texture image.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

sampler_t Member List

This is the complete list of members for sampler_t, including all inherited members.
name | sampler_t
texImg | sampler_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


ScaleFilter Class Reference

Scale Filter Functor. More...

#include <TextureImage.h>

Inheritance diagram for ScaleFilter:

[legend]
Collaboration diagram for ScaleFilter:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API float | getSupportWidth (void) const=0
Get the support width of this scale filter.

virtual NVSG_API float | operator() (float t) const=0
Weight calculation operator.

Detailed Description

Scale Filter Functor.

Functor base class used in texture image scaling.
When scaling a TextureImage, a ScaleFilter is used to determine the weight for a source texel in a given distance to the destination texel.
With these ScaleFilters, the image is resampled in two passes, stretching or shrinking the image first horizontally and then vertically (or vice versa) with potentially different scale factors. The two-pass approach has a significantly lower run-time cost, O(imageWidth*imageHeight*(filterWidth+filterHeight)), than straightforward 2-D filtering, O(imageWidth*imageHeight*filterWidth*filterHeight)). The performance gain is even higher in 3-D filtering.
For magnification, the ScaleFilter is centered around each source texel and scaled to the height of that texel. For each destination texel, the corresponding location in the source image is calculated. The sum of the weighted filter functions at this point determines the value of the destination texel.
For minification, to eliminate all frequency components above the resampling Nyquist frequency, the ScaleFilter is stretched by the image reduction factor.
Because the scaling process for each row or column is identical, the placement and area of the ScaleFilter is fixed. Therefore the contributors to each destination texel and the corresponding filter weight are precomputed once, using the calling operator, and then applied to each destination texel.

Member Function Documentation

virtual NVSG_API float getSupportWidth ( void ) const [pure virtual]

Get the support width of this scale filter.

Returns:
the maximal distance between a source and a destination texel, that is used to determine the source texels that contribute to the destination texel.

Implemented in BoxFilter, TriangleFilter, BellFilter, BSplineFilter, and Lanczos3Filter.

virtual NVSG_API float operator() ( float t ) const [pure virtual]

Weight calculation operator.

Returns:
the weight for a source texel that is t units from the destination texel to compute.
Parameters:
t distance between source and destination texel

Implemented in BoxFilter, TriangleFilter, BellFilter, BSplineFilter, and Lanczos3Filter.

The documentation for this class was generated from the following file:
  • TextureImage.h
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Member List

ScaleFilter Member List

This is the complete list of members for ScaleFilter, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
getSupportWidth(void) const=0 | ScaleFilter | [pure virtual]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator()(float t) const=0 | ScaleFilter | [pure virtual]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Scene Class Reference

Container class to hold all scene related information. More...

#include <Scene.h>

Collaboration diagram for Scene:

[legend]
List of all members.

Public Member Functions

NVSG_API | Scene ()
Default-constructs a Scene.

virtual NVSG_API | ~Scene ()
Destructs a Scene.

NVSG_API const nvmath::Vec3f & | getAmbientColor () const
Get the global ambient color.

NVSG_API void | setAmbientColor (const nvmath::Vec3f &color)
Set the global ambient color.

NVSG_API int | getFrameNumber () const
Get the frame number.

NVSG_API void | setFrameNumber (int frameNumber)
Set the frame number.

NVSG_API const nvmath::Vec4f & | getBackColor () const
Get the background color.

NVSG_API void | setBackColor (const nvmath::Vec4f &color)
Set the background color.

NVSG_API nvsg::TextureImageHandle * | getBackImage () const
return the handle to background texture image.

NVSG_API void | setBackImage (nvsg::TextureImageHandle *image)
NVSG_API unsigned int | getNumberOfCameras () const
Get the number of predefined Camera objects.

NVSG_API CameraHandle * | getCamera (unsigned int index=0) const
Returns the Camera at the specified index.

NVSG_API void | addCamera (CameraHandle *camera)
Adds a Camera to the list of predefined views.

NVSG_API void | removeCamera (unsigned int index)
Remove a Camera from the Scene.

NVSG_API unsigned int | getNumberOfCameraAnimations () const
Get the number of camera animations.

NVSG_API TrafoAnimationHandle * | getCameraAnimation (unsigned int index=0) const
Returns the camera animation at the specified index.

NVSG_API void | addCameraAnimation (TrafoAnimationHandle *animation)
Adds a camera animation to the Scene.

NVSG_API void | removeCameraAnimation (unsigned int index)
Remove a camera animation from the Scene.

NVSG_API NodeHandle * | getRootNode () const
Returns the root Node of the Scene.

NVSG_API void | setRootNode (NodeHandle *root)
Sets the root Node of the Scene.

NVSG_API bool | containsCgFx () const
Ask if the Scene contains any StateAttribute of type CgFx.

NVSG_API bool | containsLight () const
Ask if this Scene contains any LightSource.

NVSG_API bool | containsTransparentGeometry () const
Ask if this Scene contains any transparent StateAttribute.

NVSG_API bool | containsAnimation () const
Interface to determine if an Object contains an animation.

Detailed Description

Container class to hold all scene related information.

Namespace: nvsg
Remarks:
The Scene represents the loaded/created scene. It contains the ambient and back color, predefined cameras (views), predefined camera animations, and the tree of objects (the scene graph).
Note:
The Scene holds a number of predefined cameras, but the ViewState holds the active camera.
See also:
Camera, SceneLoader, SceneSaver, ViewState

Constructor & Destructor Documentation

NVSG_API Scene ( )

Default-constructs a Scene.

Remarks:
The Scene initially has an ambient color of light grey (0.2, 0.2, 0.2), and a background color of medium grey (0.4, 0.4, 0.4). By default there are no cameras, no camera animations, and no tree object attached to the Scene.

virtual NVSG_API ~Scene ( ) [virtual]

Destructs a Scene.

Member Function Documentation

const nvmath::Vec3f & getAmbientColor ( ) const [inline]

Get the global ambient color.

Returns:
A reference to the constant ambient color.
Remarks:
This color represents light that is not from any particular source. The default is light grey (0.2,0.2,0.2).
See also:
getBackColor, setAmbientColor

void setAmbientColor ( const nvmath::Vec3f & color ) [inline]

Set the global ambient color.

Parameters:
color A reference to the constant ambient color to set.
Remarks:
This color represents light that is not from any particular source. The default is light grey (0.2,0.2,0.2).
See also:
getAmbientColor, setBackColor

int getFrameNumber ( ) const [inline]

Get the frame number.

Returns:
The current frame number.
Remarks:
The frame number is monotonically incremented by NVSG's AppTraverser. This value is published to shaders in the NVSGScene.frameNumber counter. NOTE that the value is a SIGNED int, because Cg does not currently support unsigned ints. While the maximum value able to be returned from this routine is 0x7fffffff, code using the frame number should assume that it can change or wrap to zero at any time.
See also:
setFrameNumber

void setFrameNumber ( int frameNumber ) [inline]

Set the frame number.

Parameters:
frameNumber The current frame count for this scene.
Remarks:
The frame number is monotonically incremented by NVSG's AppTraverser. This value can be set or reset if necessary. NOTE the value is a SIGNED int because Cg does not support unsigned ints. Therefore, if the argument is < 0, it is clamped to 0 when stored. Also note that Cg will store the value as a float rather than an INT, and therefore the range will be further compromised. Code using this value should assume it can change or wrap at any time.
See also:
getFrameNumber

const nvmath::Vec4f & getBackColor ( ) const [inline]

Get the background color.

Returns:
A reference to the constant background color.
Remarks:
This color is used to clear the viewport. The default is medium grey (0.4,0.4,0.4,1.0).
See also:
getAmbientColor, setBackColor

void setBackColor ( const nvmath::Vec4f & color ) [inline]

Set the background color.

Parameters:
color A reference to the constant background color to set.
Remarks:
This color is used to clear the viewport with. The default is medium grey (0.4,0.4,0.4,1.0).
See also:
getBackColor, setAmbientColor,

nvsg::TextureImageHandle * getBackImage ( ) const [inline]

return the handle to background texture image.

Returns:
A pointer to a TextureImageHandle
See also:
setBackImage

NVSG_API void setBackImage ( nvsg::TextureImageHandle * image )

brief Set the background texture image

Parameters:
image A pointer to TextureImageHandle specifying texture to be set as background.
Remarks:
The reference count for image is incremented. The texture is applied to the entire viewport.
See also:
getBackImage

unsigned int getNumberOfCameras ( ) const [inline]

Get the number of predefined Camera objects.

Returns:
The number of Camera objects in this Scene.
Remarks:
A scene holds a list of Camera objects from which one can be selected for viewing.
See also:
addCamera, getCamera, removeCamera

CameraHandle * getCamera ( unsigned int index = 0 ) const [inline]

Returns the Camera at the specified index.

Parameters:
index Optional index of the Camera to get. The default is 0.
Returns:
A pointer to a CameraHandle specifying the Camera at index index.
Note:
The behavior is undefined if index is larger than or equal to the number of Camera objects in this Scene.
See also:
addCamera, getNumberOfCameras, removeCamera

void addCamera ( CameraHandle * camera ) [inline]

Adds a Camera to the list of predefined views.

Parameters:
camera A pointer to a CameraHandle specifying the Camera to add.
Remarks:
The reference count of camera is incremented.
See also:
getCamera, getNumberOfCameras, removeCamera

void removeCamera ( unsigned int index ) [inline]

Remove a Camera from the Scene.

Parameters:
index Index of the camera to remove.
Remarks:
The reference count of the Camera at index index is decremented.
Note:
The behavior is undefined if index is larger than or equal to the number of Camera objects in this Scene.
See also:
addCamera, getCamera, getNumberOfCameras

unsigned int getNumberOfCameraAnimations ( ) const [inline]

Get the number of camera animations.

Returns:
The number of camera animations in this Scene.
Remarks:
A scene holds a list of camera animations, from which one can be selected (independently from the Camera) for animated viewing.
See also:
addCameraAnimation, getCameraAnimation, removeCameraAnimation

TrafoAnimationHandle * getCameraAnimation ( unsigned int index = 0 ) const [inline]

Returns the camera animation at the specified index.

Parameters:
index Optional index of the camera animation to get. The default is 0.
Returns:
A pointer to a TrafoAnimationHandle specifying the camera animation at index index.
Remarks:
A scene holds a list of camera animations, from which one can be selected (independently from the Camera) for animated viewing.
Note:
The behavior is undefined if index is larger than or equal to the number of camera animations in this Scene.
See also:
addCameraAnimation, getNumberOfCameraAnimations, removeCameraAnimation

void addCameraAnimation ( TrafoAnimationHandle * animation ) [inline]

Adds a camera animation to the Scene.

Parameters:
animation A pointer to a TrafoAnomationHandle specifying the camera animation to add.
Remarks:
A scene holds a list of camera animations, from which one can be selected (independently from the Camera) for animated viewing.
The reference count of animation is incremented.
See also:
getCameraAnimation, getNumberOfCameraAnimations, removeCameraAnimation

void removeCameraAnimation ( unsigned int index ) [inline]

Remove a camera animation from the Scene.

Parameters:
index Index of the camera animation to remove.
Remarks:
The reference count of the camera animation at index index is decremented.
Note:
The behavior is undefined if index is larger than or equal to the number of camera animations in this Scene.
See also:
addCameraAnimation, getCameraAnimation, getNumberOfCameraAnimations

NodeHandle * getRootNode ( ) const [inline]

Returns the root Node of the Scene.

Returns:
A pointer to a NodeHandle specifying the root Node of the Scene, or NULL if there is no root Node specified yet.
See also:
setRootNode

NVSG_API void setRootNode ( NodeHandle * root )

Sets the root Node of the Scene.

Parameters:
root A pointer to a NodeHandle specifying the Node to set as the root Node.
Remarks:
The reference count of root is incremented, and the reference count of any previous root node is decremented.
See also:
getRootNode

bool containsCgFx ( ) const [inline]

Ask if the Scene contains any StateAttribute of type CgFx.

Returns:
true, if the Scene contains a CgFx attribute, otherwise false.
Remarks:
Because of the special display handling of a CgFx, it might be of interest if there's a CgFx attribute in the Scene at all.
See also:
containsLight, containsTransparentGeometry

bool containsLight ( ) const [inline]

Ask if this Scene contains any LightSource.

Returns:
true, if the Scene contains a LightSource, otherwise false.
See also:
containsCgFx, containsTransparentGeometry

bool containsTransparentGeometry ( ) const [inline]

Ask if this Scene contains any transparent StateAttribute.

Returns:
true, if the Scene contains a transparent StateAttribute, otherwise false.
See also:
containsCgFx, containsLight

bool containsAnimation ( ) const [inline]

Interface to determine if an Object contains an animation.

Returns:
true if there is a camera animation or the root node of the tree contains an Animation, otherwise c\ false.

The documentation for this class was generated from the following file:
  • Scene.h
Generated on Tue Jan 15 10:29:15 2008 for NVSGSDK by NVIDIA


Member List

Scene Member List

This is the complete list of members for Scene, including all inherited members.
addCamera(CameraHandle *camera) | Scene | [inline]
addCameraAnimation(TrafoAnimationHandle *animation) | Scene | [inline]
containsAnimation() const | Scene | [inline]
containsCgFx() const | Scene | [inline]
containsLight() const | Scene | [inline]
containsTransparentGeometry() const | Scene | [inline]
getAmbientColor() const | Scene | [inline]
getBackColor() const | Scene | [inline]
getBackImage() const | Scene | [inline]
getCamera(unsigned int index=0) const | Scene | [inline]
getCameraAnimation(unsigned int index=0) const | Scene | [inline]
getFrameNumber() const | Scene | [inline]
getNumberOfCameraAnimations() const | Scene | [inline]
getNumberOfCameras() const | Scene | [inline]
getRootNode() const | Scene | [inline]
removeCamera(unsigned int index) | Scene | [inline]
removeCameraAnimation(unsigned int index) | Scene | [inline]
Scene() | Scene |
setAmbientColor(const nvmath::Vec3f &color) | Scene | [inline]
setBackColor(const nvmath::Vec4f &color) | Scene | [inline]
setBackImage(nvsg::TextureImageHandle *image) | Scene |
setFrameNumber(int frameNumber) | Scene | [inline]
setRootNode(NodeHandle *root) | Scene |
~Scene() | Scene | [virtual]
Generated on Tue Jan 15 10:29:15 2008 for NVSGSDK by NVIDIA


SceneLoader Class Reference

Pure virtual base class for NVSG scene loader plug-ins. More...

#include <PlugInterface.h>

Inheritance diagram for SceneLoader:

[legend]
Collaboration diagram for SceneLoader:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API SceneHandle * | load (const std::string &filename, const std::vector< std::string > &searchPaths, ViewStateHandle *&viewState)=0
Loading a scene.

Protected Member Functions

virtual NVSG_API | ~SceneLoader ()
Protected virtual destructor.

Detailed Description

Pure virtual base class for NVSG scene loader plug-ins.

User defined NVSG scene loader plug-ins must provide the SceneLoader interface.

Client code that needs to utilize a certain SceneLoader interface should first query for a unique plug interface type ID through a call to nvutil::queryInterfaceType. The unique plug interface type ID for a SceneLoader will be constructed from the UPITID_SCENE_SAVER define and the actual NVSG version, which is coded in the UPITID_VERSION define, as shown in the code snippet below. A call to nvutil::queryInterfaceType returns a list of all unique interface IDs (UPIIDSs) found at given search paths.
After that, the client code can take the different UPIIDs to grab a scene loader interface through a call to nvutil::getInterface.
After usage, the client code should release the interface through a call to nvutil::releaseInterface:
   // Example:
   // --------
   // Get a scene loader interface capable to load 'nvb' files

   //
   vector<string> searchPathes;
   // Add appropriate search paths here. Not relevant for the example here.
   // ...

   // define the unique plug interface type ID for SceneLoaders
   const nvutil::UPITID PITID_SCENE_LOADER(UPITID_SCENE_LOADER, UPITID_VERSION);

   nvsg::Scene * theScene = NULL;
   nvsg::ViewState * viewState = NULL;
   nvutil::UPIID nvbLoaderInterfaceID;
   bool foundAppropriate = false;
   vector<nvutil::UPIID> piids;
   if ( nvutil::queryInterfaceType(searchPathes, PITID_SCENE_LOADER, piids) )
   {
     vector<nvutil::UPIID>::iterator it = piids.begin();
     for ( ; it != piids.end(); ++it )
     {
       if ( !stricmp((*it).getPlugSpecificIDString(), ".nvb") )
       {
         // found, copy the ID
         nvbLoaderInterfaceID = *it;
         foundAppropriate = true;
         break; // look no further
       }
     }
     if ( foundAppropriate )
     {
       nvutil::PlugIn * plug;
       if ( nvutil::getInterface(searchPathes, nvbLoaderInterfaceID, plug) )
       {
         nvsg::SceneLoader * loader = reinterpret_cast<SceneLoader*>(plug);
         theScene = loader->load("c:\\nvb\\sample.nvb", searchPathes, viewState);
         if ( theScene )
         {
           theScene->addRef();
           if ( viewState )
           {
             viewState->addRef();
           }
         }
         nvutil::releaseInterface(nvbLoaderInterfaceID);
       }
     }
   }

Constructor & Destructor Documentation

virtual NVSG_API ~SceneLoader ( ) [protected, virtual]

Protected virtual destructor.

Prohibits ordinary client code from

  • creating a SceneLoader derived object on stack and
  • calling delete on a pointer to SceneLoader.
    Note:
    This will not prohibit the client code from calling delete on a pointer to a SceneLoader derived object. Normally this is not that critical, because one almost always uses a pointer to the base class when working with SceneLoader plug-ins.
    Nevertheless, it would be far less error prone if classes that inherit from SceneLoader also make their destructor protected.

Member Function Documentation

virtual NVSG_API SceneHandle* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | ViewStateHandle *& | viewState
 | ) | [pure virtual]

Loading a scene.

Loads an NVSG scene from a file specified by filename. The function tries to look up this file as follows:

  1. Looks at the specified location.
  2. Looks at the current directory.
  3. Uses the search paths stored in searchPaths to look up the file.
    Returns:
    A pointer to a SceneHandle specifying the loaded scene if successful, a null pointer otherwise.
Parameters:
filename | A string that holds the name of the scene file to be loaded.
searchPaths | A collection of search pathes used to look up the file.
viewState | If the function succeeded, this points to the optional ViewState stored with the scene.

Implemented in NBFLoader, NVBLoader, NVSGLoader, PLYLoader, and WRLLoader.

The documentation for this class was generated from the following file:
  • PlugInterface.h
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


Member List

SceneLoader Member List

This is the complete list of members for SceneLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void)=0 | PlugIn | [protected, pure virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, ViewStateHandle *&viewState)=0 | SceneLoader | [pure virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneLoader() | SceneLoader | [protected, virtual]
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


SceneSaver Class Reference

Pure virtual base class for NVSG scene saver plug-ins. More...

#include <PlugInterface.h>

Inheritance diagram for SceneSaver:

[legend]
Collaboration diagram for SceneSaver:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API bool | save (nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState, const std::string &filename)=0
Saving a scene.

Protected Member Functions

virtual NVSG_API | ~SceneSaver ()
Protected virtual destructor.

Detailed Description

Pure virtual base class for NVSG scene saver plug-ins.

User defined NVSG scene saver plug-ins must provide the SceneSaver interface.

Constructor & Destructor Documentation

virtual NVSG_API ~SceneSaver ( ) [protected, virtual]

Protected virtual destructor.

Prohibits ordinary client code from

  • creating a SceneSaver derived object on stack and
  • calling delete on a pointer to SceneSaver.
    Note:
    This will not prohibit the client code from calling delete on a pointer to a SceneSaver derived object. Normally this is not that critical, because one almost always uses a pointer to the base class when working with SceneSaver plug-ins.
    Nevertheless, it would be far less error prone if classes that inherit from SceneSaver, also make their destructor protected.

Member Function Documentation

virtual NVSG_API bool save | ( | nvsg::SceneHandle * | scene,
 |  | nvsg::ViewStateHandle * | viewState,
 |  | const std::string & | filename
 | ) | [pure virtual]

Saving a scene.

Saves an NVSG scene and a viewState to a file specified by filename.

Returns:
true if successful, false otherwise.

Implemented in NBFSaver, NVSGSaver, and OBJSaver.

The documentation for this class was generated from the following file:
  • PlugInterface.h
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


Member List

SceneSaver Member List

This is the complete list of members for SceneSaver, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void)=0 | PlugIn | [protected, pure virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(nvsg::SceneHandle *scene, nvsg::ViewStateHandle *viewState, const std::string &filename)=0 | SceneSaver | [pure virtual]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneSaver() | SceneSaver | [protected, virtual]
Generated on Tue Jan 15 10:29:12 2008 for NVSGSDK by NVIDIA


SearchTraverser Class Reference

Traverser for searching all objects of one class type. More...

#include <SearchTraverser.h>

Inheritance diagram for SearchTraverser:

[legend]
Collaboration diagram for SearchTraverser:

[legend]
List of all members.

Public Types

typedef std::vector< const
nvsg::Object * >::const_iterator 		iterator
Iterator type definition.

Public Member Functions

NVSG_API | SearchTraverser (void)
Constructor.

NVSG_API const std::vector<
const nvsg::Path * > & 		getPaths (void) const
Get a constant reference to the vector of paths to the search results.

NVSG_API const std::vector<
nvsg::ObjectHandle * > & 		getResults (void) const
Get a constant reference to the vector of search results.

NVSG_API void | setClassName (const std::string &name)
Set the class name to search for.

NVSG_API void | setObjectName (const std::string &objectName)
Set the object name to look for.

NVSG_API void | setObjectPointer (nvsg::ObjectHandle *ptr)
Set the object pointer to look for.

NVSG_API void | setBaseClassSearch (bool enable)
Enable/Disable the search for base classes.

Protected Member Functions

virtual NVSG_API | ~SearchTraverser (void)
Destructor.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Set up the search and traverse the scene.

NVSG_API void | addItem (const nvsg::Object *obj)
Add an Object to the list of found items.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Routine to handle a Billboard node while traversing the scene graph.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Routine to handle a GeoNode while traversing the scene graph.

NVSG_API void | handleVolumeNode (const nvsg::VolumeNode *p)
Routine to handle a VolumeNode while traversing the scene graph.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Routine to handle a Group node while traversing the scene graph.

virtual NVSG_API void | handleFlipbookAnimation (const nvsg::FlipbookAnimation *p)
Routine to handle a FlipbookAnimation node while traversing the scene graph.

virtual NVSG_API void | handleLOD (const nvsg::LOD *p)
Routine to handle a LOD (Level Of Detail) node while traversing the scene graph.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *p)
Routine to handle a Switch node while traversing the scene graph.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Routine to handle a Transform node while traversing the scene graph.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Routine to handle a AnimatedTransform node while traversing the scene graph.

virtual NVSG_API void | handleDirectedLight (const nvsg::DirectedLight *p)
Routine to handle a DirectedLight node while traversing the scene graph.

virtual NVSG_API void | handlePointLight (const nvsg::PointLight *p)
Routine to handle a PointLight node while traversing the scene graph.

virtual NVSG_API void | handleSpotLight (const nvsg::SpotLight *p)
Routine to handle a SpotLight node while traversing the scene graph.

virtual NVSG_API void | handleLines (const nvsg::Lines *p)
Routine to handle a Lines object while traversing the scene graph.

virtual NVSG_API void | handleLineStrips (const nvsg::LineStrips *p)
Routine to handle a LineStrips object while traversing the scene graph.

virtual NVSG_API void | handlePoints (const nvsg::Points *p)
Routine to handle a Points object while traversing the scene graph.

virtual NVSG_API void | handleQuadMeshes (const nvsg::QuadMeshes *p)
Routine to handle a QuadMeshes object while traversing the scene graph.

virtual NVSG_API void | handleQuads (const nvsg::Quads *p)
Routine to handle a Quads object while traversing the scene graph.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *p)
Routine to handle a QuadStrips object while traversing the scene graph.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *p)
Routine to handle a Triangles object while traversing the scene graph.

virtual NVSG_API void | handleSkinnedTriangles (const nvsg::SkinnedTriangles *p)
Routine to handle a SkinnedTriangles object while traversing the scene graph.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *p)
Routine to handle a TriFans object while traversing the scene graph.

virtual NVSG_API void | handleTriStrips (const nvsg::TriStrips *p)
Routine to handle a TriStrips object while traversing the scene graph.

virtual NVSG_API void | handleStateSet (const nvsg::StateSet *p)
Routine to handle a StateSet object while traversing the scene graph.

virtual NVSG_API void | handleStateVariant (const nvsg::StateVariant *p)
Routine to handle a StateVariant object while traversing the scene graph.

virtual NVSG_API void | handleStatePass (const nvsg::StatePass *p)
Routine to handle a StatePass object while traversing the scene graph.

virtual NVSG_API void | handleBlendAttribute (const nvsg::BlendAttribute *p)
Routine to handle a BlendAttribute attribute while traversing the scene graph.

virtual NVSG_API void | handleCgFx (const nvsg::CgFx *p)
Routine to handle a CgFx attribute while traversing the scene graph.

virtual NVSG_API void | handleDepthAttribute (const nvsg::DepthAttribute *p)
Routine to handle a DepthAttribute attribute while traversing the scene graph.

virtual NVSG_API void | handleFaceAttribute (const nvsg::FaceAttribute *p)
Routine to handle a FaceAttribute attribute while traversing the scene graph.

virtual NVSG_API void | handleLineAttribute (const nvsg::LineAttribute *p)
Routine to handle a LineAttribute attribute while traversing the scene graph.

virtual NVSG_API void | handleMaterial (const nvsg::Material *p)
Routine to handle a Material attribute while traversing the scene graph.

virtual NVSG_API void | handlePointAttribute (const nvsg::PointAttribute *p)
Routine to handle a PointAttribute attribute while traversing the scene graph.

virtual NVSG_API void | handleTextureAttribute (const nvsg::TextureAttribute *p)
Routine to handle a TextureAttribute attribute while traversing the scene graph.

virtual NVSG_API void | handleUnlitColorAttribute (const nvsg::UnlitColorAttribute *p)
Routine to handle an UnlitColorAttribute attribute while traversing the scene graph.

virtual NVSG_API void | handleParallelCamera (const nvsg::ParallelCamera *p)
Routine to handle a ParallelCamera object while traversing the scene graph.

virtual NVSG_API void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *p)
Routine to handle a PerspectiveCamera object while traversing the scene graph.

virtual NVSG_API void | handleFramedIndexAnimation (const nvsg::FramedAnimation< unsigned int > *p)
Routine to handle a FramedAnimation<unsigned int> object while traversing the scene graph.

virtual NVSG_API void | handleFramedTrafoAnimation (const nvsg::FramedAnimation< nvmath::Trafo > *p)
Routine to handle a FramedAnimation<Trafo> object while traversing the scene graph.

virtual NVSG_API void | handleFramedVertexAttributeAnimation (const nvsg::FramedAnimation< nvsg::VertexAttribute > *p)
Routine to handle a FramedAnimation<VertexAttribute> object while traversing the scene graph.

virtual NVSG_API void | handleLinearInterpolatedTrafoAnimation (const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p)
Routine to handle a LinearInterpolatedAnimation<Trafo> object while traversing the scene graph.

virtual NVSG_API void | handleLinearInterpolatedVertexAttributeAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p)
Routine to handle a LinearInterpolatedAnimation<VertexAttribute> object while traversing the scene graph.

virtual NVSG_API void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *vas)
Routine to handle a VertexAttributeSet object while traversing the scene graph.

virtual NVSG_API void | handleAnimatedVertexAttributeSet (const nvsg::AnimatedVertexAttributeSet *avas)
Routine to handle a AnimatedVertexAttributeSet object while traversing the scene graph.

virtual NVSG_API void | handleSkin (const nvsg::Skin *skin)
Routine to handle a Skin object while traversing the scene graph.

virtual NVSG_API void | search (const nvsg::Animation< nvmath::Trafo > *p)
Search through an Animation<Trafo> object.

virtual NVSG_API void | search (const nvsg::Animation< unsigned int > *p)
Search through an Animation<unsigned int> object.

virtual NVSG_API void | search (const nvsg::Animation< nvsg::VertexAttribute > *p)
Search through an Animation<VertexAttribute> object.

virtual NVSG_API void | search (const nvsg::AnimationBase *p)
Search through an AnimationBase object.

virtual NVSG_API void | search (const nvsg::Camera *p)
Search through a Camera object.

virtual NVSG_API void | search (const nvsg::Drawable *p)
Search through a Drawable object.

virtual NVSG_API void | search (const nvsg::Group *p)
Search through a Group object.

virtual NVSG_API void | search (const nvsg::IndependentPrimitiveSet *p)
Search through an IndependentPrimitiveSet.

virtual NVSG_API void | search (const nvsg::KeyFramedAnimation< nvmath::Trafo > *p)
Search through an KeyFramedAnimation<Trafo>.

virtual NVSG_API void | search (const nvsg::KeyFramedAnimation< nvsg::VertexAttribute > *p)
Search through an KeyFramedAnimation<VertexAttribute>.

virtual NVSG_API void | search (const nvsg::LightSource *p)
Search through a LightSource object.

virtual NVSG_API void | search (const nvsg::MeshedPrimitiveSet *p)
Search through a MeshedPrimitiveSet.

virtual NVSG_API void | search (const nvsg::Node *p)
Search through a Node object.

virtual NVSG_API void | search (const nvsg::Object *p)
Search through an Object object.

virtual NVSG_API void | search (const nvsg::PrimitiveSet *p)
Search through a PrimitiveSet object.

virtual NVSG_API void | search (const nvsg::Quads *p)
Search through an Quads object.

virtual NVSG_API void | search (const nvsg::StateAttribute *p)
Search through a StateAttribute object.

virtual NVSG_API void | search (const nvsg::StrippedPrimitiveSet *p)
Search through an StrippedPrimitiveSet.

virtual NVSG_API void | search (const nvsg::Transform *p)
Search through a Transform object.

virtual NVSG_API void | search (const nvsg::Triangles *p)
Search through a Triangles object.

virtual NVSG_API void | search (const nvsg::VertexAttributeSet *p)
Search through a VertexAttributeSet object.

virtual NVSG_API void | search (const nvsg::OwnedObject< nvsg::PrimitiveSetHandle > *p)
Search through an OwnedObject<PrimitiveSetHandle> object.

Detailed Description

Traverser for searching all objects of one class type.

With a search traverser you can scan over a scene and get a vector of pointers to the objects you're searching. It's possible to search for objects of a specific class or for objects that have a specific base class.

Member Typedef Documentation

typedef std::vector<const nvsg::Object*>::const_iterator iterator

Iterator type definition.

Constructor & Destructor Documentation

NVSG_API SearchTraverser ( void )

Constructor.

virtual NVSG_API ~SearchTraverser ( void ) [protected, virtual]

Destructor.

Member Function Documentation

const std::vector< const nvsg::Path * > & getPaths ( void ) const [inline]

Get a constant reference to the vector of paths to the search results.

Returns:
constant reference to the vector of paths to the search results

const std::vector< nvsg::ObjectHandle * > & getResults ( void ) const [inline]

Get a constant reference to the vector of search results.

Returns:
constant reference to the vector of search results

void setClassName ( const std::string & name ) [inline]

Set the class name to search for.

The class name to look for needs to be fully qualified, i.e. "class nvsg::LightSource" instead of "LightSource" only.

Parameters:
name class name to look for in a sceene

void setObjectName ( const std::string & objectName ) [inline]

Set the object name to look for.

Parameters:
objectName object name to look for in a scene

void setObjectPointer ( nvsg::ObjectHandle * ptr ) [inline]

Set the object pointer to look for.

Parameters:
ptr object pointer to look for in a scene

void setBaseClassSearch ( bool enable ) [inline]

Enable/Disable the search for base classes.

If the search for base class is enabled, all classes that are equal to are are derived from the search class are found.

Parameters:
enable true, to enable base class search, otherwise false

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Set up the search and traverse the scene.

Reimplemented from SharedTraverser.

NVSG_API void addItem ( const nvsg::Object * obj ) [protected]

Add an Object to the list of found items.

Parameters:
obj A pointer to the read-locked object to add

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Routine to handle a Billboard node while traversing the scene graph.

Parameters:
p Points to the currently visited Billboard object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Routine to handle a GeoNode while traversing the scene graph.

Parameters:
p Points to the currently visited GeoNode object.

Reimplemented from SharedTraverser.

NVSG_API void handleVolumeNode ( const nvsg::VolumeNode * p ) [protected, virtual]

Routine to handle a VolumeNode while traversing the scene graph.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Routine to handle a Group node while traversing the scene graph.

Parameters:
p Points to the currently visited Group object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFlipbookAnimation ( const nvsg::FlipbookAnimation * p ) [protected, virtual]

Routine to handle a FlipbookAnimation node while traversing the scene graph.

Parameters:
p Points to the currently visited FlipbookAnimation object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Routine to handle a LOD (Level Of Detail) node while traversing the scene graph.

Parameters:
p Points to the currently visited LOD object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Routine to handle a Switch node while traversing the scene graph.

Parameters:
p Points to the currently visited Switch object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Routine to handle a Transform node while traversing the scene graph.

Parameters:
p Points to the currently visited Transform object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Routine to handle a AnimatedTransform node while traversing the scene graph.

Parameters:
p Points to the currently visited AnimatedTransform object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleDirectedLight ( const nvsg::DirectedLight * p ) [protected, virtual]

Routine to handle a DirectedLight node while traversing the scene graph.

Parameters:
p Points to the currently visited DirectedLight object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePointLight ( const nvsg::PointLight * p ) [protected, virtual]

Routine to handle a PointLight node while traversing the scene graph.

Parameters:
p Points to the currently visited PointLight object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSpotLight ( const nvsg::SpotLight * p ) [protected, virtual]

Routine to handle a SpotLight node while traversing the scene graph.

Parameters:
p Points to the currently visited SpotLight object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Routine to handle a Lines object while traversing the scene graph.

Parameters:
p Points to the currently visited Lines object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Routine to handle a LineStrips object while traversing the scene graph.

Parameters:
p Points to the currently visited LineStrips object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Routine to handle a Points object while traversing the scene graph.

Parameters:
p Points to the currently visited Points object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Routine to handle a QuadMeshes object while traversing the scene graph.

Parameters:
p Points to the currently visited QuadMeshes object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Routine to handle a Quads object while traversing the scene graph.

Parameters:
p Points to the currently visited Quads object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Routine to handle a QuadStrips object while traversing the scene graph.

Parameters:
p Points to the currently visited QuadStrips object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Routine to handle a Triangles object while traversing the scene graph.

Parameters:
p Points to the currently visited Triangles object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Routine to handle a SkinnedTriangles object while traversing the scene graph.

Parameters:
p Points to the currently visited SkinnedTriangles object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Routine to handle a TriFans object while traversing the scene graph.

Parameters:
p Points to the currently visited TriFans object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Routine to handle a TriStrips object while traversing the scene graph.

Parameters:
p Points to the currently visited TriStrips object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Routine to handle a StateSet object while traversing the scene graph.

Parameters:
p Points to the currently visited StateSet object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleStateVariant ( const nvsg::StateVariant * p ) [protected, virtual]

Routine to handle a StateVariant object while traversing the scene graph.

Parameters:
p Points to the currently visited StateVariant object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Routine to handle a StatePass object while traversing the scene graph.

Parameters:
p Points to the currently visited StatePass object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleBlendAttribute ( const nvsg::BlendAttribute * p ) [protected, virtual]

Routine to handle a BlendAttribute attribute while traversing the scene graph.

Parameters:
p Points to the currently visited BlendAttribute object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Routine to handle a CgFx attribute while traversing the scene graph.

Parameters:
p Points to the currently visited CgFx object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleDepthAttribute ( const nvsg::DepthAttribute * p ) [protected, virtual]

Routine to handle a DepthAttribute attribute while traversing the scene graph.

Parameters:
p Points to the currently visited DepthAttribute object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFaceAttribute ( const nvsg::FaceAttribute * p ) [protected, virtual]

Routine to handle a FaceAttribute attribute while traversing the scene graph.

Parameters:
p Points to the currently visited FaceAttribute object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLineAttribute ( const nvsg::LineAttribute * p ) [protected, virtual]

Routine to handle a LineAttribute attribute while traversing the scene graph.

Parameters:
p Points to the currently visited LineAttribute object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleMaterial ( const nvsg::Material * p ) [protected, virtual]

Routine to handle a Material attribute while traversing the scene graph.

Parameters:
p Points to the currently visited Material object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePointAttribute ( const nvsg::PointAttribute * p ) [protected, virtual]

Routine to handle a PointAttribute attribute while traversing the scene graph.

Parameters:
p Points to the currently visited PointAttribute object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleTextureAttribute ( const nvsg::TextureAttribute * p ) [protected, virtual]

Routine to handle a TextureAttribute attribute while traversing the scene graph.

Parameters:
p Points to the currently visited TextureAttribute object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleUnlitColorAttribute ( const nvsg::UnlitColorAttribute * p ) [protected, virtual]

Routine to handle an UnlitColorAttribute attribute while traversing the scene graph.

Parameters:
p Points to the currently visited UnlitColorAttribute object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleParallelCamera ( const nvsg::ParallelCamera * p ) [protected, virtual]

Routine to handle a ParallelCamera object while traversing the scene graph.

Parameters:
p Points to the currently visited ParallelCamera object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handlePerspectiveCamera ( const nvsg::PerspectiveCamera * p ) [protected, virtual]

Routine to handle a PerspectiveCamera object while traversing the scene graph.

Parameters:
p Points to the currently visited PerspectiveCamera object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFramedIndexAnimation ( const nvsg::FramedAnimation< unsigned int > * p ) [protected, virtual]

Routine to handle a FramedAnimation<unsigned int> object while traversing the scene graph.

Parameters:
p Points to the currently visited Animation object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFramedTrafoAnimation ( const nvsg::FramedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Routine to handle a FramedAnimation<Trafo> object while traversing the scene graph.

Parameters:
p Points to the currently visited Animation object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleFramedVertexAttributeAnimation ( const nvsg::FramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Routine to handle a FramedAnimation<VertexAttribute> object while traversing the scene graph.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLinearInterpolatedTrafoAnimation ( const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Routine to handle a LinearInterpolatedAnimation<Trafo> object while traversing the scene graph.

Parameters:
p Points to the currently visited Animation object.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleLinearInterpolatedVertexAttributeAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Routine to handle a LinearInterpolatedAnimation<VertexAttribute> object while traversing the scene graph.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * vas ) [protected, virtual]

Routine to handle a VertexAttributeSet object while traversing the scene graph.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleAnimatedVertexAttributeSet ( const nvsg::AnimatedVertexAttributeSet * avas ) [protected, virtual]

Routine to handle a AnimatedVertexAttributeSet object while traversing the scene graph.

Reimplemented from SharedTraverser.

virtual NVSG_API void handleSkin ( const nvsg::Skin * skin ) [protected, virtual]

Routine to handle a Skin object while traversing the scene graph.

Reimplemented from SharedTraverser.

virtual NVSG_API void search ( const nvsg::Animation< nvmath::Trafo > * p ) [protected, virtual]

Search through an Animation<Trafo> object.

This function is called when base class searching is enabled.

Parameters:
p Animation to search through

virtual NVSG_API void search ( const nvsg::Animation< unsigned int > * p ) [protected, virtual]

Search through an Animation<unsigned int> object.

Parameters:
p Animation to search through.
Remarks:
This function is called when base class searching is enabled.

virtual NVSG_API void search ( const nvsg::Animation< nvsg::VertexAttribute > * p ) [protected, virtual]

Search through an Animation<VertexAttribute> object.

This function is called when base class searching is enabled.

virtual NVSG_API void search ( const nvsg::AnimationBase * p ) [protected, virtual]

Search through an AnimationBase object.

Parameters:
p AnimationBase to search through.
Remarks:
This function is called when base class searching is enabled.

virtual NVSG_API void search ( const nvsg::Camera * p ) [protected, virtual]

Search through a Camera object.

This function is called when base class searching is enabled.

Parameters:
p Camera to search through

virtual NVSG_API void search ( const nvsg::Drawable * p ) [protected, virtual]

Search through a Drawable object.

This function is called when base class searching is enabled.

Parameters:
p Drawable to search through

virtual NVSG_API void search ( const nvsg::Group * p ) [protected, virtual]

Search through a Group object.

This function is called when Group is searched through or base class searching is enabled.

Parameters:
p Group to search through

virtual NVSG_API void search ( const nvsg::IndependentPrimitiveSet * p ) [protected, virtual]

Search through an IndependentPrimitiveSet.

This function is called when a base class searching is enabled.

Parameters:
p IndependentPrimitiveSet to search through

virtual NVSG_API void search ( const nvsg::KeyFramedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Search through an KeyFramedAnimation<Trafo>.

This function is called when base class searching is enabled.

Parameters:
p KeyFramedAnimation to search through

virtual NVSG_API void search ( const nvsg::KeyFramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Search through an KeyFramedAnimation<VertexAttribute>.

This function is called when base class searching is enabled.

virtual NVSG_API void search ( const nvsg::LightSource * p ) [protected, virtual]

Search through a LightSource object.

This function is called when base class searching is enabled.

Parameters:
p LightSource to search through

virtual NVSG_API void search ( const nvsg::MeshedPrimitiveSet * p ) [protected, virtual]

Search through a MeshedPrimitiveSet.

This function is called when a base class searching is enabled.

Parameters:
p MeshedPrimitiveSet to search through

virtual NVSG_API void search ( const nvsg::Node * p ) [protected, virtual]

Search through a Node object.

This function is called when base class searching is enabled.

Parameters:
p Node to search through

virtual NVSG_API void search ( const nvsg::Object * p ) [protected, virtual]

Search through an Object object.

This function is called when base class searching is enabled.

Parameters:
p Object to search through

virtual NVSG_API void search ( const nvsg::PrimitiveSet * p ) [protected, virtual]

Search through a PrimitiveSet object.

This function is called when base class searching is enabled.

Parameters:
p PrimitiveSet to search through

virtual NVSG_API void search ( const nvsg::Quads * p ) [protected, virtual]

Search through an Quads object.

This function is called when a Quad is search through or a base class searching is enabled.

Parameters:
p Quads to search through

virtual NVSG_API void search ( const nvsg::StateAttribute * p ) [protected, virtual]

Search through a StateAttribute object.

This function is called when base class searching is enabled.

Parameters:
p StateAttribute to search through

virtual NVSG_API void search ( const nvsg::StrippedPrimitiveSet * p ) [protected, virtual]

Search through an StrippedPrimitiveSet.

This function is called when a base class searching is enabled.

Parameters:
p StrippedPrimitiveSet to search through

virtual NVSG_API void search ( const nvsg::Transform * p ) [protected, virtual]

Search through a Transform object.

This function is called when Transform is searched or a base class searching is enabled.

Parameters:
p Transform to search through

virtual NVSG_API void search ( const nvsg::Triangles * p ) [protected, virtual]

Search through a Triangles object.

This function is called when a Triangles is searched or a base class searching is enabled.

Parameters:
p Triangles to search through

virtual NVSG_API void search ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

Search through a VertexAttributeSet object.

This function is called when a VertexAttributeSet is searched or a base class searching is enabled.

virtual NVSG_API void search ( const nvsg::OwnedObject< nvsg::PrimitiveSetHandle > * p ) [protected, virtual]

Search through an OwnedObject<PrimitiveSetHandle> object.

This function is called when an OwnedObject<PrimitiveSetHandle> is searched or a base class searching is enabled.

The documentation for this class was generated from the following file:
  • SearchTraverser.h
Generated on Tue Jan 15 10:29:36 2008 for NVSGSDK by NVIDIA


Member List

SearchTraverser Member List

This is the complete list of members for SearchTraverser, including all inherited members.
addItem(const nvsg::Object *obj) | SearchTraverser | [protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | SearchTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
getPaths(void) const | SearchTraverser | [inline]
getResults(void) const | SearchTraverser | [inline]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SearchTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | SearchTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | SearchTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | SearchTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | SearchTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | SearchTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | SearchTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | SearchTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *p) | SearchTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *p) | SearchTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | SearchTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SearchTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | SearchTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | SearchTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | SearchTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SearchTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | SearchTraverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | SearchTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | SearchTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | SearchTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | SearchTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p) | SearchTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p) | SearchTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | SearchTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | SearchTraverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | SearchTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | SearchTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | SearchTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | SearchTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SearchTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | SearchTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | SearchTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | SearchTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | SearchTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | SearchTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | SearchTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | SearchTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | SearchTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | SearchTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | SearchTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | SearchTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *p) | SearchTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SearchTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *p) | SearchTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
iterator typedef | SearchTraverser |
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
search(const nvsg::Animation< nvmath::Trafo > *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Animation< unsigned int > *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Animation< nvsg::VertexAttribute > *p) | SearchTraverser | [protected, virtual]
search(const nvsg::AnimationBase *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Camera *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Drawable *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Group *p) | SearchTraverser | [protected, virtual]
search(const nvsg::IndependentPrimitiveSet *p) | SearchTraverser | [protected, virtual]
search(const nvsg::KeyFramedAnimation< nvmath::Trafo > *p) | SearchTraverser | [protected, virtual]
search(const nvsg::KeyFramedAnimation< nvsg::VertexAttribute > *p) | SearchTraverser | [protected, virtual]
search(const nvsg::LightSource *p) | SearchTraverser | [protected, virtual]
search(const nvsg::MeshedPrimitiveSet *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Node *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Object *p) | SearchTraverser | [protected, virtual]
search(const nvsg::PrimitiveSet *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Quads *p) | SearchTraverser | [protected, virtual]
search(const nvsg::StateAttribute *p) | SearchTraverser | [protected, virtual]
search(const nvsg::StrippedPrimitiveSet *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Transform *p) | SearchTraverser | [protected, virtual]
search(const nvsg::Triangles *p) | SearchTraverser | [protected, virtual]
search(const nvsg::VertexAttributeSet *p) | SearchTraverser | [protected, virtual]
search(const nvsg::OwnedObject< nvsg::PrimitiveSetHandle > *p) | SearchTraverser | [protected, virtual]
SearchTraverser(void) | SearchTraverser |
setBaseClassSearch(bool enable) | SearchTraverser | [inline]
setClassName(const std::string &name) | SearchTraverser | [inline]
setObjectName(const std::string &objectName) | SearchTraverser | [inline]
setObjectPointer(nvsg::ObjectHandle *ptr) | SearchTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SearchTraverser(void) | SearchTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:36 2008 for NVSGSDK by NVIDIA


Shape Class Reference

Abstract base class for shaped geometries like Boxes, Spheres, etc. More...

#include <Shape.h>

Inheritance diagram for Shape:

[legend]
Collaboration diagram for Shape:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~Shape ()
Destructs a Shape.

NVSG_API unsigned int | getNumberOfPrimitiveSets () const
Get the number of PrimitiveSet objects held by this Shape.

NVSG_API PrimitiveSetHandle * | getPrimitiveSet (unsigned int index) const
Returns the PrimitiveSet at the specified zero-based index.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another Shape.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

Protected Member Functions

NVSG_API | Shape ()
Protected default constructor to prevent explicit creation.

NVSG_API | Shape (const Shape &rhs)
Protected copy constructor to prevent explicit creation.

NVSG_API void | addPrimitiveSet (PrimitiveSetHandle *p)
Adds a PrimitiveSet to this Shape.

NVSG_API void | removePrimitiveSet (unsigned int index)
Removes the PrimitiveSet at the specified zero-based index from this Shape.

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Calculates the bounding box of this Shape.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this Shape.

NVSG_API Shape & | operator= (const Shape &rhs)
Assignment operator.

Detailed Description

Abstract base class for shaped geometries like Boxes, Spheres, etc.

Namespace: nvsg
Remarks:
This class provides the common interface for shaped geometries, holding zero or more PrimitiveSet objects.
See also:
Drawable, PrimitiveSet

Constructor & Destructor Documentation

virtual NVSG_API ~Shape ( ) [virtual]

Destructs a Shape.

NVSG_API Shape ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This default constructor is accessible only by derived classes. By default, a Shape holds no PrimitiveSet objects.

NVSG_API Shape ( const Shape & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Shape to copy from
Remarks:
This copy constructor is accessible only by derived classes. The new Shape holds a copy of the PrimitiveSet objects of rhs.

Member Function Documentation

unsigned int getNumberOfPrimitiveSets ( ) const [inline]

Get the number of PrimitiveSet objects held by this Shape.

Returns:
The number of PrimitiveSet objects.
See also:
getPrimitiveSet

PrimitiveSetHandle * getPrimitiveSet ( unsigned int index ) const [inline]

Returns the PrimitiveSet at the specified zero-based index.

Parameters:
index Zero-based index of the PrimitiveSet to get.
Returns:
A pointer to a PrimitiveSetHandle specifying PrimitiveSet at index index.
Note:
The behavior is undefined if index is larger than or equal to the number of PrimitiveSet objects in this Shape.
See also:
getNumberOfPrimitiveSets

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another Shape.

Parameters:
p | A reference to the constant Shape to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the Shape p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Drawable, they are equivalent if their PrimitiveSet objects are pair-wise equivalent. If deepCompare is false, the PrimitiveSet objects are considered to be equivalent if they are pairwise the same pointers; otherwise, a full equivalence test on each pair is initiated.
See also:
Drawable, PrimitiveSet

Reimplemented from Object.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and it is marked as invalid. Then it is validated and the Incarnation of all its PrimitiveSet objects is requested to continue validation down the tree hierarchy.
See also:
nvutil::Incarnation, PrimitiveSet

Reimplemented from Drawable.

NVSG_API void addPrimitiveSet ( PrimitiveSetHandle * p ) [protected]

Adds a PrimitiveSet to this Shape.

Parameters:
p A pointer to a PrimitiveSetHandle specifying the PrimitiveSet to add.
Remarks:
This function is protected to be accessible only by derived classes. Only those are allowed to modify the PrimitiveSet objects of a Shape.
See also:
getNumberOfPrimitives, getPrimitiveSet, removePrimitiveSet

NVSG_API void removePrimitiveSet ( unsigned int index ) [protected]

Removes the PrimitiveSet at the specified zero-based index from this Shape.

Parameters:
index Zero-based index of the PrimitiveSet to remove from this Shape.
Remarks:
This function is protected to be accessible only by derived classes. Only those are allowed to modify the PrimitiveSet objects of a Shape.
Note:
The behavior is undefined if index is larger than or equal to the number of PrimitiveSet objects in this Shape.
See also:
addPrimitiveSet, getNumberOfPrimitiveSets, getPrimitiveSet

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Calculates the bounding box of this Shape.

Returns:
The axis-aligned bounding box of this Shape.
Remarks:
This function is called by the framework when re-calculation of the bounding box is required for this Shape.

Implements Drawable.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this Shape.

Returns:
The bounding sphere of this Shape.
Remarks:
This function is called by the framework to determine the sphere to be used as the bounding sphere. It combines the bounding spheres of the PrimitiveSet objects of this Shape. If there are none, an invalid sphere is returned.
See also:
nvmath::Sphere3f, PrimitiveSet

Implements Drawable.

NVSG_API Shape& operator= ( const Shape & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant Shape to copy from.
Returns:
A reference to the assigned Shape.
Remarks:
This assignment operator is accessible only by derived classes. It calls the assignment operator of Drawable, decreases the reference count of all its PrimitiveSet objects, and copies the PrimitiveSet objects from rhs.

The documentation for this class was generated from the following file:
  • Shape.h
Generated on Tue Jan 15 10:29:16 2008 for NVSGSDK by NVIDIA


Member List

Shape Member List

This is the complete list of members for Shape, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
addPrimitiveSet(PrimitiveSetHandle *p) | Shape | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | Shape | [protected, virtual]
calculateBoundingSphere() const | Shape | [protected, virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | Drawable | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfPrimitiveSets() const | Shape | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getPrimitiveSet(unsigned int index) const | Shape | [inline]
getUserData() const | Object | [inline]
invalidateAnimationContainment() | Drawable |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Shape | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Shape &rhs) | Shape | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
removePrimitiveSet(unsigned int index) | Shape | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
Shape() | Shape | [protected]
Shape(const Shape &rhs) | Shape | [protected]
validateIncarnation() const | Shape | [virtual]
~Drawable(void) | Drawable | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~Shape() | Shape | [virtual]
Generated on Tue Jan 15 10:29:16 2008 for NVSGSDK by NVIDIA


SharedModelViewTraverser Class Reference

Traverser that can handle the model view transform stack. More...

#include <ModelViewTraverser.h>

Inheritance diagram for SharedModelViewTraverser:

[legend]
Collaboration diagram for SharedModelViewTraverser:

[legend]
List of all members.

Protected Member Functions

NVSG_API | SharedModelViewTraverser ()
Protected constructor to prevent instantiation of a ModelViewTraverser.

virtual NVSG_API | ~SharedModelViewTraverser ()
Protected destructor to prevent instantiation of a SharedModelViewTraverser.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Provide special treatment of an AnimatedTransform node.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Provide special treatment of a Billboard node.

virtual NVSG_API void | handleLOD (const nvsg::LOD *lod)
Handler function for an LOD.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Provide special treatment of a Transform node.

virtual NVSG_API bool | preTraverseTransform (const nvmath::Trafo *p)
Handles actions to take between transform stack adjustment and traversal.

virtual NVSG_API void | postTraverseTransform (const nvmath::Trafo *p)
Handles actions to take between traversal and transform stack adjustment.

virtual NVSG_API void | traverseCamera (const nvsg::Camera *camera)
Handle any type of Camera on traversal.

virtual NVSG_API void | lockViewState ()
Override for locking the ViewState.

virtual NVSG_API void | unlockViewState ()
Override for unlocking the ViewState.

Protected Attributes

const nvsg::Camera * | m_lockedCamera
read-locked camera

nvutil::TransformStack m_transformStack
stack of transformations that holds the actual transformations while traversing a tree

Detailed Description

Traverser that can handle the model view transform stack.

Use this class as a base for traversers that need to maintain the current model view transformation.

Note:
All ModelViewTraverser based classes need a valid nvsg::ViewState . If the ViewState is not valid the runtime behaviour is not defined. Call setViewState() with a valid ViewState prior calling apply().

Constructor & Destructor Documentation

NVSG_API SharedModelViewTraverser ( ) [protected]

Protected constructor to prevent instantiation of a ModelViewTraverser.

Note:
A SharedModelViewTraverser doesn't change anything in the scene graph, but might be used by a modifying traverser. therefore, it gets the readOnly flag as a parameter to pass to Traverser.

virtual NVSG_API ~SharedModelViewTraverser ( ) [protected, virtual]

Protected destructor to prevent instantiation of a SharedModelViewTraverser.

Member Function Documentation

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Provide special treatment of an AnimatedTransform node.

An AnimatedTransform is handled as a Transform.

Parameters:
p currently visited AnimatedTransform

Reimplemented from SharedTraverser.

Reimplemented in RayIntersectTraverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Provide special treatment of a Billboard node.

On a Billboard the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Parameters:
p Billboard to handle

Reimplemented from SharedTraverser.

Reimplemented in CullTraverser, RayIntersectTraverser, and RenderTraverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * lod ) [protected, virtual]

Handler function for an LOD.

Parameters:
lod A pointer to the read-locked LOD being traversed.
Remarks:
This function is called from the framework whenever an LOD is encountered on traversal. The LOD lod is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented from SharedTraverser.

Reimplemented in CullTraverser, GLUploadTraverser, and RayIntersectTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Provide special treatment of a Transform node.

On a Transform the modelview matrix is modified, the children are traversed, and the modelview matrix is restored.

Parameters:
p Transform to handle

Reimplemented from SharedTraverser.

Reimplemented in CullTraverser, RayIntersectTraverser, and RenderTraverser.

virtual NVSG_API bool preTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handles actions to take between transform stack adjustment and traversal.

In this base class, this is a NOP.

Parameters:
p Trafo of node to traverse next

Reimplemented in FrustumCullTraverser, RayIntersectTraverser, and RenderTraverser.

virtual NVSG_API void postTraverseTransform ( const nvmath::Trafo * p ) [protected, virtual]

Handles actions to take between traversal and transform stack adjustment.

When this function returns true, the subtree beneath is traversed. Otherwise it isn't.

Returns:
true
Parameters:
p Trafo of node that was traversed immediately before this call.

Reimplemented in FrustumCullTraverser, RayIntersectTraverser, and RenderTraverser.

virtual NVSG_API void traverseCamera ( const nvsg::Camera * camera ) [protected, virtual]

Handle any type of Camera on traversal.

Parameters:
camera The read-locked camera to traverse.
Remarks:
This function is called by the framework while traversing any type of Camera. On traversal, no or one camera will be traversed. The stack of transforms is initialized with the world-to-view and the view-to-clip matrices. Moreover, the camera is stored, referenced, and locked for further usage. It will be unlocked and unreferenced in doApply.
See also:
lockCamera, unlockCamera

Reimplemented from SharedTraverser.

virtual NVSG_API void lockViewState ( ) [protected, virtual]

Override for locking the ViewState.

Remarks:
This function is called from the framework when the ViewState set by setViewState is to be locked.
See also:
setViewState, unlockViewState

Reimplemented from SharedTraverser.

Reimplemented in GLUploadTraverser.

virtual NVSG_API void unlockViewState ( ) [protected, virtual]

Override for unlocking the ViewState.

Remarks:
This function is called from the framework when the ViewState set by setViewState is to be unlocked.
See also:
setViewState, lockViewState

Reimplemented from SharedTraverser.

Member Data Documentation

const nvsg::Camera* m_lockedCamera [protected]

read-locked camera

nvutil::TransformStack m_transformStack [protected]

stack of transformations that holds the actual transformations while traversing a tree

The documentation for this class was generated from the following file:
  • ModelViewTraverser.h
Generated on Tue Jan 15 10:29:32 2008 for NVSGSDK by NVIDIA


Member List

SharedModelViewTraverser Member List

This is the complete list of members for SharedModelViewTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | SharedTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SharedModelViewTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | SharedTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | SharedModelViewTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *anim) | SharedTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *gnode) | SharedTraverser | [protected, virtual]
handleGroup(const nvsg::Group *group) | SharedTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | SharedTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | SharedTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *lod) | SharedModelViewTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | SharedTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | SharedTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | SharedTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | SharedTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *variant) | SharedTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *swtch) | SharedTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | SharedModelViewTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | SharedTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | SharedTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | SharedTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SharedTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *vnode) | SharedTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedModelViewTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedCamera | SharedModelViewTraverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_transformStack | SharedModelViewTraverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | SharedModelViewTraverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | SharedModelViewTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedModelViewTraverser() | SharedModelViewTraverser | [protected]
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedModelViewTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedModelViewTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedModelViewTraverser() | SharedModelViewTraverser | [protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:32 2008 for NVSGSDK by NVIDIA


SharedTraverser Class Reference

Base class providing an interface for read-only traversing of a given scene graph. More...

#include <Traverser.h>

Inheritance diagram for SharedTraverser:

[legend]
Collaboration diagram for SharedTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | SharedTraverser ()
Default constructor.

Protected Member Functions

virtual NVSG_API | ~SharedTraverser ()
Protected Destructor to prevent instantiation.

template<typename T, typename U> void | addObjectHandler (unsigned int objectCode, void(T::*handler)(const U *))
Template function to add a handler routine for a new class derived from Object.

template<typename T, typename U, typename V> void | addObjectHandler (unsigned int objectCode, void(T::*handler)(const U *, V))
Template function to add a handler routine for a new class derived from Object.

virtual NVSG_API const nvsg::Object * | lockObject (nvsg::ObjectHandle *obj)
Override of the object locking interface.

virtual NVSG_API void | unlockObject (nvsg::ObjectHandle *obj)
Override of the object unlocking interface.

virtual NVSG_API void | lockViewState ()
Override of the ViewState locking interface.

virtual NVSG_API void | unlockViewState ()
Override of the ViewState unlocking interface.

virtual NVSG_API void | lockScene ()
Override of the Scene locking interface.

virtual NVSG_API void | unlockScene ()
Override of the Scene unlocking interface.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Override of the traversal initiating interface.

virtual NVSG_API void | handleParallelCamera (const nvsg::ParallelCamera *camera)
Handler function for a ParallelCamera.

virtual NVSG_API void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *camera)
Handler function for a PerspectiveCamera.

virtual NVSG_API void | handleGroup (const nvsg::Group *group)
Handler function for a Group.

virtual NVSG_API void | handleFlipbookAnimation (const nvsg::FlipbookAnimation *anim)
Handler function for a FlipbookAnimation.

virtual NVSG_API void | handleTransform (const nvsg::Transform *trafo)
Handler function for a Transform.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *trafo)
Handler function for an AnimatedTransform.

virtual NVSG_API void | handleLOD (const nvsg::LOD *lod)
Handler function for an LOD.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *swtch)
Handler function for a Switch.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *billboard)
Handler function for a Billboard.

virtual NVSG_API void | handleDirectedLight (const nvsg::DirectedLight *light)
Handler function for a DirectedLight.

virtual NVSG_API void | handlePointLight (const nvsg::PointLight *light)
Handler function for a PointLight.

virtual NVSG_API void | handleSpotLight (const nvsg::SpotLight *light)
Handler function for a SpotLight.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *gnode)
Handler function for a GeoNode.

virtual NVSG_API void | handleQuads (const nvsg::Quads *quads)
Handler function for a Quads.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *triangles)
Handler function for a Triangles.

virtual NVSG_API void | handleSkinnedTriangles (const nvsg::SkinnedTriangles *triangles)
Handler function for a SkinnedTriangles.

virtual NVSG_API void | handleLines (const nvsg::Lines *lines)
Handler function for a Lines.

virtual NVSG_API void | handlePoints (const nvsg::Points *points)
Handler function for a Points.

virtual NVSG_API void | handleQuadMeshes (const nvsg::QuadMeshes *meshes)
Handler function for a QuadsMeshes.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *strips)
Handler function for a QuadStrips.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *fans)
Handler function for a TriFans.

virtual NVSG_API void | handleTriStrips (const nvsg::TriStrips *strips)
Handler function for a TriStrips.

virtual NVSG_API void | handleLineStrips (const nvsg::LineStrips *strips)
Handler function for a LineStrips.

virtual NVSG_API void | handleShape (const nvsg::Shape *shape)
Handler function for a Shape.

virtual NVSG_API void | handleStateSet (const nvsg::StateSet *stateSet)
Handler function for a StateSet.

virtual NVSG_API void | handleStateVariant (const nvsg::StateVariant *variant)
Handler function for a StateVariant.

virtual NVSG_API void | handleStatePass (const nvsg::StatePass *pass)
Handler function for a StatePass.

virtual NVSG_API void | handleCgFx (const nvsg::CgFx *cgfx)
Handler function for a CgFx.

virtual NVSG_API void | handleMaterial (const nvsg::Material *material)
Handler function for a Material.

virtual NVSG_API void | handleTextureAttribute (const nvsg::TextureAttribute *texAttrib)
Handler function for a TextureAttribute.

virtual NVSG_API void | handleTextureAttributeItem (const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu)
Handler function for a TextureAttributeItem.

virtual NVSG_API void | handleAlphaTestAttribute (const nvsg::AlphaTestAttribute *alphaTestAttrib)
Handler function for a AlphaTestAttribute.

virtual NVSG_API void | handleBlendAttribute (const nvsg::BlendAttribute *blendAttrib)
Handler function for a BlendAttribute.

virtual NVSG_API void | handleDepthAttribute (const nvsg::DepthAttribute *depthAttrib)
Handler function for a DepthAttribute.

virtual NVSG_API void | handleFaceAttribute (const nvsg::FaceAttribute *faceAttrib)
Handler function for a FaceAttribute.

virtual NVSG_API void | handleLightingAttribute (const nvsg::LightingAttribute *laAttrib)
Handler function for a LightingAttribute.

virtual NVSG_API void | handleLineAttribute (const nvsg::LineAttribute *lineAttrib)
Handler function for a LineAttribute.

virtual NVSG_API void | handlePointAttribute (const nvsg::PointAttribute *pointAttrib)
Handler function for a PointAttribute.

virtual NVSG_API void | handleUnlitColorAttribute (const nvsg::UnlitColorAttribute *unlitColor)
Handler function for an UnlitColorAttribute.

virtual NVSG_API void | handleMapArray (const nvsg::MapArray *mapArray)
Handler function for a MapArray.

virtual NVSG_API void | handleMapElement (const nvsg::MapElement *mapElement)
Handler function for a MapElement.

virtual NVSG_API void | handleMapMatrix (const nvsg::MapMatrix *mapMatrix)
Handler function for a MapMatrix.

virtual NVSG_API void | handleMapList (const nvsg::MapList *mapList)
Handler function for a MapList.

virtual NVSG_API void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *vas)
Handler function for a VertexAttributeSet.

virtual NVSG_API void | handleAnimatedVertexAttributeSet (const nvsg::AnimatedVertexAttributeSet *avas)
Handler function for an AnimatedVertexAttributeSet.

virtual NVSG_API void | handleSkin (const nvsg::Skin *skin)
Handler function for a Skin.

virtual NVSG_API void | handleFramedIndexAnimation (const nvsg::FramedAnimation< unsigned int > *anim)
Handler function for a FramedAnimation<unsigned int>.

virtual NVSG_API void | handleFramedTrafoAnimation (const nvsg::FramedAnimation< nvmath::Trafo > *trafo)
Handler function for a FramedAnimation<nvmath::Trafo>.

virtual NVSG_API void | handleFramedVertexAttributeAnimation (const nvsg::FramedAnimation< nvsg::VertexAttribute > *p)
Handler function for a FramedAnimation<VertexAttribute>.

virtual NVSG_API void | handleLinearInterpolatedTrafoAnimation (const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo)
Handler function for a LinearInterpolatedAnimation<nvmath::Trafo>.

virtual NVSG_API void | handleLinearInterpolatedVertexAttributeAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p)
Handler function for a LinearInterpolatedAnimation<VertexAttribute>.

virtual NVSG_API void | handleHighlightBox (const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset)
Handler function for a HighlightBox.

virtual NVSG_API void | handleHighlightEdges (const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset)
Handler function for a HighlightEdges.

virtual NVSG_API void | handleVolumeNode (const nvsg::VolumeNode *vnode)
Handler function for a VolumeNode.

virtual NVSG_API void | traverseCamera (const nvsg::Camera *camera)
Function for common handling of Camera classes.

virtual NVSG_API void | traverseLight (const nvsg::LightSource *light)
Function for common handling of LightSource classes.

virtual NVSG_API void | traversePrimitiveSet (const nvsg::PrimitiveSet *pset)
Function for common handling of PrimitiveSet classes.

virtual NVSG_API void | traverseHighlightObject (const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset)
Function for common handling of HighlightObject classes.

Protected Attributes

const nvsg::Scene * | m_lockedScene
A pointer to the read-locked Scene currently traversed.

const nvsg::ViewState * | m_lockedViewState
A pointer to the read-locked ViewState used in the current traversal.

Detailed Description

Base class providing an interface for read-only traversing of a given scene graph.

Remarks:
The SharedTraverser class offers base functionality for all traversers that intend to provide read-only operations on a given scene graph. For all known and concrete Objects this class provides a set of overloadable handler routines, each ensuring that all components following the actual object in the graph hierarchy will be traversed correctly. Hence, for derived traversers it is recommended to always call the base implementation of an overloaded handler routine for traversing purposes.
To provide new read-only operations to be applied on known and concrete components or objects arranged in a scene graph, it is sufficient to derive a new traverser from either SharedTraverser or one of its derived traversers, and overload the corresponding handler routines as needed.
See also:
ExclusiveTraverser

Constructor & Destructor Documentation

NVSG_API SharedTraverser ( )

Default constructor.

virtual NVSG_API ~SharedTraverser ( ) [inline, protected, virtual]

Protected Destructor to prevent instantiation.

Member Function Documentation

void addObjectHandler | ( | unsigned int | objectCode,
 |  | void(T::* | handler)(const U *)
 | ) | [inline, protected]

Template function to add a handler routine for a new class derived from Object.

Parameters:
objectCode | Object code to identify an object type at run-time.
handler | Specifies the address of the handler routine.
Remarks:
The function registers the handler routine specified by handler to handle a concrete class, derived from Object, that is explicitly identified by objectCode.
A handler routine must be a member function of a Traverser-derived class. It must return void and expect a pointer to the concrete object as a first parameter, and can have one additional (optional) argument of arbitrary type. A handler routine must not have a default argument! If a handler routine is intended to remain overloadable, it should be declared virtual.
For derived classes intended to provide new operations for known objects arranged in a scene graph, it is strongly recommended not to add new handler routines for those objects but to overload the corresponding handler routine. In this context, we refer to 'known objects' as objects that are known by the Traverser base class and for which a corresponding handler routine is provided.
However, addObjectHandler is indispensable if newly invented objects, and hence, objects that are unknown by the Traverser base class, need to be considered for traversing.
Note:
Any previously registered handler routine for the specified object code will be overridden by the new handler.
Example:
    addObjectHandler(
      OC_NEWGROUP   // object code for the new object NewGroup
                    // this must be provided by the author of NewGroup
      , &MySharedTraverser::handleNewGroup // handler function
    );

void addObjectHandler | ( | unsigned int | objectCode,
 |  | void(T::* | handler)(const U *, V)
 | ) | [inline, protected]

Template function to add a handler routine for a new class derived from Object.

Parameters:
objectCode | Object code to identify an object type at run-time.
handler | Specifies the address of the handler routine.
Remarks:
The function registers the handler routine specified by handler to handle a concrete class, derived from Object, that is explicitly identified by objectCode.
A handler routine must be a member function of a Traverser-derived class. It must return void and expect a pointer to the concrete object as a first parameter, and can have one additional (optional) argument of arbitrary type. A handler routine must not have a default argument! If a handler routine is intended to remain overloadable, it should be declared virtual.
For derived classes intended to provide new operations for known objects arranged in a scene graph, it is strongly recommended not to add new handler routines for those objects but to overload the corresponding handler routine. In this context, we refer to 'known objects' as objects that are known by the Traverser base class and for which a corresponding handler routine is provided.
However, addObjectHandler is indispensable if newly invented objects, and hence, objects that are unknown by the Traverser base class, need to be considered for traversing.
Note:
Any previously registered handler routine for the specified object code will be overridden by the new handler.
Example:
    addObjectHandler(
      OC_NEWGROUP   // object code for the new object NewGroup
                    // this must be provided by the author of NewGroup
      , &MySharedTraverser::handleNewGroup // handler function
    );

virtual NVSG_API const nvsg::Object* lockObject ( nvsg::ObjectHandle * obj ) [protected, virtual]

Override of the object locking interface.

Parameters:
obj A pointer to the ObjectHandle to lock.
Returns:
A pointer to a read-locked Object.
Remarks:
This function is called from the framework just before traversal of obj. The SharedTraverser locks the Object for reading.
See also:
unlockObject

Implements Traverser.

virtual NVSG_API void unlockObject ( nvsg::ObjectHandle * obj ) [protected, virtual]

Override of the object unlocking interface.

Parameters:
obj A pointer to the ObjectHandle to unlock.
Remarks:
This function is called from the framework right after traversal of obj. The SharedTraverser unlocks the Object from reading.
See also:
lockObject

Implements Traverser.

virtual NVSG_API void lockViewState ( ) [protected, virtual]

Override of the ViewState locking interface.

Remarks:
This function is called from the framework to lock the current ViewState, if any, for reading.
See also:
setViewState, unlockViewState

Implements Traverser.

Reimplemented in GLUploadTraverser, and SharedModelViewTraverser.

virtual NVSG_API void unlockViewState ( ) [protected, virtual]

Override of the ViewState unlocking interface.

Remarks:
This function is called from the framework to unlock the current ViewState, if any, from reading.
See also:
setViewState, lockViewState

Implements Traverser.

Reimplemented in SharedModelViewTraverser.

virtual NVSG_API void lockScene ( ) [protected, virtual]

Override of the Scene locking interface.

Remarks:
This function is called from the framework to lock the current Scene, if any, for reading.
See also:
setScene, unlockScene

Implements Traverser.

virtual NVSG_API void unlockScene ( ) [protected, virtual]

Override of the Scene unlocking interface.

Remarks:
This function is called from the framework to unlock the current Scene, if any, from reading.
See also:
setScene, lockScene

Implements Traverser.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Override of the traversal initiating interface.

Parameters:
root A pointer to the NodeHandle to start traversal at.
Remarks:
This function is called from the framework after the Scene and the ViewState, if set, are locked. The actual traversal is done here.
See also:
preApply, postApply, lockScene, unlockScene, lockViewState, unlockViewState

Implements Traverser.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, FrustumCullTraverser, GLTraverser, GLUploadTraverser, RayIntersectTraverser, RenderTraverser, and SearchTraverser.

virtual NVSG_API void handleParallelCamera ( const nvsg::ParallelCamera * camera ) [protected, virtual]

Handler function for a ParallelCamera.

Parameters:
camera A pointer to the read-locked ParallelCamera being traversed.
Remarks:
This function is called from the framework whenever a ParallelCamera is encountered on traversal. The ParallelCamera camera is already read-locked.
The base implementation traverses through all the head lights of this camera.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handlePerspectiveCamera

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, and SearchTraverser.

virtual NVSG_API void handlePerspectiveCamera ( const nvsg::PerspectiveCamera * camera ) [protected, virtual]

Handler function for a PerspectiveCamera.

Parameters:
camera A pointer to the read-locked PerspectiveCamera being traversed.
Remarks:
This function is called from the framework whenever a PerspectiveCamera is encountered on traversal. The PerspectiveCamera camera is already read-locked.
The base implementation traverses through all the head lights of this camera.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handleParallelCamera

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, and SearchTraverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * group ) [protected, virtual]

Handler function for a Group.

Parameters:
group A pointer to the read-locked Group being traversed.
Remarks:
This function is called from the framework whenever a Group is encountered on traversal. The Group group is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleFlipbookAnimation ( const nvsg::FlipbookAnimation * anim ) [protected, virtual]

Handler function for a FlipbookAnimation.

Parameters:
anim A pointer to the read-locked FlipbookAnimation being traversed.
Remarks:
This function is called from the framework whenever a FlipbookAnimation is encountered on traversal. The FlipbookAnimation anim is already read-locked.
The base implementation first traverses the associated IndexAnimation, and then calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup, IndexAnimation

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, and SearchTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * trafo ) [protected, virtual]

Handler function for a Transform.

Parameters:
trafo A pointer to the read-locked Transform being traversed.
Remarks:
This function is called from the framework whenever a Transform is encountered on traversal. The Transform trafo is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, ExtractGeometryTraverser, AnalyzeTraverser, CullTraverser, SharedModelViewTraverser, RayIntersectTraverser, RenderTraverser, and SearchTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * trafo ) [protected, virtual]

Handler function for an AnimatedTransform.

Parameters:
trafo A pointer to the read-locked AnimatedTransform being traversed.
Remarks:
This function is called from the framework whenever an AnimatedTransform is encountered on traversal. The AnimatedTransform trafo is already read-locked.
The base implementation first traverses the associated TrafoAnimation, and then calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup, TrafoAnimation

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, ExtractGeometryTraverser, AnalyzeTraverser, SharedModelViewTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * lod ) [protected, virtual]

Handler function for an LOD.

Parameters:
lod A pointer to the read-locked LOD being traversed.
Remarks:
This function is called from the framework whenever an LOD is encountered on traversal. The LOD lod is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, ExtractGeometryTraverser, AnalyzeTraverser, CullTraverser, GLUploadTraverser, SharedModelViewTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * swtch ) [protected, virtual]

Handler function for a Switch.

Parameters:
swtch A pointer to the read-locked Switch being traversed.
Remarks:
This function is called from the framework whenever a Switch is encountered on traversal. The Switch switch is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, ExtractGeometryTraverser, AnalyzeTraverser, CullTraverser, GLUploadTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * billboard ) [protected, virtual]

Handler function for a Billboard.

Parameters:
billboard A pointer to the read-locked Billboard being traversed.
Remarks:
This function is called from the framework whenever a Billboard is encountered on traversal. The Billboard billboard is already read-locked.
The base implementation just calls Traverser::traverseGroup().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGroup, handleGroup

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, ExtractGeometryTraverser, AnalyzeTraverser, CullTraverser, SharedModelViewTraverser, RayIntersectTraverser, RenderTraverser, and SearchTraverser.

virtual NVSG_API void handleDirectedLight ( const nvsg::DirectedLight * light ) [protected, virtual]

Handler function for a DirectedLight.

Parameters:
light A pointer to the read-locked DirectedLight being traversed.
Remarks:
This function is called from the framework whenever a DirectedLight is encountered on traversal. The DirectedLight light is already read-locked.
The base implementation just calls traverseLight().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseLight

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handlePointLight ( const nvsg::PointLight * light ) [protected, virtual]

Handler function for a PointLight.

Parameters:
light A pointer to the read-locked PointLight being traversed.
Remarks:
This function is called from the framework whenever a PointLight is encountered on traversal. The PointLight light is already read-locked.
The base implementation just calls traverseLight().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseLight

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleSpotLight ( const nvsg::SpotLight * light ) [protected, virtual]

Handler function for a SpotLight.

Parameters:
light A pointer to the read-locked SpotLight being traversed.
Remarks:
This function is called from the framework whenever a SpotLight is encountered on traversal. The SpotLight light is already read-locked.
The base implementation just calls traverseLight().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseLight

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * gnode ) [protected, virtual]

Handler function for a GeoNode.

Parameters:
gnode A pointer to the read-locked GeoNode being traversed.
Remarks:
This function is called from the framework whenever a GeoNode is encountered on traversal. The GeoNode gnode is already read-locked.
The base implementation just calls Traverser::traverseGeoNode().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseGeoNode

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * quads ) [protected, virtual]

Handler function for a Quads.

Parameters:
quads A pointer to the read-locked Quads being traversed.
Remarks:
This function is called from the framework whenever a Quads is encountered on traversal. The Quads quads is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * triangles ) [protected, virtual]

Handler function for a Triangles.

Parameters:
triangles A pointer to the read-locked Triangles being traversed.
Remarks:
This function is called from the framework whenever a Triangles is encountered on traversal. The Triangles quads is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * triangles ) [protected, virtual]

Handler function for a SkinnedTriangles.

Parameters:
triangles A pointer to the read-locked Triangles being traversed.
Remarks:
This function is called from the framework whenever a SkinnedTriangles is encountered on traversal. The SkinnedTriangles triangles is already read-locked.
The base implementation first traverses each TrafoAnimation of each bone of each skin, and then calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * lines ) [protected, virtual]

Handler function for a Lines.

Parameters:
lines A pointer to the read-locked Lines being traversed.
Remarks:
This function is called from the framework whenever a Lines is encountered on traversal. The Lines lines is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * points ) [protected, virtual]

Handler function for a Points.

Parameters:
points A pointer to the read-locked Points being traversed.
Remarks:
This function is called from the framework whenever a Points is encountered on traversal. The Points points is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * meshes ) [protected, virtual]

Handler function for a QuadsMeshes.

Parameters:
meshes A pointer to the read-locked QuadsMeshes being traversed.
Remarks:
This function is called from the framework whenever a QuadsMeshes is encountered on traversal. The QuadsMeshes meshes is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * strips ) [protected, virtual]

Handler function for a QuadStrips.

Parameters:
strips A pointer to the read-locked QuadStrips being traversed.
Remarks:
This function is called from the framework whenever a QuadStrips is encountered on traversal. The QuadStrips strips is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * fans ) [protected, virtual]

Handler function for a TriFans.

Parameters:
fans A pointer to the read-locked TriFans being traversed.
Remarks:
This function is called from the framework whenever a TriFans is encountered on traversal. The TriFans fans is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * strips ) [protected, virtual]

Handler function for a TriStrips.

Parameters:
strips A pointer to the read-locked TriStrips being traversed.
Remarks:
This function is called from the framework whenever a TriStrips is encountered on traversal. The TriStrips strips is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * strips ) [protected, virtual]

Handler function for a LineStrips.

Parameters:
strips A pointer to the read-locked LineStrips being traversed.
Remarks:
This function is called from the framework whenever a LineStrips is encountered on traversal. The LineStrips strips is already read-locked.
The base implementation just calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleShape ( const nvsg::Shape * shape ) [protected, virtual]

Handler function for a Shape.

Parameters:
shape A pointer to the read-locked Shape being traversed.
Remarks:
This function is called from the framework whenever a Shape is encountered on traversal. The Shape shape is already read-locked.
The base implementation just calls Traverser::traverseShape().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseShape

Reimplemented in AnalyzeTraverser, and CullTraverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * stateSet ) [protected, virtual]

Handler function for a StateSet.

Parameters:
stateSet A pointer to the read-locked StateSet being traversed.
Remarks:
This function is called from the framework whenever a StateSet is encountered on traversal. The StateSet stateSet is already read-locked.
The base implementation just traverses the active StateVariant.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
StateVariant

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleStateVariant ( const nvsg::StateVariant * variant ) [protected, virtual]

Handler function for a StateVariant.

Parameters:
variant A pointer to the read-locked StateVariant being traversed.
Remarks:
This function is called from the framework whenever a StateVariant is encountered on traversal. The StateVariant variant is already read-locked.
The base implementation just call Traverser::traverseStateVariant().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseStateVariant

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, RenderTraverser, and SearchTraverser.

virtual NVSG_API void handleStatePass ( const nvsg::StatePass * pass ) [protected, virtual]

Handler function for a StatePass.

Parameters:
pass A pointer to the read-locked StatePass being traversed.
Remarks:
This function is called from the framework whenever a StateSet is encountered on traversal. The StatePass pass is already read-locked.
The base implementation just call Traverser::traverseStatePass().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseStatePass

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleCgFx ( const nvsg::CgFx * cgfx ) [protected, virtual]

Handler function for a CgFx.

Parameters:
cgfx A pointer to the read-locked CgFx being traversed.
Remarks:
This function is called from the framework whenever a CgFx is encountered on traversal. The CgFx cgfx is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleMaterial ( const nvsg::Material * material ) [protected, virtual]

Handler function for a Material.

Parameters:
material A pointer to the read-locked Material being traversed.
Remarks:
This function is called from the framework whenever a Material is encountered on traversal. The Material material is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleTextureAttribute ( const nvsg::TextureAttribute * texAttrib ) [protected, virtual]

Handler function for a TextureAttribute.

Parameters:
texAttrib A pointer to the read-locked TextureAttribute being traversed.
Remarks:
This function is called from the framework whenever a TextureAttribute is encountered on traversal. The TextureAttribute texAttrib is already read-locked.
The base implementation just calls Traverser::traverseTextureAttribute().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseTextureAttribute

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | texAttribItem,
 |  | unsigned int | tu
 | ) | [protected, virtual]

Handler function for a TextureAttributeItem.

Parameters:
texAttribItem | A pointer to the read-locked TextureAttributeItem being traversed.
tu | Index of the texture unit to use.
Remarks:
This function is called from the framework whenever a TextureAttributeItem is encountered on traversal. The TextureAttributeItem texAttribItem is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, and AnalyzeTraverser.

virtual NVSG_API void handleAlphaTestAttribute ( const nvsg::AlphaTestAttribute * alphaTestAttrib ) [protected, virtual]

Handler function for a AlphaTestAttribute.

Parameters:
alphaTestAttrib A pointer to the read-locked AlphaTestAttribute being traversed.
Remarks:
This function is called from the framework whenever a AlphaTestAttribute is encountered on traversal. The AlphaTestAttribute alphaTestAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, and NVSGSaveTraverser.

virtual NVSG_API void handleBlendAttribute ( const nvsg::BlendAttribute * blendAttrib ) [protected, virtual]

Handler function for a BlendAttribute.

Parameters:
blendAttrib A pointer to the read-locked BlendAttribute being traversed.
Remarks:
This function is called from the framework whenever a BlendAttribute is encountered on traversal. The BlendAttribute blendAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleDepthAttribute ( const nvsg::DepthAttribute * depthAttrib ) [protected, virtual]

Handler function for a DepthAttribute.

Parameters:
depthAttrib A pointer to the read-locked DepthAttribute being traversed.
Remarks:
This function is called from the framework whenever a DepthAttribute is encountered on traversal. The DepthAttribute depthAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleFaceAttribute ( const nvsg::FaceAttribute * faceAttrib ) [protected, virtual]

Handler function for a FaceAttribute.

Parameters:
faceAttrib A pointer to the read-locked FaceAttribute being traversed.
Remarks:
This function is called from the framework whenever a FaceAttribute is encountered on traversal. The FaceAttribute faceAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleLightingAttribute ( const nvsg::LightingAttribute * laAttrib ) [protected, virtual]

Handler function for a LightingAttribute.

Parameters:
laAttrib A pointer to the read-locked LightingAttribute being traversed.
Remarks:
This function is called from the framework whenever a LightingAttribute is encountered on traversal. The LightingAttribute laAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, and NVSGSaveTraverser.

virtual NVSG_API void handleLineAttribute ( const nvsg::LineAttribute * lineAttrib ) [protected, virtual]

Handler function for a LineAttribute.

Parameters:
lineAttrib A pointer to the read-locked LineAttribute being traversed.
Remarks:
This function is called from the framework whenever a LineAttribute is encountered on traversal. The LineAttribute lineAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handlePointAttribute ( const nvsg::PointAttribute * pointAttrib ) [protected, virtual]

Handler function for a PointAttribute.

Parameters:
pointAttrib A pointer to the read-locked PointAttribute being traversed.
Remarks:
This function is called from the framework whenever a PointAttribute is encountered on traversal. The PointAttribute pointAttrib is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleUnlitColorAttribute ( const nvsg::UnlitColorAttribute * unlitColor ) [protected, virtual]

Handler function for an UnlitColorAttribute.

Parameters:
unlitColor A pointer to the read-locked UnlitColorAttribute being traversed.
Remarks:
This function is called from the framework whenever an UnlitColorAttribute is encountered on traversal. The UnlitColorAttribute unlitColor is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, and SearchTraverser.

virtual NVSG_API void handleMapArray ( const nvsg::MapArray * mapArray ) [protected, virtual]

Handler function for a MapArray.

Parameters:
mapArray A pointer to the read-locked MapArray being traversed.
Remarks:
This function is called from the framework whenever a MapArray is encountered on traversal. The MapArray mapArray is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handleMapElement, handleMapMatrix

Reimplemented in GLTraverser.

virtual NVSG_API void handleMapElement ( const nvsg::MapElement * mapElement ) [protected, virtual]

Handler function for a MapElement.

Parameters:
mapElement A pointer to the read-locked MapElement being traversed.
Remarks:
This function is called from the framework whenever a MapElement is encountered on traversal. The MapElement mapElement is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handleMapArray, handleMapMatrix

Reimplemented in GLTraverser.

virtual NVSG_API void handleMapMatrix ( const nvsg::MapMatrix * mapMatrix ) [protected, virtual]

Handler function for a MapMatrix.

Parameters:
mapMatrix A pointer to the read-locked MapMatrix being traversed.
Remarks:
This function is called from the framework whenever a MapMatrix is encountered on traversal. The MapMatrix mapMatrix is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
handleMapArray, handleMapElement

Reimplemented in GLTraverser.

virtual NVSG_API void handleMapList ( const nvsg::MapList * mapList ) [protected, virtual]

Handler function for a MapList.

Parameters:
mapList A pointer to the read-locked MapList being traversed.
Remarks:
This function is called from the framework whenever a MapList is encountered on traversal. The MapList mapList is already read-locked.
The base implementation just calls Traverser::traverseMapList().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseMapList

Reimplemented in GLTraverser.

virtual NVSG_API void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * vas ) [protected, virtual]

Handler function for a VertexAttributeSet.

Parameters:
vas A pointer to the read-locked VertexAttributeSet being traversed.
Remarks:
This function is called from the framework whenever a VertexAttributeSet is encountered on traversal. The VertexAttributeSet vas is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, and SearchTraverser.

virtual NVSG_API void handleAnimatedVertexAttributeSet ( const nvsg::AnimatedVertexAttributeSet * avas ) [protected, virtual]

Handler function for an AnimatedVertexAttributeSet.

Parameters:
avas A pointer to the read-locked AnimatedVertexAttributeSet being traversed.
Remarks:
This function is called from the framework whenever an AnimatedVertexAttributeSet is encountered on traversal. The AnimatedVertexAttributeSet avas is already read-locked.
The base implementation traverses each VertexAttributeAnimationHandle of avas and holds the index of the currently traversed VertexAttributeAnimationHandle in the protected member variable m_currentAttrib.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, RenderTraverser, and SearchTraverser.

virtual NVSG_API void handleSkin ( const nvsg::Skin * skin ) [protected, virtual]

Handler function for a Skin.

Parameters:
skin A pointer to the read-locked Skin being traversed.
Remarks:
This function is called from the framework whenever a Skin is encountered on traversal. The Skin skin is already read-locked.
The base implementation just does nothing.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleFramedIndexAnimation ( const nvsg::FramedAnimation< unsigned int > * anim ) [protected, virtual]

Handler function for a FramedAnimation<unsigned int>.

Parameters:
anim A pointer to the read-locked FramedAnimation<unsigned int> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<unsigned int> is encountered on traversal. The FramedAnimation<unsigned int> anim is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleFramedTrafoAnimation ( const nvsg::FramedAnimation< nvmath::Trafo > * trafo ) [protected, virtual]

Handler function for a FramedAnimation<nvmath::Trafo>.

Parameters:
trafo A pointer to the read-locked FramedAnimation<nvmath::Trafo> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<nvmath::Trafo> is encountered on traversal. The FramedAnimation<nvmath::Trafo> trafo is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleFramedVertexAttributeAnimation ( const nvsg::FramedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Handler function for a FramedAnimation<VertexAttribute>.

Parameters:
p A pointer to the read-locked FramedAnimation<VertexAttribute> being traversed.
Remarks:
This function is called from the framework whenever a FramedAnimation<VertexAttribute> is encountered on traversal. The FramedAnimation<VertexAttribute> p is already read-locked.
The base implementation just does nothing
See also:
handleLinearInterpolatedVertexAttributeAnimation

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleLinearInterpolatedTrafoAnimation ( const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > * trafo ) [protected, virtual]

Handler function for a LinearInterpolatedAnimation<nvmath::Trafo>.

Parameters:
trafo A pointer to the read-locked LinearInterpolatedAnimation<nvmath::Trafo> being traversed.
Remarks:
This function is called from the framework whenever a LinearInterpolatedAnimation<nvmath::Trafo> is encountered on traversal. The LinearInterpolatedAnimation<nvmath::Trafo> trafo is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleLinearInterpolatedVertexAttributeAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > * p ) [protected, virtual]

Handler function for a LinearInterpolatedAnimation<VertexAttribute>.

Parameters:
p A pointer to the read-locked LinearInterpolatedAnimation<VertexAttribute> being traversed.
Remarks:
This function is called from the framework whenever a LinearInterpolatedAnimation<VertexAttribute> is encountered on traversal. The LinearInterpolatedAnimation<VertexAttribute> p is already read-locked.
The base implementation just does nothing
See also:
handleFramedVertexAttributeAnimation

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleHighlightBox | ( | const nvsg::HighlightBox * | hlBox,
 |  | const nvsg::PrimitiveSet * | pset
 | ) | [protected, virtual]

Handler function for a HighlightBox.

Parameters:
hlBox | A pointer to the read-locked HighlightBox being traversed.
pset | A pointer to the read-locked PrimitiveSet, that hlBox is associated to.
Remarks:
This function is called from the framework whenever a HighlightBox is encountered on traversal. The HighlightBox hlBox is already read-locked.
The base implementation just calls traverseHighlightObject().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseHighlightObject

virtual NVSG_API void handleHighlightEdges | ( | const nvsg::HighlightEdges * | hlEdges,
 |  | const nvsg::PrimitiveSet * | pset
 | ) | [protected, virtual]

Handler function for a HighlightEdges.

Parameters:
hlEdges | A pointer to the read-locked HighlightEdges being traversed.
pset | A pointer to the read-locked PrimitiveSet, that hlEdges is associated to.
Remarks:
This function is called from the framework whenever a HighlightEdges is encountered on traversal. The HighlightEdges hlEdges is already read-locked.
The base implementation just calls traverseHighlightObject().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseHighlightObject

virtual NVSG_API void handleVolumeNode ( const nvsg::VolumeNode * vnode ) [protected, virtual]

Handler function for a VolumeNode.

Parameters:
vnode A pointer to the read-locked VolumeNode being traversed.
Remarks:
This function is called from the framework whenever a VolumeNode is encountered on traversal. The VolumeNode vnode is already read-locked.
The base implementation just calls Traverser::traverseVolumeNode().
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traverseVolumeNode

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, CullTraverser, RayIntersectTraverser, RenderTraverser, and SearchTraverser.

virtual NVSG_API void traverseCamera ( const nvsg::Camera * camera ) [protected, virtual]

Function for common handling of Camera classes.

Parameters:
camera A pointer to the read-locked Camera being traversed.
Remarks:
This function is called from the framework whenever a Camera is encountered on traversal. The Camera camera is already read-locked.
The base implementation traverses the headlights of camera.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
LightSource

Reimplemented in SharedModelViewTraverser.

virtual NVSG_API void traverseLight ( const nvsg::LightSource * light ) [protected, virtual]

Function for common handling of LightSource classes.

Parameters:
light A pointer to the read-locked LightSource being traversed.
Remarks:
This function is called from the framework whenever a LightSource is encountered on traversal. The LightSource light is already read-locked.
The base implementation traverses the Animation associated with light, if there is one.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
TrafoAnimation

Reimplemented in RenderTraverser.

virtual NVSG_API void traversePrimitiveSet ( const nvsg::PrimitiveSet * pset ) [protected, virtual]

Function for common handling of PrimitiveSet classes.

Parameters:
pset A pointer to the read-locked PrimitiveSet being traversed.
Remarks:
This function is called from the framework whenever a PrimitiveSet is encountered on traversal. The PrimitiveSet pset is already read-locked.
The base implementation first traverses the Skin, if there is one, and then the VertexAttributeSet of pset, if there is one. If pset is highlighted, the associated HighlightObject is traversed.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
VertexAttributeSet, HighlightObject

Reimplemented in ExtractGeometryTraverser, CullTraverser, and RenderTraverser.

virtual NVSG_API void traverseHighlightObject | ( | const nvsg::HighlightObject * | hlObject,
 |  | const nvsg::PrimitiveSet * | pset
 | ) | [protected, virtual]

Function for common handling of HighlightObject classes.

Parameters:
hlObject | A pointer to the read-locked HighlightObject being traversed.
pset | A pointer to the read-locked PrimitiveSet to be highlighted.
Remarks:
This function is called from the framework whenever a HighlightObject is encountered on traversal. The HighlightObject hlObject is already read-locked.
The base implementation just does nothing.
Note:
When this function is overloaded by a traverser derived from SharedTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.

Member Data Documentation

const nvsg::Scene* m_lockedScene [protected]

A pointer to the read-locked Scene currently traversed.

const nvsg::ViewState* m_lockedViewState [protected]

A pointer to the read-locked ViewState used in the current traversal.

The documentation for this class was generated from the following file:
  • Traverser.h
Generated on Tue Jan 15 10:29:38 2008 for NVSGSDK by NVIDIA


Member List

SharedTraverser Member List

This is the complete list of members for SharedTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *)) | SharedTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(const U *, V)) | SharedTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | SharedTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
handleAlphaTestAttribute(const nvsg::AlphaTestAttribute *alphaTestAttrib) | SharedTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *trafo) | SharedTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(const nvsg::AnimatedVertexAttributeSet *avas) | SharedTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *billboard) | SharedTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *blendAttrib) | SharedTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *cgfx) | SharedTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *depthAttrib) | SharedTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *light) | SharedTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *faceAttrib) | SharedTraverser | [protected, virtual]
handleFlipbookAnimation(const nvsg::FlipbookAnimation *anim) | SharedTraverser | [protected, virtual]
handleFramedIndexAnimation(const nvsg::FramedAnimation< unsigned int > *anim) | SharedTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(const nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *gnode) | SharedTraverser | [protected, virtual]
handleGroup(const nvsg::Group *group) | SharedTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
handleLightingAttribute(const nvsg::LightingAttribute *laAttrib) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | SharedTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | SharedTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *lineAttrib) | SharedTraverser | [protected, virtual]
handleLines(const nvsg::Lines *lines) | SharedTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *strips) | SharedTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *lod) | SharedTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *mapArray) | SharedTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *mapElement) | SharedTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *mapList) | SharedTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *mapMatrix) | SharedTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *material) | SharedTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *camera) | SharedTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *camera) | SharedTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *pointAttrib) | SharedTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *light) | SharedTraverser | [protected, virtual]
handlePoints(const nvsg::Points *points) | SharedTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *meshes) | SharedTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *quads) | SharedTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *strips) | SharedTraverser | [protected, virtual]
handleShape(const nvsg::Shape *shape) | SharedTraverser | [protected, virtual]
handleSkin(const nvsg::Skin *skin) | SharedTraverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *triangles) | SharedTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *light) | SharedTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *pass) | SharedTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *stateSet) | SharedTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *variant) | SharedTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *swtch) | SharedTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *texAttrib) | SharedTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | SharedTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *trafo) | SharedTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *triangles) | SharedTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *fans) | SharedTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *strips) | SharedTraverser | [protected, virtual]
handleUnlitColorAttribute(const nvsg::UnlitColorAttribute *unlitColor) | SharedTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *vas) | SharedTraverser | [protected, virtual]
handleVolumeNode(const nvsg::VolumeNode *vnode) | SharedTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
lockScene() | SharedTraverser | [protected, virtual]
lockViewState() | SharedTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | SharedTraverser | [protected]
m_lockedViewState | SharedTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SharedTraverser() | SharedTraverser |
theAllocator typedef | IAllocator |
traverseCamera(const nvsg::Camera *camera) | SharedTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(const nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
traverseLight(const nvsg::LightSource *light) | SharedTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *pset) | SharedTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | SharedTraverser | [protected, virtual]
unlockScene() | SharedTraverser | [protected, virtual]
unlockViewState() | SharedTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SharedTraverser() | SharedTraverser | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:38 2008 for NVSGSDK by NVIDIA


ShortStrippedResult Class Reference

AnalyzeResult indicating a StrippedPrimitiveSet with very short strips. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for ShortStrippedResult:

[legend]
Collaboration diagram for ShortStrippedResult:

[legend]
List of all members.

Public Attributes

unsigned int | shortStrippedCount
The number of objects with short strips.

unsigned int | shortStrippedNumber
The number of short strips in those objects.

Detailed Description

AnalyzeResult indicating a StrippedPrimitiveSet with very short strips.

Namespace: nvsg
Remarks:
All QuadStrips with strips of length up to four, and all TriFans and TriStrips with fans or strips of length up to three are reported.
See also:
AnalyzeResult, AnalyzeTraverser, QuadStrips, TriFans, TriStrips

Member Data Documentation

unsigned int shortStrippedCount

The number of objects with short strips.

unsigned int shortStrippedNumber

The number of short strips in those objects.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


Member List

ShortStrippedResult Member List

This is the complete list of members for ShortStrippedResult, including all inherited members.
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
shortStrippedCount | ShortStrippedResult |
shortStrippedNumber | ShortStrippedResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~ShortStrippedResult() (defined in ShortStrippedResult) | ShortStrippedResult | [inline, virtual]
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


SingleChildResult Class Reference

AnalyzeResult indicating a Group with a single child. More...

#include <AnalyzeTraverser.h>

Inheritance diagram for SingleChildResult:

[legend]
Collaboration diagram for SingleChildResult:

[legend]
List of all members.

Public Member Functions

virtual | ~SingleChildResult ()
Virtual Destructor.

Public Attributes

unsigned int | singleChildCount
The number of objects with a single child.

Detailed Description

AnalyzeResult indicating a Group with a single child.

Namespace: nvsg
Remarks:
All Group (and Group-derived) objects with only one child are reported with a SingleChildResult.
See also:
AnalyzeResult, AnalyzeTraverser

Constructor & Destructor Documentation

virtual ~SingleChildResult ( ) [inline, virtual]

Virtual Destructor.

Member Data Documentation

unsigned int singleChildCount

The number of objects with a single child.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


Member List

SingleChildResult Member List

This is the complete list of members for SingleChildResult, including all inherited members.
objectCode | AnalyzeResult |
objectCount | AnalyzeResult |
singleChildCount | SingleChildResult |
~AnalyzeResult() | AnalyzeResult | [inline, virtual]
~SingleChildResult() | SingleChildResult | [inline, virtual]
Generated on Tue Jan 15 10:29:26 2008 for NVSGSDK by NVIDIA


TemplateSingleton class Reference

Singleton Class Template Reference

A Singleton framework. More...

#include <Singleton.h>

Collaboration diagram for Singleton:

[legend]
List of all members.

Static Public Member Functions

T * instance ()
Single instance access.

Detailed Description

template<typename T>
class nvutil::Singleton< T >

A Singleton framework.

Ensures a class T only has one instance. Defines a global point of access to that object.

Member Function Documentation

T * instance ( ) [inline, static]

Single instance access.

Receive a pointer to the single instance.

The documentation for this class was generated from the following file:
  • Singleton.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

Singleton Member List

This is the complete list of members for Singleton, including all inherited members.
instance() Singleton [inline, static]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Skin Class Reference

Provides functionality to work with skinned vertex attribute data. More...

#include <Skin.h>

Inheritance diagram for Skin:

[legend]
Collaboration diagram for Skin:

[legend]
List of all members.

Public Types

enum | SkinningType { NVSG_SKIN_NONE, NVSG_SKIN_POINT, NVSG_SKIN_VECTOR }

Public Member Functions

NVSG_API | Skin ()
Default constructor.

NVSG_API | Skin (const Skin &rhs)
Copy constructor.

virtual NVSG_API | ~Skin ()
Destructor.

NVSG_API Skin & | operator= (const Skin &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other Skin.

NVSG_API Skin::SkinningType | getSkinningType (unsigned int attrib) const
Get the skinning type of the specified attribute.

NVSG_API void | setSkinningType (unsigned int attrib, SkinningType type)
Set the skinning type for the specified attribute.

NVSG_API void | setInfluenceData (const float *weights, const unsigned int *indices, const unsigned int *counts, unsigned int numberOfInfluences)
Set the complete set of influence data.

NVSG_API void | setInfluenceData (unsigned int pos, const float *weights, const unsigned int *indices, const unsigned int *counts, unsigned int numberOfInfluences)
Set influence data, starting at the specified position.

NVSG_API const float * | getWeights () const
Get a pointer to the weights.

NVSG_API const unsigned int * | getIndices () const
Get a pointer to the indices.

NVSG_API const unsigned int * | getCounts () const
Get a pointer to the counts.

NVSG_API const unsigned int * | getOffsets () const
Get a pointer to the offsets.

NVSG_API unsigned int | getNumberOfInfluences () const
Get the number of influence data.

NVSG_API unsigned int | getTotalNumberOfIndices () const
Get the total number of indices.

NVSG_API const nvmath::Mat44f & | getBindShapeMatrix () const
Get the bind shape matrix of this Skin.

NVSG_API void | setBindShapeMatrix (const nvmath::Mat44f &matrix)
Set the bind shape matrix of this Skin.

NVSG_API unsigned int | getNumberOfJoints () const
Get the number of Joints of this Skin.

NVSG_API unsigned int | addJoint (TransformHandle *joint, const nvmath::Mat44f &inverseBindMatrix, unsigned int position=~0)
Add a Joint to this Skin.

NVSG_API TransformHandle * | getJoint (unsigned int position) const
Get the joint at the specified position.

NVSG_API const nvmath::Mat44f & | getInverseBindMatrix (unsigned int position) const
Get the inverse bind matrix of the joint at the specified position.

NVSG_API void | removeJoint (unsigned int position)
Remove the joint at the specified position.

virtual NVSG_API bool | isCompatible (const Skin *p) const

Detailed Description

Provides functionality to work with skinned vertex attribute data.

Remarks:
A Skin can be used in conjunction with a VertexAttributeSet. In addition to the reference to a VertexAttributeSet, a PrimitiveSet might hold a reference to a Skin. That way, each PrimitiveSet object can be skinned.

The base mesh is defined in the VertexAttributeSet part.

Skin::m_weights hold a vector of weights per vertex. For each vertex, the number of elements in m_indices and m_weights have to be equal. For each VertexAttribute, the SkinningType has to be set. NVSG_SKIN_NONE (the default) means that the corresponding VertexAttribute is not changed by the skinning process. NVSG_SKIN_POINT uses the skinning matrices. NVSG_SKIN_VECTOR uses the inverse transpose of the skinning matrices and normalizes the vector at the end.

The values in m_indices index into the current set of matrices m_jointMatrices.
Note:
It might happen, that the skinned vertex data is not created as part of this Skin, but is created in a way that can be directly accessed by the rendering engine.

It might be useful, to set the NH_CULL_NEVER hint for a GeoNode holding a Skin, to prevent culling of that object, because the vertices are moved by the skinning process.

Constructor & Destructor Documentation

NVSG_API Skin ( )

Default constructor.

Remarks:
Creates an empty Skin.

NVSG_API Skin ( const Skin & rhs )

Copy constructor.

Parameters:
rhs Skin to copy from.
Remarks:
Creates a Skin by copying the data from rhs.

virtual NVSG_API ~Skin ( ) [virtual]

Destructor.

Member Function Documentation

NVSG_API Skin& operator= ( const Skin & rhs )

Assignment operator.

Parameters:
rhs Skin to assign.
Returns:
A reference to this.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other Skin.

Parameters:
p | A pointer to an Object to test for equivalence with.
ignoreNames | true, if names are to be ignored in the equivalence test, otherwise false.
deepCompare | true, if a deep compare should be done, otherwise false.
Returns:
true, if this and p are equivalent, otherwise false.
Remarks:
An Object p is considered to be equivalent to the Skin this, if it also is a Skin and has the same bind shape matrix, joints, inverse bind matrices, counts, indices, and weights.

Reimplemented from Object.

Skin::SkinningType getSkinningType ( unsigned int attrib ) const [inline]

Get the skinning type of the specified attribute.

Parameters:
attrib Specifies the vertex attribute to get the skinning type for.
Returns:
The skinning type for the specified attribute.
Remarks:
There are three possibilities how a vertex attribute should be handled by the skinning process. It should not be modified (NVSG_SKIN_NONE, the default, for texture coordinates for example), it should be handled like position information (NVSG_SKIN_POINT), or it should be handled like normal information (NVSG_SKIN_VECTOR).
See also:
setSkinningType

NVSG_API void setSkinningType | ( | unsigned int | attrib,
 |  | SkinningType | type
 | ) |

Set the skinning type for the specified attribute.

Parameters:
attrib | Specifies the vertex attribute to set the skinning type for.
type | The skinning type to set.
Remarks:
There are three possibilities how a vertex attribute should be handled by the skinning process. It should not be modified (NVSG_SKIN_NONE, the default, for texture coordinates for example), it should be handled like position information (NVSG_SKIN_POINT), or it should be handled like normal information (NVSG_SKIN_VECTOR).
See also:
getSkinningType

NVSG_API void setInfluenceData | ( | const float * | weights,
 |  | const unsigned int * | indices,
 |  | const unsigned int * | counts,
 |  | unsigned int | numberOfInfluences
 | ) |

Set the complete set of influence data.

Parameters:
weights | A pointer to the weights.
indices | A pointer to the indices.
counts | A pointer to the counts.
numberOfInfluences | The number of influences to be set.
Remarks:
The numberOfInfluences has to be equal to the number of vertices in the associated VertexAttributeSet. It is expected, that counts points to numberOfInfluences values. Each one specifies how many indices and weights are used for the corresponding vertex. Is is expected that weights and indices point to a number of values, that are equal to the sum of all the values in counts. The indices index into the array of joint matrices. The weights specify the weight to use with each of those matrices.
See also:
getWeights, getIndices, getCounts, getOffsets, getNumberOfInfluences

NVSG_API void setInfluenceData | ( | unsigned int | pos,
 |  | const float * | weights,
 |  | const unsigned int * | indices,
 |  | const unsigned int * | counts,
 |  | unsigned int | numberOfInfluences
 | ) |

Set influence data, starting at the specified position.

Parameters:
pos | Specifies the position of the first vertex to set the influence data for.
weights | A pointer to the weights.
indices | A pointer to the indices.
counts | A pointer to the counts.
numberOfInfluences | The number of influences to be set.
Remarks:
This inserts the influence data inside (or at the end of) an already defined set of influence data.
See also:
setInfluenceData, getWeights, getIndices, getCounts, getOffsets, getNumberOfInfluences

const float * getWeights ( ) const [inline]

Get a pointer to the weights.

Returns:
A pointer to the weights.
Remarks:
The weights for each vertex are concatenated to one large array.
See also:
setInfluenceData, getIndices, getCounts, getOffsets, getNumberOfInfluences

const unsigned int * getIndices ( ) const [inline]

Get a pointer to the indices.

Returns:
A pointer to the indices.
Remarks:
The indices for each vertex are concatenated to one large array.
See also:
setInfluenceData, getWeights, getCounts, getOffsets, getNumberOfInfluences

const unsigned int * getCounts ( ) const [inline]

Get a pointer to the counts.

Returns:
A pointer to the counts.
Remarks:
The array of counts specifies for each vertex how many index/weight pairs are used.
See also:
setInfluenceData, getWeights, getIndices, getOffsets, getNumberOfInfluences

const unsigned int * getOffsets ( ) const [inline]

Get a pointer to the offsets.

Returns:
A pointer to the offsets.
Remarks:
The array of offsets specifies for each vertex the offset into the weights and indices arrays, where the index/weight pairs start for that vertex.
See also:
setInfluenceData, getWeights, getIndices, getCounts, getNumberOfInfluences

unsigned int getNumberOfInfluences ( ) const [inline]

Get the number of influence data.

Returns:
The number of influence data.
Remarks:
The number of influence data should be equal to the number of vertices of the associated VertexAttributeSet.
See also:
setInfluenceData, getWeights, getIndices, getCounts, getOffsets

unsigned int getTotalNumberOfIndices ( ) const [inline]

Get the total number of indices.

Returns:
The total number of indices.
Remarks:
The total number of weights has to be equal to the total number of indices.
See also:
getCounts, getNumberOfInfluences

const nvmath::Mat44f & getBindShapeMatrix ( ) const [inline]

Get the bind shape matrix of this Skin.

Returns:
The bind shape matrix of this Skin.
Remarks:
The bind shape matrix is the transformation that moves the skin in the skeleton coordinate system. The default of this matrix is the identity.
See also:
setBindShapeMatrix

void setBindShapeMatrix ( const nvmath::Mat44f & matrix ) [inline]

Set the bind shape matrix of this Skin.

Parameters:
matrix The bind shape matrix of this Skin.
Remarks:
The bind shape matrix is the transformation that moves the skin in the skeleton coordinate system. The default of this matrix is the identity.
See also:
getBindShapeMatrix

unsigned int getNumberOfJoints ( ) const [inline]

Get the number of Joints of this Skin.

Returns:
The number of Joints of this Skin.
See also:
addJoint, getJoint, getInverseBindMatrix, removeJoint

NVSG_API unsigned int addJoint | ( | TransformHandle * | joint,
 |  | const nvmath::Mat44f & | inverseBindMatrix,
 |  | unsigned int | position = ~0
 | ) |

Add a Joint to this Skin.

Parameters:
joint | A pointer to the TransformHandle to use as a Joint.
inverseBindMatrix | The transformation that is applied to a vertex to express it in the joint coordinate system.
position | Optional position where to place the new Joint.
Returns:
The function returns the zero-based position where the Joint has been added.
Remarks:
The reference count and the joint marker of joint is increased.

When omitting the position parameter, the joint will be added at the end. If position specifies a position greater than or equal to the actual number of joints, the new joint will be added to the end. Otherwise the joint will be inserted at that position forcing all subsequent joints to move up in the list of joints.
See also:
getNumberOfJoints, getJoint, getInverseBindMatrix, removeJoint

TransformHandle * getJoint ( unsigned int position ) const [inline]

Get the joint at the specified position.

Parameters:
position Zero-based position of the joint to get.
Returns:
The function returns a pointer to the TransformHandle at the specified position.
Remarks:
The behavior of this function is undefined, if position is greater than or equal to the number of joints of this Skin.
See also:
getNumberOfJoints, addJoint, getInverseBindMatrix, removeJoint

const nvmath::Mat44f & getInverseBindMatrix ( unsigned int position ) const [inline]

Get the inverse bind matrix of the joint at the specified position.

Parameters:
position Zero-based position of the inverse bind matrix to get.
Returns:
The function returns a constant reference to the inverse bind matrix at the specified position.
Remarks:
The behavior of this function is undefined, if position is greater than or equal to the number of joints of this Skin.
See also:
getNumberOfJoints, addJoint, getJoint, removeJoint

NVSG_API void removeJoint ( unsigned int position )

Remove the joint at the specified position.

Parameters:
position Zero-based position of the joint to remove.
Remarks:
When position is greater than or equal to the number of joints of this Skin, the last joint is removed. Otherwise the joint at the specified position is removed, forcing all subsequent joints to move one down in the list of joints.

When removing a joint, the joint marker and the reference count of the corresponding Transform is decreased.
See also:
getNumberOfJoints, addJoint, getJoint, getInverseBindMatrix

The documentation for this class was generated from the following file:
  • Skin.h
Generated on Tue Jan 15 10:29:16 2008 for NVSGSDK by NVIDIA


Member List

Skin Member List

This is the complete list of members for Skin, including all inherited members.
addJoint(TransformHandle *joint, const nvmath::Mat44f &inverseBindMatrix, unsigned int position=~0) | Skin |
addOwner(typename PrimitiveSetHandle::ObjectType *obj) | OwnedObject< PrimitiveSetHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< PrimitiveSetHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBindShapeMatrix() const | Skin | [inline]
getCounts() const | Skin | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIndices() const | Skin | [inline]
getInverseBindMatrix(unsigned int position) const | Skin | [inline]
getJoint(unsigned int position) const | Skin | [inline]
getName() const | Object |
getNumberOfInfluences() const | Skin | [inline]
getNumberOfJoints() const | Skin | [inline]
getNumberOfOwners() const | OwnedObject< PrimitiveSetHandle > |
getObjectCode() const | Object | [inline]
getOffsets() const | Skin | [inline]
getOwner(unsigned int index) const | OwnedObject< PrimitiveSetHandle > |
getSkinningType(unsigned int attrib) const | Skin | [inline]
getTotalNumberOfIndices() const | Skin | [inline]
getUserData() const | Object | [inline]
getWeights() const | Skin | [inline]
invalidateIncarnation() | OwnedObject< PrimitiveSetHandle > | [virtual]
isCompatible(const Skin *p) const (defined in Skin) | Skin | [virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Skin | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
NVSG_SKIN_NONE enum value (defined in Skin) | Skin |
NVSG_SKIN_POINT enum value (defined in Skin) | Skin |
NVSG_SKIN_VECTOR enum value (defined in Skin) | Skin |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Skin &rhs) | Skin |
nvsg::OwnedObject< PrimitiveSetHandle >::operator=(const OwnedObject< PrimitiveSetHandle > &rhs) | OwnedObject< PrimitiveSetHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< PrimitiveSetHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< PrimitiveSetHandle > | [protected]
OwnedObject(const OwnedObject< PrimitiveSetHandle > &rhs) | OwnedObject< PrimitiveSetHandle > | [protected]
OwnerIterator typedef | OwnedObject< PrimitiveSetHandle > | [protected]
ownersBegin() const | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersBegin() | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersEnd() const | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersEnd() | OwnedObject< PrimitiveSetHandle > | [inline, protected]
removeJoint(unsigned int position) | Skin |
removeOwner(typename PrimitiveSetHandle::ObjectType *obj) | OwnedObject< PrimitiveSetHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setBindShapeMatrix(const nvmath::Mat44f &matrix) | Skin | [inline]
setInfluenceData(const float *weights, const unsigned int *indices, const unsigned int *counts, unsigned int numberOfInfluences) | Skin |
setInfluenceData(unsigned int pos, const float *weights, const unsigned int *indices, const unsigned int *counts, unsigned int numberOfInfluences) | Skin |
setName(const std::string &name) | Object |
setSkinningType(unsigned int attrib, SkinningType type) | Skin |
setUserData(const void *userData) | Object | [inline]
Skin() | Skin |
Skin(const Skin &rhs) | Skin |
SkinningType enum name (defined in Skin) | Skin |
validateIncarnation() const | Object | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< PrimitiveSetHandle > | [protected]
~Skin() | Skin | [virtual]
Generated on Tue Jan 15 10:29:16 2008 for NVSGSDK by NVIDIA


skin_t Struct Reference

The skin_t structure specifies how a skin is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t numBones
Specifies the number of bones describing the actual skin.

uint_t bones
float3_t vertex
Specifies the initial vertex for the actual skin.

float3_t normal
Specifies the initial normal for the actual skin.

Detailed Description

The skin_t structure specifies how a skin is stored in a .NBF file.

Skins need to be considered in conjunction with NBFSkinnedTriangles objects.

Member Data Documentation

uint_t numBones

Specifies the number of bones describing the actual skin.

uint_t bones

Specifies the file offset to the bones describing the actual skin. < The way bones are stored in a .NBF file is specified by the bone_t structure.

float3_t vertex

Specifies the initial vertex for the actual skin.

float3_t normal

Specifies the initial normal for the actual skin.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

skin_t Member List

This is the complete list of members for skin_t, including all inherited members.
bones | skin_t
normal | skin_t
numBones | skin_t
vertex | skin_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


SkinnedTriangles Class Reference

Class representing a skinned Triangles. More...

#include <SkinnedTriangles.h>

Inheritance diagram for SkinnedTriangles:

[legend]
Collaboration diagram for SkinnedTriangles:

[legend]
List of all members.

Public Member Functions

NVSG_API | SkinnedTriangles ()
Default-constructs a SkinnedTriangles.

NVSG_API | SkinnedTriangles (const Triangles &rhs)
Constructs a SkinnedTriangles from a Triangles.

NVSG_API | SkinnedTriangles (const SkinnedTriangles &rhs)
Constructs a SkinnedTriangles as a copy from anothe SkinnedTriangles.

virtual NVSG_API | ~SkinnedTriangles ()
Destructs a SkinnedTriangles.

virtual NVSG_API bool | isDataShared () const
Query if the data of this SkinnedTriangles is shared.

virtual NVSG_API DataID | getDataID () const
Get the DataID, which uniquely identifies the sharable object data.

NVSG_API void | setAnimationFrame (unsigned int frame, bool calculateTangentSpace)
Set the current frame.

NVSG_API unsigned int | getNumberOfSkins () const
Get the number of skins.

NVSG_API const Skin * | getSkins () const
Get a pointer to the constant Skin.

NVSG_API void | setSkins (const SkinnedTriangles::Skin *skins, unsigned int numSkins)
Set the skins.

NVSG_API void | setSkins (unsigned int pos, const SkinnedTriangles::Skin *skins, unsigned int numSkins)
Set a subset of skins of this SkinnedTriangles.

NVSG_API SkinnedTriangles & | operator= (const SkinnedTriangles &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another SkinnedTriangles.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

virtual NVSG_API bool | containsAnimation () const
Interface to determine if an Object contains an animation.

NVSG_API void | evaluateAnimation ()
Evaluate the Animation.

Detailed Description

Class representing a skinned Triangles.

Namespace: nvsg
Remarks:
This class has additional information for calculating the vertices and normals of a Triangles (based on the animation step) from a "Skin" on every vertex.
See also:
Bone, Skin, Triangles

Constructor & Destructor Documentation

NVSG_API SkinnedTriangles ( )

Default-constructs a SkinnedTriangles.

NVSG_API SkinnedTriangles ( const Triangles & rhs )

Constructs a SkinnedTriangles from a Triangles.

NVSG_API SkinnedTriangles ( const SkinnedTriangles & rhs )

Constructs a SkinnedTriangles as a copy from anothe SkinnedTriangles.

virtual NVSG_API ~SkinnedTriangles ( ) [virtual]

Destructs a SkinnedTriangles.

Member Function Documentation

virtual NVSG_API bool isDataShared ( ) const [virtual]

Query if the data of this SkinnedTriangles is shared.

Returns:
true if the data is shared, otherwise false.
See also:
getDataID

Reimplemented from IndependentPrimitiveSet.

virtual NVSG_API DataID getDataID ( ) const [virtual]

Get the DataID, which uniquely identifies the sharable object data.

Returns:
The unique DataID, that identifies the object data.
See also:
isDataShared

Reimplemented from IndependentPrimitiveSet.

NVSG_API void setAnimationFrame | ( | unsigned int | frame,
 |  | bool | calculateTangentSpace
 | ) |

Set the current frame.

Parameters:
frame | The index of the frame to set as current.
calculateTangentSpace | if true, tangents and binormals are recalculated
Remarks:
SkinnedTriangles contain animation information on each vertex. When the animation frame is set, the vertices and normals are recalculated.
Note:
The behavior is undefined if frame is larger than or equal to the number of frames of the Animation objects of this SkinnedTriangles.
See also:
Animation, Bone, Skin

unsigned int getNumberOfSkins ( ) const [inline]

Get the number of skins.

Returns:
The number of skins.
Remarks:
In addition to vertices, normals, and so on, a SkinnedTriangles contains so-called "Skins". A Skin is the information from which one vertex and its normal can be calculated, depending on the animation frame.
See also:
Skin

const SkinnedTriangles::Skin * getSkins ( ) const [inline]

Get a pointer to the constant Skin.

Returns:
A pointer to the constant Skin.
See also:
Skin

NVSG_API void setSkins | ( | const SkinnedTriangles::Skin * | skins,
 |  | unsigned int | numSkins
 | ) |

Set the skins.

Parameters:
skins | A pointer to the constant skins to use.
numSkins | The number of skins.
Remarks:
A Skin contains information for calculating a vertex and a normal for each animation step.
Note:
The behavior is undefined if there are less than numSkins value of type Skin located at skins.
See also:
Bone, Skin

NVSG_API void setSkins | ( | unsigned int | pos,
 |  | const SkinnedTriangles::Skin * | skins,
 |  | unsigned int | numSkins
 | ) |

Set a subset of skins of this SkinnedTriangles.

Parameters:
pos | The start position inside the range of pre-existing skins.
skins | A pointer to the constant skins to use.
numSkins | The number of skins.
Remarks:
Copies numSkins values of type Skin from skins into this SkinnedTriangles, starting at position pos inside the range of pre-existing skins.
Pre-existing skins in the range [pos, pos + numSkins) will be replaced. Pre-existing skins outside this range remain untouched.
If you specify (-1) for pos or pos specifies the number of skins currently stored, the skins pointed to by skins will be appended to the pre-existing skins.
Note:
The behavior is undefined if pos is neither a valid position inside the range of pre-existing skins, nor the number of skins currently stored, nor (-1).

The behavior is undefined if there are less than numSkins values of type Skin located at skins.

See also:
hasFaces, getNumberOfFaces, getFaces

NVSG_API SkinnedTriangles& operator= ( const SkinnedTriangles & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant SkinnedTriangles to copy from.
Returns:
A reference to the assigned SkinnedTriangles.
Remarks:
The assignment operator calls the assignment operator of Triangles and copies the skins.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another SkinnedTriangles.

Parameters:
p | Pointer to the constant SkinnedTriangles to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the SkinnedTriangles p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Triangles, they are considered to be equivalent, if their skins are pair-wise equal.
Note:
The behavior is undefined if p is not a SkinnedTriangles nor derived from one.
See also:
Object, Skin, Triangles

Reimplemented from IndependentPrimitiveSet.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and it is marked as invalid. Then it is validated and the Incarnation of each Animation of each Bone of each Skin is requested to continue validation down the tree hierarchy. Bone, Incarnation, Skin

Reimplemented from PrimitiveSet.

virtual NVSG_API bool containsAnimation ( ) const [virtual]

Interface to determine if an Object contains an animation.

Returns:
true if the VertexAttributeSet of this PrimitiveSet contains an animation, otherwise false.

Reimplemented from PrimitiveSet.

NVSG_API void evaluateAnimation ( )

Evaluate the Animation.

Remarks:
The current animation state is used to update the Transform part of the skins. This is called by the AppTraverser.

The documentation for this class was generated from the following file:
  • SkinnedTriangles.h
Generated on Tue Jan 15 10:29:16 2008 for NVSGSDK by NVIDIA


Member List

SkinnedTriangles Member List

This is the complete list of members for SkinnedTriangles, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | IndependentPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
calculateTangentSpace(Triangles *t, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2) | Triangles | [related]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | SkinnedTriangles | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
evaluateAnimation() | SkinnedTriangles |
generateNormals(Triangles *t) | Triangles | [related]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | SkinnedTriangles | [virtual]
getFaces() const | Triangles | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getName() const | Object |
getNumberOfFaces() const | Triangles | [inline]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfSkins() const | SkinnedTriangles | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getSkins() const | SkinnedTriangles | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasFaces() const | Triangles | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | SkinnedTriangles | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | SkinnedTriangles | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const SkinnedTriangles &rhs) | SkinnedTriangles |
nvsg::Triangles::operator=(const Triangles &rhs) | Triangles |
nvsg::IndependentPrimitiveSet::operator=(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnimationFrame(unsigned int frame, bool calculateTangentSpace) | SkinnedTriangles |
setAnnotation(const std::string &anno) | Object |
setFaces(const Face3 *faces, unsigned int numFaces) | Triangles | [inline]
setFaces(unsigned int pos, const Face3 *faces, unsigned int numFaces) | Triangles | [inline]
setIndices(const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setIndices(unsigned int pos, const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setSkins(const SkinnedTriangles::Skin *skins, unsigned int numSkins) | SkinnedTriangles |
setSkins(unsigned int pos, const SkinnedTriangles::Skin *skins, unsigned int numSkins) | SkinnedTriangles |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
SkinnedTriangles() | SkinnedTriangles |
SkinnedTriangles(const Triangles &rhs) | SkinnedTriangles |
SkinnedTriangles(const SkinnedTriangles &rhs) | SkinnedTriangles |
Triangles() | Triangles |
Triangles(const IndependentPrimitiveSet &rhs) | Triangles |
Triangles(const PrimitiveSet &rhs) | Triangles |
Triangles(const Triangles &rhs) | Triangles |
validateIncarnation() const | SkinnedTriangles | [virtual]
~Drawable(void) | Drawable | [virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~SkinnedTriangles() | SkinnedTriangles | [virtual]
~Triangles() | Triangles | [virtual]
Generated on Tue Jan 15 10:29:16 2008 for NVSGSDK by NVIDIA


SkinnedTriangles::Skin Struct Reference

Internal helper class for SkinnedTriangles. More...

#include <SkinnedTriangles.h>

Collaboration diagram for SkinnedTriangles::Skin:

[legend]
List of all members.

Public Attributes

std::vector< Bone > m_bones
vector of "Bones" from which a vertex and a normal is calculated

nvmath::Vec3f m_normal
current normal, calculated from the vector of "Bones"

nvmath::Vec3f m_vertex
current vertex, calculated from the vector of "Bones"

Detailed Description

Internal helper class for SkinnedTriangles.

Namespace: nvsg
Remarks:
Instead of the vertices and normals from Triangles, SkinnedTriangles use a special construction that has a vector of "Bones" per vertex, from which the vertices and normals are calculated. This calculation depends on the animation step.
The vertex and the normal of a Skin are starting values, that are calculated out of the first animation step of each bone, together with their offset and weight. These values are used as starting values on the following animation steps.
See also:
Bone

Member Data Documentation

std::vector<Bone> m_bones

vector of "Bones" from which a vertex and a normal is calculated

nvmath::Vec3f m_normal

current normal, calculated from the vector of "Bones"

nvmath::Vec3f m_vertex

current vertex, calculated from the vector of "Bones"

The documentation for this struct was generated from the following file:
  • SkinnedTriangles.h
Generated on Tue Jan 15 10:29:17 2008 for NVSGSDK by NVIDIA


Member List

SkinnedTriangles::Skin Member List

This is the complete list of members for SkinnedTriangles::Skin, including all inherited members.
m_bones | SkinnedTriangles::Skin
m_normal | SkinnedTriangles::Skin
m_vertex | SkinnedTriangles::Skin
Generated on Tue Jan 15 10:29:17 2008 for NVSGSDK by NVIDIA


SmoothTraverser Class Reference

Traverser that can smooth some drawables. More...

#include <SmoothTraverser.h>

Inheritance diagram for SmoothTraverser:

[legend]
Collaboration diagram for SmoothTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | SmoothTraverser (void)
Constructor.

NVSG_API void | setCreaseAngle (float creaseAngle)
Set the crease angle for smoothing.

Protected Member Functions

virtual NVSG_API | ~SmoothTraverser (void)
Protected destructor to prevent instantiation of a SmoothTraverser.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
doApply override

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *p)
Handle a GeoNode object.

virtual NVSG_API void | handleQuads (nvsg::Quads *p)
Handle a Quads object.

virtual NVSG_API void | handleTriangles (nvsg::Triangles *p)
Handle a Triangles object.

virtual NVSG_API void | handleQuadStrips (nvsg::QuadStrips *p)
Handle a QuadStrips object.

virtual NVSG_API void | handleTriFans (nvsg::TriFans *p)
Handle a TriFans object.

virtual NVSG_API void | handleTriStrips (nvsg::TriStrips *p)
Handle a TriStrips object.

Detailed Description

Traverser that can smooth some drawables.

Currently, this SmoothTraverser supports Triangles only. If these Triangles are non-trivially indexed, they are changed to be trivially indexed.

Constructor & Destructor Documentation

NVSG_API SmoothTraverser ( void )

Constructor.

virtual NVSG_API ~SmoothTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a SmoothTraverser.

Member Function Documentation

NVSG_API void setCreaseAngle ( float creaseAngle )

Set the crease angle for smoothing.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

doApply override

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * p ) [protected, virtual]

Handle a GeoNode object.

The GeoNode is the primary object to smooth.

Parameters:
p GeoNode to handle

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuads ( nvsg::Quads * p ) [protected, virtual]

Handle a Quads object.

Parameters:
p Quads to handle

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriangles ( nvsg::Triangles * p ) [protected, virtual]

Handle a Triangles object.

Parameters:
p Triangles to handle

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadStrips ( nvsg::QuadStrips * p ) [protected, virtual]

Handle a QuadStrips object.

Just assert here; shouldn't happen at all!

Parameters:
p QuadStrips to handle

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriFans ( nvsg::TriFans * p ) [protected, virtual]

Handle a TriFans object.

Just assert here; shouldn't happen at all!

Parameters:
p TriFans to handle

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriStrips ( nvsg::TriStrips * p ) [protected, virtual]

Handle a TriStrips object.

Just assert here; shouldn't happen at all!

Parameters:
p TriStrips to handle

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • SmoothTraverser.h
Generated on Tue Jan 15 10:29:37 2008 for NVSGSDK by NVIDIA


Member List

SmoothTraverser Member List

This is the complete list of members for SmoothTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | SmoothTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *p) | SmoothTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *p) | SmoothTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *p) | SmoothTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *p) | SmoothTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *p) | SmoothTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *p) | SmoothTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setCreaseAngle(float creaseAngle) | SmoothTraverser |
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
SmoothTraverser(void) | SmoothTraverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SmoothTraverser(void) | SmoothTraverser | [protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:37 2008 for NVSGSDK by NVIDIA


TemplateSpherent class Reference

Spherent Class Template Reference

Sphere class. More...

#include <Spherent.h>

Collaboration diagram for Spherent:

[legend]
List of all members.

Public Member Functions

Spherent ()
Default constructor.

Spherent (const Vecnt< n, T > &center, T radius)
Constructor by center and radius.

const Vecnt< n, T > & | getCenter () const
Get the center of the sphere.

T | getRadius () const
Get the radius of the sphere.

void | invalidate ()
Invalidate the sphere by setting the radius to a negative value.

T | operator() (const Vecnt< n, T > &p) const
Function call operator.

void | setCenter (const Vecnt< n, T > &center)
Set the center of the sphere.

void | setRadius (T radius)
Set the radius of the sphere.

Detailed Description

template<unsigned int n, typename T>
class nvmath::Spherent< n, T >

Sphere class.

Remarks:
This is a sphere in n-space, determined by a center point and a radius. A sphere is often used as a bounding sphere around some data, so there is a variety of routines to calculate the bounding sphere.

Constructor & Destructor Documentation

Spherent ( ) [inline]

Default constructor.

Remarks:
The default sphere is initialized to be invalid. A sphere is considered to be invalid, if the radius is negative.

Spherent | ( | const Vecnt< n, T > & | center,
 |  | T | radius
 | ) | [inline]

Constructor by center and radius.

Parameters:
center | The center of the sphere.
radius | The radius of the sphere.

Member Function Documentation

const Vecnt< n, T > & getCenter ( ) const [inline]

Get the center of the sphere.

Returns:
The center of the sphere.
See also:
setCenter, getRadius

T getRadius ( ) const [inline]

Get the radius of the sphere.

Returns:
The radius of the sphere.
Remarks:
A sphere is considered to be invalid if the radius is negative.
See also:
setRadius, getCenter, invalidate

void invalidate ( ) [inline]

Invalidate the sphere by setting the radius to a negative value.

Remarks:
A sphere is considered to be invalid if the radius is negative.
See also:
getRadius, setRadius

T operator() ( const Vecnt< n, T > & p ) const [inline]

Function call operator.

Parameters:
p A reference to a constant point.
Returns:
The signed distance of the point p from the sphere.
Remarks:
The distance is negative when p is inside the sphere, and it is positive if p is outside the sphere.

void setCenter ( const Vecnt< n, T > & center ) [inline]

Set the center of the sphere.

Parameters:
center A reference to the constant center point.
See also:
getCenter, setRadius

void setRadius ( T radius ) [inline]

Set the radius of the sphere.

Parameters:
radius The radius of the sphere.
See also:
getRadius, setRadius, invalidate

The documentation for this class was generated from the following file:
  • Spherent.h
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


Member List

Spherent Member List

This is the complete list of members for Spherent, including all inherited members.
getCenter() const | Spherent | [inline]
getRadius() const | Spherent | [inline]
invalidate() | Spherent | [inline]
operator()(const Vecnt< n, T > &p) const | Spherent | [inline]
setCenter(const Vecnt< n, T > &center) | Spherent | [inline]
setRadius(T radius) | Spherent | [inline]
Spherent() | Spherent | [inline]
Spherent(const Vecnt< n, T > &center, T radius) | Spherent | [inline]
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


SpotLight Class Reference

LightSource representing a spot light. More...

#include <SpotLight.h>

Inheritance diagram for SpotLight:

[legend]
Collaboration diagram for SpotLight:

[legend]
List of all members.

Public Member Functions

NVSG_API | SpotLight ()
Default-constructs a SpotLight.

NVSG_API | SpotLight (const LightSource &rhs)
Constructs a SpotLight from a LightSource.

NVSG_API | SpotLight (const SpotLight &rhs)
Constructs a SpotLight as a copy of another SpotLight.

virtual NVSG_API | ~SpotLight ()
Destructs a SpotLight.

NVSG_API const nvmath::Vec3f & | getPosition () const
Get the position.

NVSG_API void | setPosition (const nvmath::Vec3f &position)
Set the position.

NVSG_API nvmath::Vec3f | getDirection () const
Get the direction.

NVSG_API void | setDirection (const nvmath::Vec3f &direction)
Set the direction.

NVSG_API const nvmath::Quatf & | getOrientation () const
Get the orientation.

NVSG_API void | setOrientation (const nvmath::Quatf &orientation)
Set the orientation.

NVSG_API bool | isAttenuated () const
Query if this SpotLight is attenuated.

NVSG_API void | getAttenuation (float &c, float &l, float &q) const
Get the attenuation factors.

NVSG_API const nvmath::Vec3f & | getAttenuation () const
Get the attenuation factors as a nvmath::Vec3f.

NVSG_API void | setAttenuation (float c, float l, float q)
Set the attenuation factors.

NVSG_API void | setAttenuation (const nvmath::Vec3f &attenuation)
Set the attenuation factors by a nvmath::Vec3f.

NVSG_API float | getCutoffAngle () const
Get the cut-off angle.

NVSG_API void | setCutoffAngle (float ca)
Set the cut-off angle.

NVSG_API float | getFalloffExponent () const
Get the fall-off exponent.

NVSG_API void | setFalloffExponent (float fe)
Set the fall-off exponent.

NVSG_API SpotLight & | operator= (const SpotLight &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other SpotLight.

Detailed Description

LightSource representing a spot light.

Namespace: nvsg
Remarks:
A SpotLight restricts the shape of the emitted light to a cone. To specify the angle between the axis of the cone and a ray along the edge of the cone, use setCutoffAngle() with the angle in radians. The angle of the cone at the apex is then twice this value. No light is emitted beyond the edges of the cone.
In addition, there are two ways to control the intensity distribution of the light within the cone. First, you can set the attenuation factors with setAttenuation(). You can also set a falloff exponent using setFalloffExponent(), which by default is zero, to control how concentrated the light is. The light's intensity is highest in the center of the cone. It is attenuated toward the edges of the cone by the cosine of the angle between the direction of the light and the direction from the light to the vertex being lit, raised to the power of the falloff exponent. Thus, higher falloff exponents result in a more focused light source.
The default for a SpotLight are as follows:
  • attenuation is off (constant = 1.0, linear = 0.0, quadratic = 0.0)
  • cut-off angle is 45°
  • direction is the negative z-axis (0.0,0.0,-1.0)
  • fall-off exponent is no fall-off (0.0)
  • position is the origin (0.0,0.0,0.0)
See also:
LightSource, DirectedLight, PointLight

Constructor & Destructor Documentation

NVSG_API SpotLight ( )

Default-constructs a SpotLight.

NVSG_API SpotLight ( const LightSource & rhs )

Constructs a SpotLight from a LightSource.

Parameters:
rhs LightSource to construct the SpotLight from.
Remarks:
This is kind of a partial copy constructor only copying the LightSource part from the source object.

NVSG_API SpotLight ( const SpotLight & rhs )

Constructs a SpotLight as a copy of another SpotLight.

virtual NVSG_API ~SpotLight ( ) [virtual]

Destructs a SpotLight.

Member Function Documentation

const nvmath::Vec3f & getPosition ( ) const [inline]

Get the position.

Returns:
A reference to the constant position of the SpotLight.
Remarks:
The default position is the origin (0.0,0.0,0.0).
See also:
getDirection, getOrientation, setPosition

NVSG_API void setPosition ( const nvmath::Vec3f & position )

Set the position.

Parameters:
position A reference to the constant position to set.
Remarks:
The default position is the origin (0.0,0.0,0.0).
See also:
getPosition, setDirection, setOrientation

nvmath::Vec3f getDirection ( ) const [inline]

Get the direction.

Returns:
A reference to the constant direction of the SpotLight.
Remarks:
The default direction is the negative z-axis (0.0,0.0,-1.0)
See also:
getPosition, setDirection, setOrientation

NVSG_API void setDirection ( const nvmath::Vec3f & direction )

Set the direction.

Parameters:
direction A reference to the constant direction to set.
Remarks:
The default direction is the negative z-axis (0.0,0.0,-1.0)
Note:
The direction is expected to be normalized.
See also:
getDirection, setOrientation, setPosition

const nvmath::Quatf & getOrientation ( ) const [inline]

Get the orientation.

Returns:
A reference to the constant orientation of the SpotLight.
Remarks:
The default direction is the negative z-axis (0.0,0.0,-1.0), thus the default orientation is (0.0,0.0,0.0,1.0).
See also:
getPosition, getDirection, setOrientation

NVSG_API void setOrientation ( const nvmath::Quatf & orientation )

Set the orientation.

Parameters:
orientation A reference to the constant orientation to set.
Remarks:
The default direction is the negative z-axis (0.0,0.0,-1.0), thus the default orientation is (0.0,0.0,0.0,1.0).
See also:
getOrientation, setDirection, setPosition

bool isAttenuated ( ) const [inline]

Query if this SpotLight is attenuated.

Returns:
true if this light source is attenuated, otherwise false
Remarks:
A SpotLight is attenuated if the constant attenuation factor is different from one, or if the linear or quadratic attenuation factor is different from zero.
By default, attenuation is off.
See also:
getAttenuation, setAttenuation

void getAttenuation | ( | float & | c,
 |  | float & | l,
 |  | float & | q
 | ) | const [inline]

Get the attenuation factors.

Parameters:
c | A reference to a float to get the constant attenuation factor.
l | A reference to a float to get the linear attenuation factor.
q | A reference to a float to get the quadratic attenuation factor.
Remarks:
The attenuation factors are used to calculate the attenuation of this light at a lit point by the equation
 atten = 1 / ( c + l * d + q * d * d )
where d is the distance between the light and the vertex.
By default, attenuation is off.
See also:
isAttenuated, setAttenuation

const nvmath::Vec3f & getAttenuation ( ) const [inline]

Get the attenuation factors as a nvmath::Vec3f.

Returns:
A reference to the constant nvmath::Vec3f with the attenuation factors.
Remarks:
The attenuation factors are used to calculate the attenuation of this light at a lit point by the equation
 atten = 1 / ( v[0] + v[1] * d + v[2] * d * d )
where v is the returned nvmath::Vec3f, and d is the distance between the light and the vertex.
By default, attenuation is off.
See also:
isAttenuated, setAttenuation

void setAttenuation | ( | float | c,
 |  | float | l,
 |  | float | q
 | ) | [inline]

Set the attenuation factors.

Parameters:
c | The constant attenuation factor.
l | The linear attenuation factor.
q | The quadratic attenuation factor.
Remarks:
The attenuation factors are used to calculate the attenuation of this light at a lit point by the equation
 atten = 1 / ( c + l * d + q * d * d )
where d is the distance between the light and the vertex.
By default, attenuation is off.
See also:
isAttenuated, getAttenuation

void setAttenuation ( const nvmath::Vec3f & attenuation ) [inline]

Set the attenuation factors by a nvmath::Vec3f.

Parameters:
attenuation A reference to the constant attenuation factors.
Remarks:
The attenuation factors are used to calculate the attenuation of this light at a lit point by the equation
 atten = 1 / ( v[0] + v[1] * d + v[2] * d * d )
where v is the returned nvmath::Vec3f, and d is the distance between the light and the vertex.
By default, attenuation is off.
See also:
isAttenuated, getAttenuation

float getCutoffAngle ( ) const [inline]

Get the cut-off angle.

Returns:
The cut-off angle in degrees.
Remarks:
The light's cone is cut off at this angle (in radian). Points beyond this cone are not lit. The default is pi/4 (or 45°).
See also:
setCutoffAngle

void setCutoffAngle ( float ca ) [inline]

Set the cut-off angle.

Parameters:
ca The cut-off angle in degrees.
Remarks:
The light's cone is cut off at this angle (in radian). Points beyond this cone are not lit. The default is pi/4 (or 45°).
See also:
getCutoffAngle

float getFalloffExponent ( ) const [inline]

Get the fall-off exponent.

Returns:
The fall-off exponent.
Remarks:
The falloff exponent controls the sharpness of the spot light. The higher the exponent, the more focused the light source. The default is 0.0
See also:
setFalloffExponent

void setFalloffExponent ( float fe ) [inline]

Set the fall-off exponent.

Parameters:
fe The fall-off exponent.
Remarks:
The falloff exponent controls the sharpness of the spot light. The higher the exponent, the more focused the light source. The default is 0.0
See also:
getFalloffExponent

NVSG_API SpotLight& operator= ( const SpotLight & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant SpotLight to copy from
Returns:
A reference to the assigned SpotLight
Remarks:
The assignment operator calls the assignment operator of LightSource, and copies the attenuation factors, the cut-off angle and the fall-off exponent.
See also:
LightSource

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other SpotLight.

Parameters:
p | A pointer to the SpotLight to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the SpotLight p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as LightSource, they are equivalent, if the attenuation factors, the cut-off angle, and the fall-off exponent are equal.
Note:
The behaviour is undefined if p is not a SpotLight or derived from one.
See also:
DirectedLight, LightSource, PointLight

Reimplemented from LightSource.

The documentation for this class was generated from the following file:
  • SpotLight.h
Generated on Tue Jan 15 10:29:17 2008 for NVSGSDK by NVIDIA


Member List

SpotLight Member List

This is the complete list of members for SpotLight, including all inherited members.
addOwner(typename GroupHandle::ObjectType *obj) | OwnedObject< GroupHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< GroupHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAmbientColor() const | LightSource | [inline]
getAnimation() const | LightSource | [inline]
getAnnotation() const | Object |
getAttenuation(float &c, float &l, float &q) const | SpotLight | [inline]
getAttenuation() const | SpotLight | [inline]
getCutoffAngle() const | SpotLight | [inline]
getDataID() const | Object | [virtual]
getDiffuseColor() const | LightSource | [inline]
getDirection() const | SpotLight | [inline]
getFalloffExponent() const | SpotLight | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIntensity() const | LightSource | [inline]
getInverse() const | LightSource | [inline]
getName() const | Object |
getNumberOfOwners() const | OwnedObject< GroupHandle > |
getObjectCode() const | Object | [inline]
getOrientation() const | SpotLight | [inline]
getOwner(unsigned int index) const | OwnedObject< GroupHandle > |
getPosition() const | SpotLight | [inline]
getSpecularColor() const | LightSource | [inline]
getTransformationMatrix() const | LightSource | [inline]
getUserData() const | Object | [inline]
invalidateAnimationContainment() | LightSource |
invalidateIncarnation() | OwnedObject< GroupHandle > | [virtual]
isAttenuated() const | SpotLight | [inline]
isDataShared() const | Object | [virtual]
isEnabled() const | LightSource | [inline]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | SpotLight | [virtual]
isShadowCasting() const | LightSource | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
LightSource() | LightSource | [protected]
LightSource(const LightSource &rhs) | LightSource | [protected]
m_objectCode | Object | [protected]
m_trafo | LightSource | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const SpotLight &rhs) | SpotLight |
nvsg::LightSource::operator=(const LightSource &rhs) | LightSource | [protected]
nvsg::OwnedObject< GroupHandle >::operator=(const OwnedObject< GroupHandle > &rhs) | OwnedObject< GroupHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< GroupHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< GroupHandle > | [protected]
OwnedObject(const OwnedObject< GroupHandle > &rhs) | OwnedObject< GroupHandle > | [protected]
OwnerIterator typedef | OwnedObject< GroupHandle > | [protected]
ownersBegin() const | OwnedObject< GroupHandle > | [inline, protected]
ownersBegin() | OwnedObject< GroupHandle > | [inline, protected]
ownersEnd() const | OwnedObject< GroupHandle > | [inline, protected]
ownersEnd() | OwnedObject< GroupHandle > | [inline, protected]
removeOwner(typename GroupHandle::ObjectType *obj) | OwnedObject< GroupHandle > | [protected]
setAmbientColor(const nvmath::Vec3f &color) | LightSource | [inline]
setAnimation(TrafoAnimationHandle *animation) | LightSource |
setAnnotation(const std::string &anno) | Object |
setAttenuation(float c, float l, float q) | SpotLight | [inline]
setAttenuation(const nvmath::Vec3f &attenuation) | SpotLight | [inline]
setCutoffAngle(float ca) | SpotLight | [inline]
setDiffuseColor(const nvmath::Vec3f &color) | LightSource | [inline]
setDirection(const nvmath::Vec3f &direction) | SpotLight |
setEnabled(bool enable) | LightSource | [inline]
setFalloffExponent(float fe) | SpotLight | [inline]
setIntensity(float intensity) | LightSource | [inline]
setName(const std::string &name) | Object |
setOrientation(const nvmath::Quatf &orientation) | SpotLight |
setPosition(const nvmath::Vec3f &position) | SpotLight |
setShadowCasting(bool cast) | LightSource | [inline]
setSpecularColor(const nvmath::Vec3f &color) | LightSource | [inline]
setUserData(const void *userData) | Object | [inline]
SpotLight() | SpotLight |
SpotLight(const LightSource &rhs) | SpotLight |
SpotLight(const SpotLight &rhs) | SpotLight |
validateIncarnation() const | LightSource | [virtual]
~LightSource() | LightSource | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< GroupHandle > | [protected]
~SpotLight() | SpotLight | [virtual]
Generated on Tue Jan 15 10:29:17 2008 for NVSGSDK by NVIDIA


sstr_t Struct Reference

The sstr_t structure specifies how a small string is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

ushort_t numChars
uint_t chars
Specifies the file offset to the string characters.

Detailed Description

The sstr_t structure specifies how a small string is stored in a .NBF file.

Note:
A small string is limited to 65535 characters, including the terminating 0

Member Data Documentation

ushort_t numChars

Specifies the number of characters in the actual small string, < not including the terminating null character.

uint_t chars

Specifies the file offset to the string characters.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

sstr_t Member List

This is the complete list of members for sstr_t, including all inherited members.
chars | sstr_t
numChars | sstr_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


StateAttribute Class Reference

Abstract base class of all attribute objects. More...

#include <StateAttribute.h>

Inheritance diagram for StateAttribute:

[legend]
Collaboration diagram for StateAttribute:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~StateAttribute (void)
Destructs a StateAttribute.

virtual NVSG_API bool | isTransparent (void) const
Ask if this StateAttribute is transparent.

NVSG_API void | invalidateTransparencyContainment (void)
Invalidate the transparency containment state.

Protected Member Functions

NVSG_API | StateAttribute (void)
Protected default constructor to prevent explicit creation.

NVSG_API | StateAttribute (const StateAttribute &rhs)
Protected copy constructor to prevent explicit creation.

NVSG_API StateAttribute & | operator= (const StateAttribute &rhs)
Assignment operator.

NVSG_API void | invalidateContainment (unsigned int mask)
Invalidates containment for the indicated states.

Protected Attributes

unsigned int | m_flags

Detailed Description

Abstract base class of all attribute objects.

Namespace: nvsg
Remarks:
Defines the interface that every state attribute has to resolve. A StateAttribute can be the child of one or more StatePass objects.
See also:
BlendAttribute, CgFx, Material, PrimitiveAttribute, StatePass, TextureAttribute

Constructor & Destructor Documentation

virtual NVSG_API ~StateAttribute ( void ) [virtual]

Destructs a StateAttribute.

NVSG_API StateAttribute ( void ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This default constructor is accessible only by derived classes.

NVSG_API StateAttribute ( const StateAttribute & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StateAttribute to copy from
Remarks:
This copy constructor is accessible only by derived classes. The copy constructor of OwnedObject is called, but the parents of rhs are not copied.

Member Function Documentation

virtual NVSG_API bool isTransparent ( void ) const [virtual]

Ask if this StateAttribute is transparent.

Returns:
true, if this StateAttribute is transparent, otherwise false.
Remarks:
We define a StateAttribute to be transparent, or to force transparency, if it explicitly provides a rule that forces the corresponding geometry to appear transparent.
For derived StateAttributes that provide such a rule, it is recommended to override this function to obtain the desired render effect.
The default implementation returns false.
See also:
BlendAttribute, CgFx, invalidateTransparencyContainment

Reimplemented in AlphaTestAttribute, BlendAttribute, CgFx, and LightingAttribute.

NVSG_API void invalidateTransparencyContainment ( void )

Invalidate the transparency containment state.

Remarks:
The transparency containment state of each parent StateSet is invalidated.
See also:
StatePass, isTransparent

NVSG_API StateAttribute& operator= ( const StateAttribute & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant StateAttribute to copy from.
Returns:
A reference to the assigned StateAttribute.
Remarks:
This assignment operator is accessible only by derived classes. It just calls the assignment operator of OwnedObject. The parents of rhs are not copied.

NVSG_API void invalidateContainment ( unsigned int mask ) [protected]

Invalidates containment for the indicated states.

Parameters:
mask A bit mask indicating all containment states to be invalidated.
Remarks:
The function invalidate all containment states indicated by mask up the tree. Symbolic constants are used to set bits in the mask. mask is typically constructed by ORing several of these constants together. Allowed constants are SF_CONTAINS_CGFX and SF_CONTAINS_TRANSPARENCY. The special mask SF_CONTAINS_MASK can be used if all available containment states should be invalidated.

The documentation for this class was generated from the following file:
  • StateAttribute.h
Generated on Tue Jan 15 10:29:17 2008 for NVSGSDK by NVIDIA


Member List

StateAttribute Member List

This is the complete list of members for StateAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isTransparent(void) const | StateAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
validateIncarnation() const | Object | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
Generated on Tue Jan 15 10:29:17 2008 for NVSGSDK by NVIDIA


StatePass Class Reference

Container class to hold a number of StateAttribute objects. More...

#include <StatePass.h>

Inheritance diagram for StatePass:

[legend]
Collaboration diagram for StatePass:

[legend]
List of all members.

Public Member Functions

NVSG_API | StatePass ()
Default-constructs a StatePass.

NVSG_API | StatePass (const Object &rhs)
Constructs a StatePass from an Object.

NVSG_API | StatePass (const StatePass &rhs)
Constructs a StatePass as a copy from another StatePass.

virtual NVSG_API | ~StatePass ()
Destructs a StatePass.

NVSG_API unsigned int | getNumberOfAttributes () const
Get the number of StateAttribute objects in this StatePass.

NVSG_API StateAttributeHandle * | getAttribute (unsigned int index) const
Get the StateAttribute at the specified position.

NVSG_API StateAttributeHandle * | getAttributeByObjectCode (unsigned int objectCode) const
Get the StateAttribute with the object code objectCode.

NVSG_API unsigned int | getAttributeIndex (StateAttributeHandle *attribute) const
Get the index of the specified StateAttribute in this StatePass.

NVSG_API void | addAttribute (StateAttributeHandle *attribute)
Add a StateAttribute to this StatePass.

NVSG_API void | removeAttribute (unsigned int index)
Remove the StateAttribute at the specified position.

NVSG_API void | removeAttribute (StateAttributeHandle *attribute)
Remove the given StateAttribute.

NVSG_API void | removeAttributeByObjectCode (unsigned int objectCode)
Remove the StateAttribute with the specified object code.

NVSG_API bool | isTransparent () const
Ask if this StatePass is transparent.

NVSG_API void | invalidateTransparencyContainment ()
Invalidate the transparency containment cache.

NVSG_API bool | containsCgFx () const
Ask if this StatePass contains any StateAttribute of type CgFx.

NVSG_API void | invalidateCgFxContainment ()
Invalidate the CgFx containment cache.

NVSG_API StatePass & | operator= (const StatePass &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other StatePass.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

NVSG_API void | invalidateContainment (unsigned int mask)
Invalidates containment for the indicated states.

Detailed Description

Container class to hold a number of StateAttribute objects.

Namespace: nvsg
Remarks:
A StatePass holds a number of StateAttribute objects, that together define one rendering pass. A StatePass can be the child of one or more StateVariant objects.
See also:
StateAttribute, StateVariant

Constructor & Destructor Documentation

NVSG_API StatePass ( )

Default-constructs a StatePass.

Remarks:
An empty StatePass is created.

NVSG_API StatePass ( const Object & rhs )

Constructs a StatePass from an Object.

Remarks:
An empty StatePass is created.

NVSG_API StatePass ( const StatePass & rhs )

Constructs a StatePass as a copy from another StatePass.

virtual NVSG_API ~StatePass ( ) [virtual]

Destructs a StatePass.

Member Function Documentation

unsigned int getNumberOfAttributes ( ) const [inline]

Get the number of StateAttribute objects in this StatePass.

Returns:
The number of StateAttribute objects in this StatePass.
See also:
StateAttribute, addAttribute, getAttribute, getAttributeIndex, removeAttribute

StateAttributeHandle * getAttribute ( unsigned int index ) const [inline]

Get the StateAttribute at the specified position.

Parameters:
index The index of the StateAttribute to get.
Returns:
A pointer to the constant StateAttribute at position index.
Note:
The behavior is undefined if index is larger than or equal to the number of StateAttribute objects of this StatePass.
See also:
StateAttribute, addAttribute, getNumberOfAttributes, getAttributeByObjectCode, removeAttribute

NVSG_API StateAttributeHandle* getAttributeByObjectCode ( unsigned int objectCode ) const

Get the StateAttribute with the object code objectCode.

Parameters:
objectCode The object code of the StateAttribute to get.
Returns:
A pointer to the constant StateAttribute with the object code objectCode, or NULL, if there is none.
See also:
StateAttribute, addAttribute, getAttribute, removeAttributeByObjectCode

unsigned int getAttributeIndex ( StateAttributeHandle * attribute ) const [inline]

Get the index of the specified StateAttribute in this StatePass.

Parameters:
attribute A pointer to the constant StateAttribute to get the index in this StatePass for.
Returns:
The index of attribute in this StatePass, or -1 if it is not part of this StatePass.
See also:
StateAttribute, addAttribute, getAttribute, getNumberOfAttributes, removeAttribute

NVSG_API void addAttribute ( StateAttributeHandle * attribute )

Add a StateAttribute to this StatePass.

Parameters:
attribute A pointer to the constant StateAttribute to add.
Remarks:
The reference count of attribute is increased. If there already was a StateAttribute of the same type in this StatePass, the reference count of that StateAttribute is decremented and then it is removed.
See also:
StateAttribute, getAttribute, getAttributeIndex, getNumberOfAttributes, removeAttribute

NVSG_API void removeAttribute ( unsigned int index )

Remove the StateAttribute at the specified position.

Parameters:
index The index of the StateAttribute to remove.
Remarks:
The reference count of the StateAttribute to remove is decreased.
Note:
The behavior is undefined if index is larger than or equal to the number of StateAttribute objects of this StatePass.
See also:
StateAttribute, addAttribute, getAttribute, getAttributeIndex, getNumberOfAttributes

NVSG_API void removeAttribute ( StateAttributeHandle * attribute )

Remove the given StateAttribute.

Parameters:
attribute A pointer to the constant StateAttribute to remove.
Remarks:
If attribute is part of this StatePass, it is removed.
See also:
StateAttribute, addAttribute, getAttributeIndex, removeAttributeByObjectCode

NVSG_API void removeAttributeByObjectCode ( unsigned int objectCode )

Remove the StateAttribute with the specified object code.

Parameters:
objectCode The object code of the StateAttribute to remove.
Remarks:
If there is a StateAttribute with the object code objectCode in this StatePass, it is removed.
See also:
StateAttribute, addAttribute, getAttributeByObjectCode, removeAttribute

NVSG_API bool isTransparent ( ) const

Ask if this StatePass is transparent.

Returns:
true, if this StatePass is transparent, otherwise false.
Remarks:
A StatePass is considered to be transparent, if at least one of its StateAttribute objects is transparent.
See also:
invalidateTransparencyContainment

NVSG_API void invalidateTransparencyContainment ( )

Invalidate the transparency containment cache.

Remarks:
If the transparency containment cache is valid, it is marked as invalid, and the transparency containment cache of each owner is invalidated.
See also:
isTransparent

NVSG_API bool containsCgFx ( ) const

Ask if this StatePass contains any StateAttribute of type CgFx.

Returns:
true, if this StatePass contains a StateAttribute of type CgFx, otherwise false.
See also:
invalidateCgFxContainment

NVSG_API void invalidateCgFxContainment ( )

Invalidate the CgFx containment cache.

Remarks:
If the CgFx containment cache is valid, it is marked as invalid, and all the CgFx containment cache of each owner is invalidated.
See also:
containsCgFx

NVSG_API StatePass& operator= ( const StatePass & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant StatePass to copy from
Returns:
A reference to the assigned StatePass
Remarks:
The assignment operator calls the assignment operator of OwnedObject. Then any StateAttribute attached to this StatePass is removed, and all StateAttribute objects of rhs are copied.
See also:
OwnedObject, StateAttribute

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other StatePass.

Parameters:
p | A reference to the constant StatePass to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the StatePass p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Object, they are equivalent if their StateAttribute objects are equivalent. If deepCompare is true, they are equivalent if for each StateAttribute in this there is an equivalent StateAttribute in p. If deepCompare is false, they are equivalent if each StateAttribute in this is also found in p.
Note:
The behavior is undefined if p is not a StatePass nor derived from one.
See also:
Object, StateAttribute

Reimplemented from Object.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and it is marked as invalid. Then it is validated and the Incarnation of all its StateAttribute objects is requested to continue validation down the tree hierarchy.
See also:
nvutil::Incarnation, StateAttribute, invalidateIncarnation

Reimplemented from Object.

NVSG_API void invalidateContainment ( unsigned int mask )

Invalidates containment for the indicated states.

Parameters:
mask A bit mask indicating all containment states to be invalidated.
Remarks:
The function invalidate all containment states indicated by mask up the tree. Symbolic constants are used to set bits in the mask. mask is typically constructed by ORing several of these constants together. Allowed constants are SF_CONTAINS_CGFX and SF_CONTAINS_TRANSPARENCY. The special mask SF_CONTAINS_MASK can be used if all available containment states should be invalidated.

The documentation for this class was generated from the following file:
  • StatePass.h
Generated on Tue Jan 15 10:29:18 2008 for NVSGSDK by NVIDIA


Member List

StatePass Member List

This is the complete list of members for StatePass, including all inherited members.
addAttribute(StateAttributeHandle *attribute) | StatePass |
addOwner(typename StateVariantHandle::ObjectType *obj) | OwnedObject< StateVariantHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StateVariantHandle > | [protected]
containsCgFx() const | StatePass |
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getAttribute(unsigned int index) const | StatePass | [inline]
getAttributeByObjectCode(unsigned int objectCode) const | StatePass |
getAttributeIndex(StateAttributeHandle *attribute) const | StatePass | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfAttributes() const | StatePass | [inline]
getNumberOfOwners() const | OwnedObject< StateVariantHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StateVariantHandle > |
getUserData() const | Object | [inline]
invalidateCgFxContainment() | StatePass |
invalidateContainment(unsigned int mask) | StatePass |
invalidateIncarnation() | OwnedObject< StateVariantHandle > | [virtual]
invalidateTransparencyContainment() | StatePass |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StatePass | [virtual]
isTransparent() const | StatePass |
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const StatePass &rhs) | StatePass |
nvsg::OwnedObject< StateVariantHandle >::operator=(const OwnedObject< StateVariantHandle > &rhs) | OwnedObject< StateVariantHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StateVariantHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StateVariantHandle > | [protected]
OwnedObject(const OwnedObject< StateVariantHandle > &rhs) | OwnedObject< StateVariantHandle > | [protected]
OwnerIterator typedef | OwnedObject< StateVariantHandle > | [protected]
ownersBegin() const | OwnedObject< StateVariantHandle > | [inline, protected]
ownersBegin() | OwnedObject< StateVariantHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StateVariantHandle > | [inline, protected]
ownersEnd() | OwnedObject< StateVariantHandle > | [inline, protected]
removeAttribute(unsigned int index) | StatePass |
removeAttribute(StateAttributeHandle *attribute) | StatePass |
removeAttributeByObjectCode(unsigned int objectCode) | StatePass |
removeOwner(typename StateVariantHandle::ObjectType *obj) | OwnedObject< StateVariantHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StatePass() | StatePass |
StatePass(const Object &rhs) | StatePass |
StatePass(const StatePass &rhs) | StatePass |
validateIncarnation() const | StatePass | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StateVariantHandle > | [protected]
~StatePass() | StatePass | [virtual]
Generated on Tue Jan 15 10:29:18 2008 for NVSGSDK by NVIDIA


StateSet Class Reference

Container class to hold a number of StateVariant objects. More...

#include <StateSet.h>

Inheritance diagram for StateSet:

[legend]
Collaboration diagram for StateSet:

[legend]
List of all members.

Public Member Functions

NVSG_API | StateSet ()
Default-constructs a StateSet.

NVSG_API | StateSet (const Object &rhs)
Constructs a StateSet from an Object.

NVSG_API | StateSet (const StateSet &rhs)
Constructs a StateSet as a copy from another StateSet.

virtual NVSG_API | ~StateSet ()
Destructs a StateSet.

NVSG_API unsigned int | getNumberOfVariants () const
Get the number of StateVariant objects in this StateSet.

NVSG_API VariantIterator | getFirstVariantIterator () const
Get an iterator on the first pair of VariantKey and StateVariant.

NVSG_API VariantIterator | getNextVariantIterator (VariantIterator it) const
Get an iterator on the next pair of VariantKey and StateVariant.

NVSG_API VariantIterator | getLastVariantIterator () const
Get an iterator beyond the last pair of VariantKey and StateVariant.

NVSG_API StateVariantHandle * | getActiveVariant () const
Get the currently active StateVariant.

NVSG_API StateVariantHandle * | getVariant (VariantKey key) const
Get the StateVariant associated with the specified VariantKey.

NVSG_API StateVariantHandle * | getVariant (VariantIterator it) const
Get the StateVariant corresponding to the VariantIterator it.

NVSG_API VariantKey | getVariantKey (VariantIterator it) const
Get the VariantKey corresponding to the VariantIterator it.

NVSG_API VariantKey | getActiveVariantKey () const
Get the currently active VariantKey.

NVSG_API void | setActiveVariantKey (VariantKey key)
Set the active VariantKey.

NVSG_API void | addVariant (StateVariantHandle *variant, VariantKey key)
Add a combination of VariantKey and StateVariant to this StateSet.

NVSG_API void | removeVariant (VariantKey key)
Remove the StateVariant associated with the specified VariantKey.

NVSG_API void | replaceVariant (VariantKey key, StateVariantHandle *variant)
Replace the StateVariant associated with key by variant.

NVSG_API void | replaceVariantKey (VariantKey oldKey, VariantKey newKey)
Replace the association with oldKey to newKey.

NVSG_API unsigned int | getNumberOfPasses (VariantKey key=0) const
Get the number of StatePass objects in the specified StateVariant.

NVSG_API StatePassHandle * | getPass (unsigned int passIndex, VariantKey key=0) const
Get the StatePass at the specified position in the StateVariant associated with key.

NVSG_API void | addPass (StatePassHandle *pass, VariantKey key=0)
Add a StatePass to the StateVariant associated with key.

NVSG_API void | removePass (unsigned int passIndex, VariantKey key=0)
Remove the StatePass at the specified position from the StateVariant associated with key.

NVSG_API void | replacePass (StatePassHandle *pass, unsigned int passIndex, VariantKey key=0)
Replace the StatePass at the specified position in the StateVariant associated with key.

NVSG_API unsigned int | getNumberOfAttributes (unsigned int passIndex=0, VariantKey key=0) const
Get the number of StateAttribute objects in the specified StatePass.

NVSG_API StateAttributeHandle * | getAttribute (unsigned int attributeIndex, unsigned int passIndex=0, VariantKey key=0) const
Get the StateAttribute at the specified position.

NVSG_API StateAttributeHandle * | getAttributeByObjectCode (unsigned int objectCode, unsigned int passIndex=0, VariantKey key=0) const
Get the StateAttribute with the object code objectCode in the specified StatePass.

NVSG_API unsigned int | getAttributeIndex (StateAttributeHandle *attribute, unsigned int passIndex=0, VariantKey key=0) const
Get the index of the StateAttribute in the specified StatePass.

NVSG_API void | addAttribute (StateAttributeHandle *attribute, unsigned int passIndex=0, VariantKey key=0)
Add a StateAttribute to the specified StatePass.

NVSG_API void | removeAttribute (unsigned int attributeIndex, unsigned int passIndex=0, VariantKey key=0)
Remove the StateAttribute at the specified position.

NVSG_API void | removeAttribute (StateAttributeHandle *attribute, unsigned int passIndex=0, VariantKey key=0)
Remove the given StateAttribute from the specified StatePass.

NVSG_API void | removeAttributeByObjectCode (unsigned int objectCode, unsigned int passIndex=0, VariantKey key=0)
Remove the StateAttribute with the specified object code from the specified StatePass.

NVSG_API bool | isTransparent () const
Ask if the currently active StateVariant is transparent.

NVSG_API void | invalidateContainment (unsigned int mask)
Invalidates containment for the indicated states.

NVSG_API void | invalidateTransparencyContainment ()
Invalidate the transparency containment cache.

NVSG_API bool | containsCgFx () const
Ask if the currently active StateVariant contains any StateAttribute of type CgFx.

NVSG_API void | invalidateCgFxContainment ()
Invalidate the CgFx containment cache.

NVSG_API StateSet & | operator= (const StateSet &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other StateSet.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

Static Public Attributes

const VariantKey | INVALID_VARIANT_KEY = 0xFFFFFFFF

Detailed Description

Container class to hold a number of StateVariant objects.

Namespace: nvsg
Remarks:
A StateSet holds a number of StateVariant objects and a key to select one of them. Only the selected StateVariant is used on standard traversal. That way, it is easy to switch between different StateVariant objects to use.
See also:
StateVariant

Constructor & Destructor Documentation

NVSG_API StateSet ( )

Default-constructs a StateSet.

Remarks:
An empty StateSet with an invalid key is created.

NVSG_API StateSet ( const Object & rhs )

Constructs a StateSet from an Object.

Remarks:
An empty StateSet with an invalid key is created.

NVSG_API StateSet ( const StateSet & rhs )

Constructs a StateSet as a copy from another StateSet.

virtual NVSG_API ~StateSet ( ) [virtual]

Destructs a StateSet.

Member Function Documentation

unsigned int getNumberOfVariants ( ) const [inline]

Get the number of StateVariant objects in this StateSet.

Returns:
The number of StateVariant objects in this StateSet.
See also:
StateVariant, addVariant, getVariant, getVariantKey, removeVariant, replaceVariant

VariantIterator getFirstVariantIterator ( ) const [inline]

Get an iterator on the first pair of VariantKey and StateVariant.

Returns:
A VariantIterator to the first pair of VariantKey and StateVariant.
See also:
getLastVariantIterator, getNextVariantIterator

VariantIterator getNextVariantIterator ( VariantIterator it ) const [inline]

Get an iterator on the next pair of VariantKey and StateVariant.

Parameters:
it The VariantIterator to get the next one for.
Returns:
A VariantIterator to the next pair of VariantKey and StateVariant.
See also:
getFirstVariantIterator, getLastVariantIterator

VariantIterator getLastVariantIterator ( ) const [inline]

Get an iterator beyond the last pair of VariantKey and StateVariant.

Returns:
A VariantIterator beyond the last pair of VariantKey and StateVariant.
See also:
getFirstVariantIterator, getNextVariantIterator

StateVariantHandle * getActiveVariant ( ) const [inline]

Get the currently active StateVariant.

Returns:
A pointer to the constant StateVariant currently active, or NULL, if there is none.
Remarks:
There is only one StateVariant active in a StateSet. Only that StateVariant is used in traversals.
See also:
StateVariant, addVariant, getNumberOfVariants, getVariantKey, getActiveVariant

StateVariantHandle * getVariant ( VariantKey key ) const [inline]

Get the StateVariant associated with the specified VariantKey.

Parameters:
key The VariantKey to get the StateVariant of.
Returns:
A pointer to the constant StateVariant, that is associated with key. key, or NULL, if there is none.
See also:
StateVariant, VariantKey, addVariant, getNumberOfVariants, getVariantKey, getActiveVariant

StateVariantHandle * getVariant ( VariantIterator it ) const [inline]

Get the StateVariant corresponding to the VariantIterator it.

Parameters:
it A VariantIterator from getFirstVariantIterator or getNextVariantIterator
Returns:
A pointer to the constant StateVariant corresponding to it.
Note:
The behavior is undefined if it is not a valid VariantIterator.
See also:
getFirstVariantIterator, getNextVariantIterator, getLastVariantIterator

VariantKey getVariantKey ( VariantIterator it ) const [inline]

Get the VariantKey corresponding to the VariantIterator it.

Parameters:
it A VariantIterator from getFirstVariantIterator or getNextVariantIterator
Returns:
The VariantKey corresponding to \ it.
Note:
The behavior is undefined if it is not a valid VariantIterator.
See also:
getFirstVariantIterator, getNextVariantIterator, getLastVariantIterator

VariantKey getActiveVariantKey ( ) const [inline]

Get the currently active VariantKey.

Returns:
The currently active VariantKey.
Remarks:
There is only one StateVariant active in a StateSet. Only that StateVariant is used in traversals. If there is no StateVariant active, the INVALID_VARIANT_KEY is returned.
See also:
VariantKey, getActiveVariant, getVariantKey, setActiveVariantKey

NVSG_API void setActiveVariantKey ( VariantKey key )

Set the active VariantKey.

Parameters:
key The VariantKey to set active.
Remarks:
There is only one StateVariant active in a StateSet. Only that StateVariant is used in traversals. Only a VariantKey that is part of the StateSet can be used.
See also:
VariantKey, getActiveVariant, getActiveVariantKey

NVSG_API void addVariant | ( | StateVariantHandle * | variant,
 |  | VariantKey | key
 | ) |

Add a combination of VariantKey and StateVariant to this StateSet.

Parameters:
variant | A pointer to the constant StateVariant to add.
key | The VariantKey to associate with variant.
Remarks:
The reference count of \ variant is increased. If there was a StateVariant associated with key before, the reference count of that StateVariant is decreased.
Note:
The behavior is undefined if variant is not a valid pointer to a constant StateVariant.

The behavior is undefined if key is INVALID_VARIANT_KEY.

See also:
StateVariant, VariantKey, getNumberOfVariants, getVariant, getActiveVariant

NVSG_API void removeVariant ( VariantKey key )

Remove the StateVariant associated with the specified VariantKey.

Parameters:
key The VariantKey that is to be removed.
Remarks:
If key is part of this StateSet, the reference count of the associated StateVariant is decreased.
See also:
StateVariant, addVariant, getNumberOfVariants, getVariant, replaceVariant

NVSG_API void replaceVariant | ( | VariantKey | key,
 |  | StateVariantHandle * | variant
 | ) |

Replace the StateVariant associated with key by variant.

Parameters:
key | The VariantKey associated with the StateVariant to replace.
variant | A pointer to the constant StateVariant to use as the replacement.
Remarks:
If key is part of this StateSet, the StateVariant associated with key is replaced by variant. The reference count of the formerly associated StateVariant is decremented, and the reference count of variant is incremented.
See also:
StateVariant, VariantKey, addVariant, replaceVariantKey

NVSG_API void replaceVariantKey | ( | VariantKey | oldKey,
 |  | VariantKey | newKey
 | ) |

Replace the association with oldKey to newKey.

Parameters:
oldKey | The VariantKey, that is to be replaced.
newKey | The VariantKey, that replaces oldKey.
Remarks:
If there is a StateVariant associated with oldKey part of this StateSet, that StateVariant is re-associated with newKey. The old association is lost.
See also:
StateVariant, VariantKey, addVariant, removeVariant, replaceVariant

unsigned int getNumberOfPasses ( VariantKey key = 0 ) const [inline]

Get the number of StatePass objects in the specified StateVariant.

Parameters:
key Optional VariantKey of the StateVariant to get the number of StatePass objects from; default is 0.
Returns:
The number of StatePass objects in the StateVariant associated with the VariantKey key.
See also:
StateVariant, VariantKey, addPass, getPass, removePass, replacePass

StatePassHandle * getPass | ( | unsigned int | passIndex,
 |  | VariantKey | key = 0
 | ) | const [inline]

Get the StatePass at the specified position in the StateVariant associated with key.

Parameters:
passIndex | The index of the StatePass to get.
key | Optional VariantKey of the StateVariant to get the StatePass from; default is 0.
Returns:
A pointer to the constant StatePass at position passIndex in the StateVariant associated with the VariantKey key.
Note:
The behavior is undefined if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant.
See also:
StatePass, StateVariant, VariantKey, addPass, getNumberOfPasses, removePass, replacePass

NVSG_API void addPass | ( | StatePassHandle * | pass,
 |  | VariantKey | key = 0
 | ) |

Add a StatePass to the StateVariant associated with key.

Parameters:
pass | A pointer to the constant StatePass to add.
key | Optional VariantKey of the StateVariant to add the StatePass to; default is 0.
Remarks:
If there is no StateVariant associated to key in this StateSet, such a StateVariant is created. While adding the StatePass, its reference count is incremented.
See also:
StatePass, StateVariant, VariantKey, getNumberOfPasses, getPass, removePass, replacePass

NVSG_API void removePass | ( | unsigned int | passIndex,
 |  | VariantKey | key = 0
 | ) |

Remove the StatePass at the specified position from the StateVariant associated with key.

Parameters:
passIndex | The index of the StatePass to remove.
key | Optional VariantKey of the StateVariant to remove the StatePass from; default is 0.
Remarks:
The reference count of the StatePass to remove is decreased.
Note:
The behaviour is undefined, if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant.
See also:
StatePass, StateVariant, VariantKey, addPass, getNumberOfPasses, getPass, replacePass

NVSG_API void replacePass | ( | StatePassHandle * | pass,
 |  | unsigned int | passIndex,
 |  | VariantKey | key = 0
 | ) |

Replace the StatePass at the specified position in the StateVariant associated with key.

Parameters:
pass | A pointer to the constant StatePass to replace with.
passIndex | The index of the StatePass in the StateVariant to replace.
key | Optional VariantKey of the StateVariant to replace the StatePass from; default is 0.
Remarks:
The reference count of pass is incremented, and the reference count of the StatePass at position index in the StateVariant associated with key is decremented.
Note:
The behavior is undefined if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant.
See also:
StatePass, StateVariant, VariantKey, addPass, getNumberOfPasses, getPass

unsigned int getNumberOfAttributes | ( | unsigned int | passIndex = 0,
 |  | VariantKey | key = 0
 | ) | const [inline]

Get the number of StateAttribute objects in the specified StatePass.

Parameters:
passIndex | Optional index of the StatePass to get the number of StateAttribute objects from; default is 0.
key | Optional VariantKey of the StateVariant to use the StatePass in; default is 0.
Returns:
The number of StateAttribute objects in the StatePass at position passIndex in the StateVariant associated with the VariantKey key.
See also:
StateAttribute, StatePass, StateVariant, VariantKey, addAttribute, getAttribute, getAttributeIndex, removeAttribute

StateAttributeHandle * getAttribute | ( | unsigned int | attributeIndex,
 |  | unsigned int | passIndex = 0,
 |  | VariantKey | key = 0
 | ) | const [inline]

Get the StateAttribute at the specified position.

Parameters:
attributeIndex | The index of the StateAttribute to get.
passIndex | Optional index of the StatePass to get the StateAttribute from; default is 0.
key | Optional VariantKey of the StateVariant to use the StatePass in; default is 0.
Returns:
A pointer to the constant StateAttribute at the specified position.
Note:
The behavior is undefined if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant, of if attributeIndex is larger than or equal to the number of StateAttribute objects in the specified StatePass.
See also:
StateAttribute, StatePass, StateVariant, VariantKey, addAttribute, getAttribute, getAttributeIndex, getNumberOfAttributes, removeAttribute

StateAttributeHandle * getAttributeByObjectCode | ( | unsigned int | objectCode,
 |  | unsigned int | passIndex = 0,
 |  | VariantKey | key = 0
 | ) | const [inline]

Get the StateAttribute with the object code objectCode in the specified StatePass.

Parameters:
objectCode | The object code of the StateAttribute to get.
passIndex | Optional index of the StatePass to get the StateAttribute from; default is 0.
key | Optional VariantKey of the StateVariant to use the StatePass in; default is 0.
Returns:
A pointer to the constant StateAttribute with the object code objectCode, or NULL, if there is none.
Note:
The behavior is undefined if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant.
See also:
StateAttribute, StatePass, StateVariant, VariantKey, addAttribute, getAttribute, removeAttributeByObjectCode

unsigned int getAttributeIndex | ( | StateAttributeHandle * | attribute,
 |  | unsigned int | passIndex = 0,
 |  | VariantKey | key = 0
 | ) | const [inline]

Get the index of the StateAttribute in the specified StatePass.

Parameters:
attribute | A pointer to the constant StateAttribute to get the index for.
passIndex | Optional index of the StatePass to get the index of the StateAttribute from; default is 0.
key | Optional VariantKey of the StateVariant to use the StatePass in; default is 0.
Returns:
The index of attribute in the StatePass passIndex in the specified StateVariant, or -1 if it is not part of.
Note:
The behavior is undefined if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant.
See also:
StateAttribute, StatePass, StateVariant, VariantKey, addAttribute, getAttribute, getNumberOfAttributes, removeAttribute

NVSG_API void addAttribute | ( | StateAttributeHandle * | attribute,
 |  | unsigned int | passIndex = 0,
 |  | VariantKey | key = 0
 | ) |

Add a StateAttribute to the specified StatePass.

Parameters:
attribute | A pointer to the constant StateAttribute to add.
passIndex | Optional index of the StatePass to add attribute to; default is 0.
key | Optional VariantKey of the StateVariant to use the StatePass in; default is 0.
Remarks:
The reference count of attribute is increased. If there already was a StateAttribute of the same type in the specified StatePass, the reference count of that StateAttribute is decremented and then it is removed.
If there is no StateVariant associated to the VariantKey key in this StateSet, a new StateVariant associated to key is created and added. If passIndex is greater than or equal to the number of StatePass objects in the specified StateVariant, a new StatePass is created and added as the last one, before attribute is added to that StatePass.
See also:
StateAttribute, StatePass, StateVariant, VariantKey, getAttribute, getAttributeIndex, getNumberOfAttributes, removeAttribute

NVSG_API void removeAttribute | ( | unsigned int | attributeIndex,
 |  | unsigned int | passIndex = 0,
 |  | VariantKey | key = 0
 | ) |

Remove the StateAttribute at the specified position.

Parameters:
attributeIndex | The index of the StateAttribute to remove.
passIndex | Optional index of the StatePass to remove the StateAttribute from; default is 0.
key | Optional VariantKey of the StateVariant to use the StatePass in; default is 0.
Remarks:
The reference count of the StateAttribute to remove is decreased.
Note:
The behavior is undefined if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant, or if attributeIndex is larger than or equal to the number of StateAttribute objects in the specified StatePass.
See also:
StateAttribute, StatePass, StateVariant, VariantKey, addAttribute, getAttribute, getAttributeIndex, getNumberOfAttributes

NVSG_API void removeAttribute | ( | StateAttributeHandle * | attribute,
 |  | unsigned int | passIndex = 0,
 |  | VariantKey | key = 0
 | ) |

Remove the given StateAttribute from the specified StatePass.

Parameters:
attribute | A pointer to the constant StateAttribute to remove.
passIndex | Optional index of the StatePass to remove attribute from; default is 0.
key | Optional VariantKey of the StateVariant to use the StatePass in; default is 0.
Remarks:
If attribute is part of the specified StatePass, it is removed.
Note:
The behavior is undefined if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant.
See also:
StateAttribute, StatePas, StateVariant, VariantKey, addAttribute, getAttributeIndex, removeAttributeByObjectCode

NVSG_API void removeAttributeByObjectCode | ( | unsigned int | objectCode,
 |  | unsigned int | passIndex = 0,
 |  | VariantKey | key = 0
 | ) |

Remove the StateAttribute with the specified object code from the specified StatePass.

Parameters:
objectCode | The object code of the StateAttribute to remove.
passIndex | Optional index of the StatePass to remove attribute from; default is 0.
key | Optional VariantKey of the StateVariant to use the StatePass in; default is 0.
Remarks:
If there is a StateAttribute with the object code objectCode in the specified StatePass, it is removed.
Note:
The behavior is undefined if there is no StateVariant associated with the VariantKey key, or if passIndex is larger than or equal to the number of StatePass objects in the specified StateVariant.
See also:
StateAttribute, StatePass, StateVariant, VariantKey, addAttribute, getAttributeByObjectCode, removeAttribute

NVSG_API bool isTransparent ( ) const

Ask if the currently active StateVariant is transparent.

Returns:
true, if the currently active StateVariant is transparent, otherwise false.
Remarks:
A StateVariant is considered to be transparent, if at least one of its StatePass objects is transparent.
See also:
invalidateTransparencyContainment

NVSG_API void invalidateContainment ( unsigned int mask )

Invalidates containment for the indicated states.

Parameters:
mask A bit mask indicating all containment states to be invalidated.
Remarks:
The function invalidate all containment states indicated by mask up the tree. Symbolic constants are used to set bits in the mask. mask is typically constructed by ORing several of these constants together. Allowed constants are SF_CONTAINS_CGFX and SF_CONTAINS_TRANSPARENCY. The special mask SF_CONTAINS_MASK can be used if all available containment states should be invalidated.

NVSG_API void invalidateTransparencyContainment ( )

Invalidate the transparency containment cache.

Remarks:
If the transparency containment cache is valid, it is marked as invalid, and the transparency containment cache of each owner is invalidated.
See also:
isTransparent

NVSG_API bool containsCgFx ( ) const

Ask if the currently active StateVariant contains any StateAttribute of type CgFx.

Returns:
true, if the currently active StateVariant contains a StateAttribute of type CgFx, otherwise false.
See also:
invalidateCgFxContainment

NVSG_API void invalidateCgFxContainment ( )

Invalidate the CgFx containment cache.

Remarks:
If the CgFx containment cache is valid, it is marked as invalid, and all the CgFx containment cache of each owner is invalidated.
See also:
containsCgFx

NVSG_API StateSet& operator= ( const StateSet & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant StateSet to copy from
Returns:
A reference to the assigned StateSet
Remarks:
The assignment operator calls the assignment operator of OwnedObject. Then any StateVariant attached to this StateSet is removed, and all StateVariant objects of rhs are copied.
See also:
OwnedObject, StateVariant

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other StateSet.

Parameters:
p | A reference to the constant StateSet to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the StateSet p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Object, they are equivalent if they have the same number of StateVariant/VariantKey pairs and have pair-wise equal VariantKey values. If deepCompare is true, they are equivalent if the StateVariant objects associated with the same VariantKey values are pair-wise equivalent. If deepCompare is false, they are equivalent if they are pair-wise the same pointers.
Note:
The behavior is undefined if p is not a StateSet nor derived from one.
See also:
Object, StateVariant, VariantKey

Reimplemented from Object.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and it is marked as invalid. Then it is validated and the Incarnation of all its StateVariant objects is requested to continue validation down the tree hierarchy.
See also:
nvutil::Incarnation, StateVariant, invalidateIncarnation

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • StateSet.h
Generated on Tue Jan 15 10:29:18 2008 for NVSGSDK by NVIDIA


Member List

StateSet Member List

This is the complete list of members for StateSet, including all inherited members.
addAttribute(StateAttributeHandle *attribute, unsigned int passIndex=0, VariantKey key=0) | StateSet |
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
addPass(StatePassHandle *pass, VariantKey key=0) | StateSet |
addVariant(StateVariantHandle *variant, VariantKey key) | StateSet |
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsCgFx() const | StateSet |
enterCS() const | Object | [inline, protected]
getActiveVariant() const | StateSet | [inline]
getActiveVariantKey() const | StateSet | [inline]
getAnnotation() const | Object |
getAttribute(unsigned int attributeIndex, unsigned int passIndex=0, VariantKey key=0) const | StateSet | [inline]
getAttributeByObjectCode(unsigned int objectCode, unsigned int passIndex=0, VariantKey key=0) const | StateSet | [inline]
getAttributeIndex(StateAttributeHandle *attribute, unsigned int passIndex=0, VariantKey key=0) const | StateSet | [inline]
getDataID() const | Object | [virtual]
getFirstVariantIterator() const | StateSet | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastVariantIterator() const | StateSet | [inline]
getName() const | Object |
getNextVariantIterator(VariantIterator it) const | StateSet | [inline]
getNumberOfAttributes(unsigned int passIndex=0, VariantKey key=0) const | StateSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfPasses(VariantKey key=0) const | StateSet | [inline]
getNumberOfVariants() const | StateSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getPass(unsigned int passIndex, VariantKey key=0) const | StateSet | [inline]
getUserData() const | Object | [inline]
getVariant(VariantKey key) const | StateSet | [inline]
getVariant(VariantIterator it) const | StateSet | [inline]
getVariantKey(VariantIterator it) const | StateSet | [inline]
INVALID_VARIANT_KEY (defined in StateSet) | StateSet | [static]
invalidateCgFxContainment() | StateSet |
invalidateContainment(unsigned int mask) | StateSet |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
invalidateTransparencyContainment() | StateSet |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StateSet | [virtual]
isTransparent() const | StateSet |
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const StateSet &rhs) | StateSet |
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
removeAttribute(unsigned int attributeIndex, unsigned int passIndex=0, VariantKey key=0) | StateSet |
removeAttribute(StateAttributeHandle *attribute, unsigned int passIndex=0, VariantKey key=0) | StateSet |
removeAttributeByObjectCode(unsigned int objectCode, unsigned int passIndex=0, VariantKey key=0) | StateSet |
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
removePass(unsigned int passIndex, VariantKey key=0) | StateSet |
removeVariant(VariantKey key) | StateSet |
replacePass(StatePassHandle *pass, unsigned int passIndex, VariantKey key=0) | StateSet |
replaceVariant(VariantKey key, StateVariantHandle *variant) | StateSet |
replaceVariantKey(VariantKey oldKey, VariantKey newKey) | StateSet |
setActiveVariantKey(VariantKey key) | StateSet |
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateSet() | StateSet |
StateSet(const Object &rhs) | StateSet |
StateSet(const StateSet &rhs) | StateSet |
validateIncarnation() const | StateSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~StateSet() | StateSet | [virtual]
Generated on Tue Jan 15 10:29:18 2008 for NVSGSDK by NVIDIA


StateVariant Class Reference

Container class to hold a number of StatePass objects. More...

#include <StateVariant.h>

Inheritance diagram for StateVariant:

[legend]
Collaboration diagram for StateVariant:

[legend]
List of all members.

Public Member Functions

NVSG_API | StateVariant ()
Default-constructs a StateVariant.

NVSG_API | StateVariant (const Object &rhs)
Constructs a StateVariant from an Object.

NVSG_API | StateVariant (const StateVariant &rhs)
Constructs a StateVariant as a copy from another StateVariant.

virtual NVSG_API | ~StateVariant ()
Destructs a StateVariant.

NVSG_API unsigned int | getNumberOfPasses () const
Get the number of StatePass objects in this StateVariant.

NVSG_API StatePassHandle * | getPass (unsigned int index) const
Get the StatePass at the specified position.

NVSG_API void | addPass (StatePassHandle *pass)
Add a StatePass to this StateVariant.

NVSG_API void | removePass (StatePassHandle *pass)
Remove the given StatePass from the StateVariant.

NVSG_API void | removePass (unsigned int passIndex)
Remove the StatePass at the specified position.

NVSG_API void | replacePass (StatePassHandle *pass, unsigned int index)
Replace the StatePass at the specified position.

NVSG_API unsigned int | getNumberOfAttributes (unsigned int passIndex=0) const
Get the number of StateAttribute objects in the specified StatePass.

NVSG_API StateAttributeHandle * | getAttribute (unsigned int attributeIndex, unsigned int passIndex=0) const
Get the StateAttribute at the specified position.

NVSG_API StateAttributeHandle * | getAttributeByObjectCode (unsigned int objectCode, unsigned int passIndex=0) const
Get the StateAttribute with the object code objectCode in the specified StatePass.

NVSG_API unsigned int | getAttributeIndex (StateAttributeHandle *attribute, unsigned int passIndex=0) const
Get the index of the StateAttribute in the specified StatePass.

NVSG_API void | addAttribute (StateAttributeHandle *attribute, unsigned int passIndex=0)
Add a StateAttribute to the specified StatePass.

NVSG_API void | removeAttribute (unsigned int attributeIndex, unsigned int passIndex=0)
Remove the StateAttribute at the specified position.

NVSG_API void | removeAttribute (StateAttributeHandle *attribute, unsigned int passIndex=0)
Remove the given StateAttribute from the specified StatePass.

NVSG_API void | removeAttributeByObjectCode (unsigned int objectCode, unsigned int passIndex)
Remove the StateAttribute with the specified object code from the specified StatePass.

NVSG_API bool | isTransparent () const
Ask if this StateVariant is transparent.

NVSG_API bool | isEachPassTransparent () const
Ask if this each StatePass of this StateVariant is transparent.

NVSG_API void | invalidateTransparencyContainment ()
Invalidate the transparency containment cache.

NVSG_API bool | containsCgFx () const
Ask if this StateVariant contains any StateAttribute of type CgFx.

NVSG_API void | invalidateCgFxContainment ()
Invalidate the CgFx containment cache.

NVSG_API StateVariant & | operator= (const StateVariant &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other StateVariant.

virtual NVSG_API bool | validateIncarnation () const
Validate the Incarnation.

NVSG_API void | invalidateContainment (unsigned int mask)
Invalidates containment for the indicated states.

Detailed Description

Container class to hold a number of StatePass objects.

Namespace: nvsg
Remarks:
A StateVariant holds a number of StatePass objects. Any geometries associated with this StateVariant is rendered with each of the StatePass objects, one after the other.
A StateVariant can be the child of one or more StateSet objects.
See also:
StatePass, StateSet

Constructor & Destructor Documentation

NVSG_API StateVariant ( )

Default-constructs a StateVariant.

Remarks:
An empty StateVariant is created.

NVSG_API StateVariant ( const Object & rhs )

Constructs a StateVariant from an Object.

Remarks:
An empty StateVariant is created.

NVSG_API StateVariant ( const StateVariant & rhs )

Constructs a StateVariant as a copy from another StateVariant.

virtual NVSG_API ~StateVariant ( ) [virtual]

Destructs a StateVariant.

Member Function Documentation

unsigned int getNumberOfPasses ( ) const [inline]

Get the number of StatePass objects in this StateVariant.

Returns:
The number of StatePass objects in this StateVariant.
See also:
StatePass, addPass, getPass, removePass, replacePass

StatePassHandle * getPass ( unsigned int index ) const [inline]

Get the StatePass at the specified position.

Parameters:
index The index of the StatePass to get.
Returns:
A pointer to the constant StatePass at position index.
Note:
The behavior is undefined if index is larger than or equal to the number of StatePass objects of this StateVariant.
See also:
StatePass, addPass, getNumberOfPasses, removePass, replacePass

NVSG_API void addPass ( StatePassHandle * pass )

Add a StatePass to this StateVariant.

Parameters:
pass A pointer to the constant StatePass to add.
Remarks:
The reference count of pass is increased.
See also:
StatePass, getNumberOfPasses, getPass, removePass, replacePass

NVSG_API void removePass ( StatePassHandle * pass )

Remove the given StatePass from the StateVariant.

Parameters:
pass A pointer to the StatePassHandle to remove.
Remarks:
If pass is not part of this StateVariant, nothing is changed.
See also:
addPass

NVSG_API void removePass ( unsigned int passIndex )

Remove the StatePass at the specified position.

Parameters:
passIndex The index of the StatePass to remove.
Remarks:
The reference count of the StatePass to remove is decreased.
Note:
The behavior is undefined if index is larger than or equal to the number of StatePass objects of this StateVariant.
See also:
StatePass, addPass, getNumberOfPasses, getPass, replacePass

NVSG_API void replacePass | ( | StatePassHandle * | pass,
 |  | unsigned int | index
 | ) |

Replace the StatePass at the specified position.

Parameters:
pass | A pointer to the constant StatePass to replace with.
index | The index of the StatePass in this StateVariant to replace.
Remarks:
The reference count of pass is incremented, and the reference count of the StatePass at position index in this StateVariant is decremented.
Note:
The behavior is undefined if index is larger than or equal to the number of StatePass objects of this StateVariant.
See also:
StatePass, addPass, getNumberOfPasses, getPass

unsigned int getNumberOfAttributes ( unsigned int passIndex = 0 ) const [inline]

Get the number of StateAttribute objects in the specified StatePass.

Parameters:
passIndex Optional index of the StatePass to get the number of StateAttribute objects from; default is 0.
Returns:
The number of StateAttribute objects in the StatePass at position passIndex in this StateVariant.
See also:
StateAttribute, addAttribute, getAttribute, getAttributeIndex, removeAttribute

StateAttributeHandle * getAttribute | ( | unsigned int | attributeIndex,
 |  | unsigned int | passIndex = 0
 | ) | const [inline]

Get the StateAttribute at the specified position.

Parameters:
attributeIndex | The index of the StateAttribute to get.
passIndex | Optional index of the StatePass to get the StateAttribute from; default is 0.
Returns:
A pointer to the constant StateAttribute at the specified position.
Note:
The behavior is undefined if passIndex is larger than or equal to the number of StatePass objects in this StateVariant, or if attributeIndex is larger than or equal to the number of StateAttribute objects in the specified StatePass in this StateVariant.
See also:
StateAttribute, addAttribute, getNumberOfAttributes, getAttributeByObjectCode, removeAttribute

StateAttributeHandle * getAttributeByObjectCode | ( | unsigned int | objectCode,
 |  | unsigned int | passIndex = 0
 | ) | const [inline]

Get the StateAttribute with the object code objectCode in the specified StatePass.

Parameters:
objectCode | The object code of the StateAttribute to get.
passIndex | Optional index of the StatePass to get the StateAttribute from; default is 0.
Returns:
A pointer to the constant StateAttribute with the object code objectCode, or NULL, if there is none.
Note:
The behaviour is undefined, if passIndex is larger than or equal to the number of StatePass objects in this StateVariant.
See also:
StateAttribute, addAttribute, getAttribute, removeAttributeByObjectCode

unsigned int getAttributeIndex | ( | StateAttributeHandle * | attribute,
 |  | unsigned int | passIndex = 0
 | ) | const [inline]

Get the index of the StateAttribute in the specified StatePass.

Parameters:
attribute | A pointer to the constant StateAttribute of the index to get.
passIndex | Optional index of the StatePass containing the index of the StateAttribute; default is 0.
Returns:
The index of attribute in the StatePass passIndex in this StateVariant, or -1 if it is not part of.
Note:
The behavior is undefined if passIndex is larger than or equal to the number of StatePass objects in this StateVariant.
See also:
StateAttribute, addAttribute, getAttribute, getNumberOfAttributes, removeAttribute

NVSG_API void addAttribute | ( | StateAttributeHandle * | attribute,
 |  | unsigned int | passIndex = 0
 | ) |

Add a StateAttribute to the specified StatePass.

Parameters:
attribute | A pointer to the constant StateAttribute to add.
passIndex | Optional index of the StatePass to add attribute to; default is 0.
Remarks:
The reference count of attribute is increased. If there already was a StateAttribute of the same type in the specified StatePass, the reference count of that StateAttribute is decremented and then it is removed.
If passIndex is greater than or equal to the number of StatePass objects in this StateVariant, a new StatePass is created and added as the last one, before attribute is added to that StatePass.
See also:
StateAttribute, getAttribute, getAttributeIndex, getNumberOfAttributes, removeAttribute

void removeAttribute | ( | unsigned int | attributeIndex,
 |  | unsigned int | passIndex = 0
 | ) | [inline]

Remove the StateAttribute at the specified position.

Parameters:
attributeIndex | The index of the StateAttribute to remove.
passIndex | Optional index of the StatePass to remove the StateAttribute from; default is 0.
Remarks:
The reference count of the StateAttribute to remove is decreased.
Note:
The behavior is undefined if passIndex is larger than or equal to the number of StatePass objects in this StateVariant, or if attributeIndex is larger than or equal to the number of StateAttribute objects in the specified StatePass in this StateVariant.
See also:
StateAttribute, addAttribute, getAttribute, getAttributeIndex, getNumberOfAttributes

void removeAttribute | ( | StateAttributeHandle * | attribute,
 |  | unsigned int | passIndex = 0
 | ) | [inline]

Remove the given StateAttribute from the specified StatePass.

Parameters:
attribute | A pointer to the constant StateAttribute to remove.
passIndex | Optional index of the StatePass to remove attribute from; default is 0.
Remarks:
If attribute is part of the specified StatePass, it is removed.
Note:
The behavior is undefined if passIndex is larger than or equal to the number of StatePass objects in this StateVariant.
See also:
StateAttribute, addAttribute, getAttributeIndex, removeAttributeByObjectCode

void removeAttributeByObjectCode | ( | unsigned int | objectCode,
 |  | unsigned int | passIndex
 | ) | [inline]

Remove the StateAttribute with the specified object code from the specified StatePass.

Parameters:
objectCode | The object code of the StateAttribute to remove.
passIndex | Optional index of the StatePass to remove attribute from; default is 0.
Remarks:
If there is a StateAttribute with the object code objectCode in the specified StatePass, it is removed.
Note:
The behavior is undefined if passIndex is larger than or equal to the number of StatePass objects in this StateVariant.
See also:
StateAttribute, addAttribute, getAttributeByObjectCode, removeAttribute

NVSG_API bool isTransparent ( ) const

Ask if this StateVariant is transparent.

Returns:
true, if this StateVariant is transparent, otherwise false.
Remarks:
A StateVariant is considered to be transparent if at least one of its StatePass objects is transparent.
See also:
invalidateTransparencyContainment, isEachPassTransparent

NVSG_API bool isEachPassTransparent ( ) const

Ask if this each StatePass of this StateVariant is transparent.

Returns:
true, if each StatePass of this StateVariant is transparent, otherwise false.
See also:
invalidateTransparencyContainment, isTransparent

NVSG_API void invalidateTransparencyContainment ( )

Invalidate the transparency containment cache.

Remarks:
If the transparency containment cache is valid, it is marked as invalid, and the transparency containment cache of each owner is invalidated.
See also:
isTransparent

NVSG_API bool containsCgFx ( ) const

Ask if this StateVariant contains any StateAttribute of type CgFx.

Returns:
true, if this StateVariant contains a StateAttribute of type CgFx, otherwise false.
See also:
invalidateCgFxContainment

NVSG_API void invalidateCgFxContainment ( )

Invalidate the CgFx containment cache.

Remarks:
If the CgFx containment cache is valid, it is marked as invalid, and all the CgFx containment cache of each owner is invalidated.
See also:
containsCgFx

NVSG_API StateVariant& operator= ( const StateVariant & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant StateVariant to copy from
Returns:
A reference to the assigned StateVariant
Remarks:
The assignment operator calls the assignment operator of OwnedObject. Then any StatePass attached to this StateVariant is removed, and all StatePass objects of rhs are copied.
See also:
OwnedObject, StatePass

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other StateVariant.

Parameters:
p | A reference to the constant StateVariant to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the StateVariant p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Object, they are equivalent, if their StatePass objects are equivalent. If deepCompare is true, they are equivalent if the StatePass objects are pairwise equivalent. If deepCompare is false, they are equivalent, if they are pair-wise the same pointers.
Note:
The behavior is undefined if p is not a StateVariant nor derived from one.
See also:
Object, StatePass

Reimplemented from Object.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the Incarnation.

Remarks:
This function is called from the framework when the Incarnation is requested and it is marked as invalid. Then it is validated and the Incarnation of all its StatePass objects is requested to continue validation down the tree hierarchy.
See also:
nvutil::Incarnation, StatePass, invalidateIncarnation

Reimplemented from Object.

NVSG_API void invalidateContainment ( unsigned int mask )

Invalidates containment for the indicated states.

Parameters:
mask A bit mask indicating all containment states to be invalidated.
Remarks:
The function invalidate all containment states indicated by mask up the tree. Symbolic constants are used to set bits in the mask. mask is typically constructed by ORing several of these constants together. Allowed constants are SF_CONTAINS_CGFX and SF_CONTAINS_TRANSPARENCY. The special mask SF_CONTAINS_MASK can be used if all available containment states should be invalidated.

The documentation for this class was generated from the following file:
  • StateVariant.h
Generated on Tue Jan 15 10:29:18 2008 for NVSGSDK by NVIDIA


Member List

StateVariant Member List

This is the complete list of members for StateVariant, including all inherited members.
addAttribute(StateAttributeHandle *attribute, unsigned int passIndex=0) | StateVariant |
addOwner(typename StateSetHandle::ObjectType *obj) | OwnedObject< StateSetHandle > | [protected]
addPass(StatePassHandle *pass) | StateVariant |
ConstOwnerIterator typedef | OwnedObject< StateSetHandle > | [protected]
containsCgFx() const | StateVariant |
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getAttribute(unsigned int attributeIndex, unsigned int passIndex=0) const | StateVariant | [inline]
getAttributeByObjectCode(unsigned int objectCode, unsigned int passIndex=0) const | StateVariant | [inline]
getAttributeIndex(StateAttributeHandle *attribute, unsigned int passIndex=0) const | StateVariant | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfAttributes(unsigned int passIndex=0) const | StateVariant | [inline]
getNumberOfOwners() const | OwnedObject< StateSetHandle > |
getNumberOfPasses() const | StateVariant | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StateSetHandle > |
getPass(unsigned int index) const | StateVariant | [inline]
getUserData() const | Object | [inline]
invalidateCgFxContainment() | StateVariant |
invalidateContainment(unsigned int mask) | StateVariant |
invalidateIncarnation() | OwnedObject< StateSetHandle > | [virtual]
invalidateTransparencyContainment() | StateVariant |
isDataShared() const | Object | [virtual]
isEachPassTransparent() const | StateVariant |
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StateVariant | [virtual]
isTransparent() const | StateVariant |
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const StateVariant &rhs) | StateVariant |
nvsg::OwnedObject< StateSetHandle >::operator=(const OwnedObject< StateSetHandle > &rhs) | OwnedObject< StateSetHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StateSetHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StateSetHandle > | [protected]
OwnedObject(const OwnedObject< StateSetHandle > &rhs) | OwnedObject< StateSetHandle > | [protected]
OwnerIterator typedef | OwnedObject< StateSetHandle > | [protected]
ownersBegin() const | OwnedObject< StateSetHandle > | [inline, protected]
ownersBegin() | OwnedObject< StateSetHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StateSetHandle > | [inline, protected]
ownersEnd() | OwnedObject< StateSetHandle > | [inline, protected]
removeAttribute(unsigned int attributeIndex, unsigned int passIndex=0) | StateVariant | [inline]
removeAttribute(StateAttributeHandle *attribute, unsigned int passIndex=0) | StateVariant | [inline]
removeAttributeByObjectCode(unsigned int objectCode, unsigned int passIndex) | StateVariant | [inline]
removeOwner(typename StateSetHandle::ObjectType *obj) | OwnedObject< StateSetHandle > | [protected]
removePass(StatePassHandle *pass) | StateVariant |
removePass(unsigned int passIndex) | StateVariant |
replacePass(StatePassHandle *pass, unsigned int index) | StateVariant |
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateVariant() | StateVariant |
StateVariant(const Object &rhs) | StateVariant |
StateVariant(const StateVariant &rhs) | StateVariant |
validateIncarnation() const | StateVariant | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StateSetHandle > | [protected]
~StateVariant() | StateVariant | [virtual]
Generated on Tue Jan 15 10:29:18 2008 for NVSGSDK by NVIDIA


str_t Struct Reference

The str_t structure specifies how a string is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t numChars
uint_t chars
Specifies the file offset to the string characters.

Detailed Description

The str_t structure specifies how a string is stored in a .NBF file.

Member Data Documentation

uint_t numChars

Specifies the number of characters in the actual string, < not including the terminating null character.

uint_t chars

Specifies the file offset to the string characters.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

str_t Member List

This is the complete list of members for str_t, including all inherited members.
chars | str_t
numChars | str_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


StrippedPrimitiveSet Class Reference

Abstract base class for PrimitiveSet objects with points organized as strips. More...

#include <StrippedPrimitiveSet.h>

Inheritance diagram for StrippedPrimitiveSet:

[legend]
Collaboration diagram for StrippedPrimitiveSet:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API | ~StrippedPrimitiveSet (void)
Destructs a StrippedPrimitiveSet.

virtual NVSG_API bool | isDataShared (void) const
Query whether the data of this StrippedPrimitiveSet is shared with other StrippedPrimitiveSet objects.

virtual NVSG_API DataID | getDataID (void) const
Get the unique data identifier of this object.

NVSG_API bool | hasStrips (void) const
Query if this StrippedPrimitiveSet has strips.

NVSG_API unsigned int | getNumberOfStrips (void) const
Get the number of strips.

NVSG_API const IndexSet * | getStrips () const
Get a pointer to the strips.

NVSG_API void | setStrips (const IndexSet *strips, unsigned int numStrips)
Set the strips of this StrippedPrimitiveSet.

NVSG_API void | setStrips (unsigned int pos, const IndexSet *strips, unsigned int numStrips)
Set a subset of strips of this StrippedPrimitiveSet.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other StrippedPrimitiveSet.

Protected Member Functions

NVSG_API | StrippedPrimitiveSet (void)
Protected constructor to prevent explicit creation.

NVSG_API | StrippedPrimitiveSet (const StrippedPrimitiveSet &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Calculates the bounding box of this StrippedPrimitiveSet.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this StrippedPrimitiveSet.

NVSG_API StrippedPrimitiveSet & | operator= (const StrippedPrimitiveSet &rhs)
Assignment operator.

Detailed Description

Abstract base class for PrimitiveSet objects with points organized as strips.

Namespace: nvsg
Remarks:
This class holds a vector of IndexSets used in stripped primitives like LineStrips, QuadStrips, and TriStrips. The strips are defined by a vector of IndexSet elements. Each IndexSet is a std::vector<unsigned int> and represents one strip.
See also:
IndependentPrimitiveSet, LineStrips, MeshedPrimitiveSet, QuadStrips, TriStrips

Constructor & Destructor Documentation

virtual NVSG_API ~StrippedPrimitiveSet ( void ) [virtual]

Destructs a StrippedPrimitiveSet.

NVSG_API StrippedPrimitiveSet ( void ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
The newly created StrippedPrimitiveSet has no strips.
Note:
A StrippedPrimitiveSet will not be instantiated directly, but through instantiating a derived object like QuadStrips for example.

NVSG_API StrippedPrimitiveSet ( const StrippedPrimitiveSet & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to copy from.
Remarks:
The newly created StrippedPrimitiveSet is copied from rhs.
Note:
A StrippedPrimitiveSet will not be instantiated directly, but through instantiating a derived object like QuadStrips for example.

Member Function Documentation

virtual NVSG_API bool isDataShared ( void ) const [virtual]

Query whether the data of this StrippedPrimitiveSet is shared with other StrippedPrimitiveSet objects.

Returns:
true, if the data of this StrippedPrimitiveSet is shared with other StrippedPrimitiveSet objects, otherwise false.
Remarks:
A StrippedPrimitiveSet object shares it's data with another StrippedPrimitiveSet object, if it was either instantiated as a copy of the other, using StrippedPrimitiveSet::clone, or if it was assigned to by the other object using the assignment operator. In that case, the two objects have the same DataID.
See also:
clone, getDataID, operator=()

Reimplemented from Object.

virtual NVSG_API DataID getDataID ( void ) const [virtual]

Get the unique data identifier of this object.

Returns:
A 64-bit value that uniquely identifies the embedded data.
Remarks:
A StrippedPrimitiveSet object shares it's data with another StrippedPrimitiveSet object, if it was either instantiated as a copy of the other, using StrippedPrimitiveSet::clone, or if it was assigned to by the other object using the assignment operator. In that case, the two objects have the same DataID.
See also:
clone, isDataShared, operator=()

Reimplemented from Object.

bool hasStrips ( void ) const [inline]

Query if this StrippedPrimitiveSet has strips.

Returns:
true, if this StrippedPrimitiveSet has at least one IndexSet, otherwise false.
See also:
getNumberOfStrips, getStrips, setStrips

unsigned int getNumberOfStrips ( void ) const [inline]

Get the number of strips.

Returns:
The number of strips of this StrippedPrimitiveSet.
See also:
hasStrips, getStrips, setStrips

const IndexSet * getStrips ( ) const [inline]

Get a pointer to the strips.

Returns:
A pointer to the constant IndexSet elements of this StrippedPrimitiveSet.
See also:
hasStrips, getNumberOfStrips, setStrips

NVSG_API void setStrips | ( | const IndexSet * | strips,
 |  | unsigned int | numStrips
 | ) |

Set the strips of this StrippedPrimitiveSet.

Parameters:
strips | A pointer to the constant IndexSet elements to use.
numStrips | The number of meshes.
Remarks:
Copies numStrips strips from strips into this StrippedPrimitiveSet.
Note:
The behaviour is undefined, if there are less than numStrips values of type IndexSet located at strips.
See also:
hasStrips, getNumberOfStrips, getStrips

NVSG_API void setStrips | ( | unsigned int | pos,
 |  | const IndexSet * | strips,
 |  | unsigned int | numStrips
 | ) |

Set a subset of strips of this StrippedPrimitiveSet.

Parameters:
pos | The start position inside the range of pre-existing strips.
strips | A pointer to the constant strips to use.
numStrips | The number of strips.
Remarks:
Copies numStrips of IndexSet elements from strips into this StrippedPrimitiveSet, starting at position pos inside the range of pre-existing strips.
Pre-existing strips in the range [pos, pos + numStrips) will be replaced. Pre-existing strips outside this range remain untouched.
If you specifiy (-1) for pos or pos specifies the number of strips currently stored, the strips pointed to by strips will be appended to the pre-existing strips.
Note:
The behaviour is undefined, if pos is neither a valid position inside the range of pre-existing strips, nor the number of strips currently stored, nor (-1).

The behaviour is undefined, if there are less than numStrips values of type IndexSet located at strips.

See also:
hasStrips, getNumberOfStrips, getStrips

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other StrippedPrimitiveSet.

Parameters:
p | A reference to the constant StrippedPrimitiveSet to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the StrippedPrimitiveSet p is equivalent to this, otherwise false.
Remarks:
Two StrippedPrimitiveSet objects are equivalent, if they are equivalent as PrimitiveSet, and all their IndexSet elements are pairwise equal.
Note:
The behaviour is undefined if p is not an StrippedPrimitiveSet or derived from one.
See also:
PrimitiveSet

Reimplemented from PrimitiveSet.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Calculates the bounding box of this StrippedPrimitiveSet.

Returns:
The axis-aligned bounding box of this StrippedPrimitiveSet.
Remarks:
This function is called by the framework when re-calculation of the bounding box is required for this StrippedPrimitiveSet.

Implements Drawable.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this StrippedPrimitiveSet.

Returns:
A nvmath::Sphere3f that contains the complete StrippedPrimitiveSet.
Remarks:
This function is called by the framework to determine a sphere that completely contains the StrippedPrimitiveSet.

Implements Drawable.

NVSG_API StrippedPrimitiveSet& operator= ( const StrippedPrimitiveSet & rhs ) [protected]

Assignment operator.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to copy from.
Returns:
A reference to the assigned StrippedPrimitiveSet.
Remarks:
The assignment operator calls the assignment operator of PrimitiveSet and copies the IndexSet elements.

The documentation for this class was generated from the following file:
  • StrippedPrimitiveSet.h
Generated on Tue Jan 15 10:29:19 2008 for NVSGSDK by NVIDIA


Member List

StrippedPrimitiveSet Member List

This is the complete list of members for StrippedPrimitiveSet, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | StrippedPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | StrippedPrimitiveSet | [protected, virtual]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setStrips(const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setStrips(unsigned int pos, const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [virtual]
Generated on Tue Jan 15 10:29:19 2008 for NVSGSDK by NVIDIA


StrippingTraverser Class Reference

Traverser to convert Triangles to TriStrips, and Quads to QuadStrips. More...

#include <StrippingTraverser.h>

Inheritance diagram for StrippingTraverser:

[legend]
Collaboration diagram for StrippingTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | StrippingTraverser (void)
Constructor.

void | getMinimalLengths (unsigned int &triStripLength, unsigned int &quadStripLength) const
Get the minimal lengths for TriStrips and QuadStrips.

void | setMinimalLengths (unsigned int triStripLength, unsigned int quadStripLength)
Set the minimal lengths for TriStrips and QuadStrips.

Protected Member Functions

virtual NVSG_API | ~StrippingTraverser (void)
Protected destructor to prevent instantiation of a StrippingTraverser.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *p)
Convert each Quads to a QuadStrips and a Quads, and each Triangles to a TriStrips and a Triangles.

virtual NVSG_API void | handleQuads (nvsg::Quads *p)
Hold the Quads to strip in handleGeoNode.

virtual NVSG_API void | handleTriangles (nvsg::Triangles *p)
Hold the Triangles to strip in handleGeoNode.

virtual NVSG_API void | handleAnimatedVertexAttributeSet (nvsg::AnimatedVertexAttributeSet *p)
Set the complexVAS flag to true, to prevent stripping Primitives holding an AnimatedVertexAttributeSet.

virtual NVSG_API void | handleSkin (nvsg::Skin *p)
Set the complexVAS flag to true, to prevent stripping Primitives holding a Skin.

Detailed Description

Traverser to convert Triangles to TriStrips, and Quads to QuadStrips.

It is strongly recommended to use a VertexUnifyTraverser before using this StrippingTraverser, because it works only on indices.

Constructor & Destructor Documentation

NVSG_API StrippingTraverser ( void )

Constructor.

virtual NVSG_API ~StrippingTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a StrippingTraverser.

Member Function Documentation

void getMinimalLengths | ( | unsigned int & | triStripLength,
 |  | unsigned int & | quadStripLength
 | ) | const [inline]

Get the minimal lengths for TriStrips and QuadStrips.

A strip with less than the minimal length is reconverted to triangles or quads.

void setMinimalLengths | ( | unsigned int | triStripLength,
 |  | unsigned int | quadStripLength
 | ) | [inline]

Set the minimal lengths for TriStrips and QuadStrips.

A strip with less than the minimal length is reconverted to triangles or quads.

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * p ) [protected, virtual]

Convert each Quads to a QuadStrips and a Quads, and each Triangles to a TriStrips and a Triangles.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuads ( nvsg::Quads * p ) [protected, virtual]

Hold the Quads to strip in handleGeoNode.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriangles ( nvsg::Triangles * p ) [protected, virtual]

Hold the Triangles to strip in handleGeoNode.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleAnimatedVertexAttributeSet ( nvsg::AnimatedVertexAttributeSet * p ) [protected, virtual]

Set the complexVAS flag to true, to prevent stripping Primitives holding an AnimatedVertexAttributeSet.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleSkin ( nvsg::Skin * p ) [protected, virtual]

Set the complexVAS flag to true, to prevent stripping Primitives holding a Skin.

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • StrippingTraverser.h
Generated on Tue Jan 15 10:29:37 2008 for NVSGSDK by NVIDIA


Member List

StrippingTraverser Member List

This is the complete list of members for StrippingTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | ExclusiveTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getMinimalLengths(unsigned int &triStripLength, unsigned int &quadStripLength) const | StrippingTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *p) | StrippingTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *p) | StrippingTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *p) | StrippingTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *p) | StrippingTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *p) | StrippingTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setMinimalLengths(unsigned int triStripLength, unsigned int quadStripLength) | StrippingTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
StrippingTraverser(void) | StrippingTraverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StrippingTraverser(void) | StrippingTraverser | [protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:37 2008 for NVSGSDK by NVIDIA


StrTokenizer Class Reference

Separate a string into tokens. More...

#include <Tools.h>

List of all members.

Public Member Functions

NVSG_API | StrTokenizer (const std::string &delimString)
NVSG_API void | setInput (const std::string &inputString)
NVSG_API const std::string & | getNextToken ()
NVSG_API bool | hasMoreTokens () const

Detailed Description

Separate a string into tokens.

Consecutive calls to getNextToken() return the tokens of inputString that are separated by one or multiple occurences of characters from delimString. If no more tokens are left, an empty string will be returned and hasMoreTokens() will return false.

The documentation for this class was generated from the following file:
  • Tools.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

StrTokenizer Member List

This is the complete list of members for StrTokenizer, including all inherited members.
getNextToken() (defined in StrTokenizer) | StrTokenizer |
hasMoreTokens() const (defined in StrTokenizer) | StrTokenizer |
setInput(const std::string &inputString) (defined in StrTokenizer) | StrTokenizer |
StrTokenizer(const std::string &delimString) (defined in StrTokenizer) | StrTokenizer | [explicit]
~StrTokenizer() (defined in StrTokenizer) | StrTokenizer |
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Switch Class Reference

Switch node. More...

#include <Switch.h>

Inheritance diagram for Switch:

[legend]
Collaboration diagram for Switch:

[legend]
List of all members.

Public Types

typedef unsigned int | MaskKey
An unsigned integer identifier.

typedef std::set< unsigned
int > 		SwitchMask
A container whose children are of type unsigned int.

typedef std::map< MaskKey,
SwitchMask >::const_iterator 		MaskIterator
A typedef helper to use when iterating the switches masks.

enum | { DEFAULT_MASK_KEY = ~0 }
The key used for the default mask. Cannot be added or removed, but can be modified and made active. More...

Public Member Functions

NVSG_API | Switch ()
Default-constructs a Switch.

NVSG_API | Switch (const Group &rhs)
Constructs a Switch from a Group.

NVSG_API | Switch (const Switch &rhs)
Constructs a Switch as a copy of another Switch.

virtual NVSG_API | ~Switch ()
Destructs a Switch.

NVSG_API void | setActive ()
Set all children of this Switch active.

NVSG_API void | setActive (unsigned int index)
Make the specified child of the Switch active.

NVSG_API void | setInactive ()
Set all children of the Switch to inactive.

NVSG_API void | setInactive (unsigned int index)
Make the specified child of the Switch inactive.

NVSG_API unsigned int | getNumberOfActive () const
Get the number of active children.

NVSG_API unsigned int | getActive (std::vector< unsigned int > &indices) const
Get indices to active child nodes.

NVSG_API bool | isActive () const
Test if any of the children are active.

NVSG_API bool | isActive (unsigned int index) const
Test if the specified child is active.

NVSG_API Switch & | operator= (const Switch &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other Switch.

NVSG_API unsigned int | getNumberOfMasks () const
Get the number of masks in this switch.

NVSG_API MaskIterator | getFirstMaskIterator () const
Get the first mask iterator.

NVSG_API MaskIterator | getLastMaskIterator () const
Get one past the last mask iterator.

NVSG_API MaskIterator | getNextMaskIterator (MaskIterator it) const
Get the next mask iterator.

NVSG_API const MaskKey | getMaskKey (MaskIterator it) const
Extract the mask key from a MaskIterator.

NVSG_API const SwitchMask & | getSwitchMask (MaskIterator it) const
Extract the switch mask from a MaskIterator.

NVSG_API const MaskKey | getActiveMask () const
Get the key of the active mask.

NVSG_API bool | setActiveMask (MaskKey k)
Set the active mask to the one that was registered with the given MaskKey.

NVSG_API void | addMask (MaskKey key, const SwitchMask &sm)
Add a new mask to the set of masks for this switch.

NVSG_API bool | removeMask (MaskKey key)
Remove a mask from the set of masks for this switch.

Protected Types

typedef std::map< MaskKey,
SwitchMask >::iterator 		NonConstMaskIterator
An internal const typedef helper to use when iterating the switches masks.

Protected Member Functions

virtual NVSG_API void | init ()
initializes internal data structures

virtual NVSG_API void | postRemoveChild (unsigned int index)
Called from the framework immediately after a child has been removed from the Switch.

virtual NVSG_API void | postAddChild (unsigned int index)
Called from the framework immediately after a child was added to the Switch.

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Calculates the bounding box of this Switch.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere (void) const
Called from the framework if re-calculation of the Group's bounding sphere is required.

virtual NVSG_API unsigned
short 		determineHintsContainment (unsigned short hints) const
Determine the hints containment status of this Switch.

virtual NVSG_API bool | determineTransparencyContainment () const
Called from the framework if re-determination of the transparency containment cache is required.

virtual NVSG_API bool | determineCgFxContainment () const
Determines the CgFx containment status.

virtual NVSG_API bool | determineLightContainment () const
Determines the LightSource containment status.

virtual NVSG_API bool | determineLODContainment () const
Determines the LOD containment status.

virtual NVSG_API bool | determineVolumeNodeContainment () const
Determines the VolumeNode containment status.

Detailed Description

Switch node.

Namespace: nvsg
Remarks:
A Switch node is a special kind of grouping node where one can define which children will be traversed and which will not (active/inactive children).
The Switch node in this case is a special node. It can be thought of as a Dip Switch where you can turn on and off the traversal of several children at the same time.

The primary method of controlling switches is through masks. Masks consist of a MaskKey and a SwitchMask describing the set of children that will become in/active when this Mask is activated. Any number of masks may be added to the switch. Once a mask has been activated the individual children within that mask may also be manipulated using the older setActive/setInactive API, if desired. Note that any changes to the active mask through the set[In]Active interface will permanently change that mask - no temporary copy of each mask is created when it is set active.

Every switch also contains a default mask (named DEFAULT_MASK_KEY). The default mask is created when the switch node is constructed, and remains active if no other switch masks are activated. This allows the switch to operate as it used to with the older API.
Example - using Masks
  mask: 0 - children (0, 2, 3)
  mask: 1 - children (0, 3)
  mask: 997 - children ( 1, 2 )

                 sw
                 |
     -----------------------
     |      |       |      |
     c0     c1      c2     c3

  [...]
  // create the masks
  Switch::MaskKey key0 = 0, key1 = 1, key997 = 997;
  Switch::SwitchMask mask;

  mask.insert( 0 );
  mask.insert( 2 );
  mask.insert( 3 );
  sw->addMask( key0, mask );

  mask.clear();

  mask.insert( 0 );
  mask.insert( 3 );
  sw->addMask( key1, mask );

  mask.clear();

  mask.insert( 1 );
  mask.insert( 2 );
  sw->addMask( key997, mask );

  sw->setActiveMask( key0 );  // mask with key = 0, children 0,2,3 active
                                                    the rest inactive
  sw->setActiveMask( key1 );  // mask with key = 1, children 0,3 active
                                                    the rest inactive
  [...]
Example - Individual Node (older) API
                 sw
                 |
     -----------------------
     |      |       |      |
     c0     c1      c2     c3

  [...]
  sw->setInactive();  // set all children in this mask inactive
  sw->setActive(0);   // set child c0 active in this mask
  sw->setActive(3);   // set child c3 active in this mask
  [...]
In this sample only C0 and C3 will be active and traversed.

Member Typedef Documentation

typedef unsigned int MaskKey

An unsigned integer identifier.

typedef std::set<unsigned int> SwitchMask

A container whose children are of type unsigned int.

Remarks:
Add/remove elements using the standard c++ library container methods.

typedef std::map<MaskKey,SwitchMask>::const_iterator MaskIterator

A typedef helper to use when iterating the switches masks.

See also:
getSwitchMask, getMaskKey

typedef std::map<MaskKey,SwitchMask>::iterator NonConstMaskIterator [protected]

An internal const typedef helper to use when iterating the switches masks.

Member Enumeration Documentation

anonymous enum

The key used for the default mask. Cannot be added or removed, but can be modified and made active.

Constructor & Destructor Documentation

NVSG_API Switch ( )

Default-constructs a Switch.

NVSG_API Switch ( const Group & rhs ) [explicit]

Constructs a Switch from a Group.

Parameters:
rhs Group to construct the Switch from.
Remarks:
This is kind of a partial copy constructor only copying the Group part from the source object.

NVSG_API Switch ( const Switch & rhs )

Constructs a Switch as a copy of another Switch.

virtual NVSG_API ~Switch ( ) [virtual]

Destructs a Switch.

Member Function Documentation

NVSG_API void setActive ( )

Set all children of this Switch active.

Remarks:
Make all children within the current mask visible so all traversers traverse them.
See also:
setInactive, setActiveMask

NVSG_API void setActive ( unsigned int index )

Make the specified child of the Switch active.

Parameters:
index Zero-based index of the child. Providing an invalid index will lead to undefined behavior.
Remarks:
This function makes the specified child visible within the current mask so all traversers traverse it.
Currently active children will stay active within this mask.
See also:
setInactive, setActiveMask

NVSG_API void setInactive ( )

Set all children of the Switch to inactive.

Remarks:
Make all children invisible within the current mask so no traverser traverses them.
See also:
setActive, setActiveMask, isActive

NVSG_API void setInactive ( unsigned int index )

Make the specified child of the Switch inactive.

Parameters:
index Zero-based index of the child. Providing an invalid index will lead to undefined behavior.
Remarks:
This function makes the specified child invisible within the current mask so no traverser traverses it.
Currently inactive children will stay inactive.
See also:
setInactive, setActiveMask, isActive

NVSG_API unsigned int getNumberOfActive ( ) const

Get the number of active children.

Returns:
Number of active children.
Remarks:
This function determines the number of active children within the current mask under this Switch.
See also:
setActive, setInactive, setActiveMask, isActive

NVSG_API unsigned int getActive ( std::vector< unsigned int > & indices ) const

Get indices to active child nodes.

Parameters:
indices Reference to a vector that will hold the returned indices.
Returns:
The number of indices copied to /a indices.
Remarks:
Copies the indices of all active child nodes within the current mask to the vector /a indices.
The internal format a Switch uses for storing indices is unsigned int, which expands to 32-bit for 32-bit environments and 64-bit for 64-bit environments.
See also:
setActive, setInactive, isActive

NVSG_API bool isActive ( ) const

Test if any of the children are active.

Returns:
This function returns true when at least one of the children is active.
Remarks:
This function can be used to test if this Switch has at least one active child within the current mask.
See also:
setActive, setInactive, isActive

NVSG_API bool isActive ( unsigned int index ) const

Test if the specified child is active.

Parameters:
index Zero-based index of the child.
Returns:
This function returns true when the specified child is active within the current mask.
Remarks:
This function can be used to test if a specific child is active within the current mask.
See also:
setActive, setActiveMask, setInactive, isActive

NVSG_API Switch& operator= ( const Switch & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant Switch to copy from.
Returns:
A reference to the assigned Switch.
Remarks:
The assignment operator performs a deep copy and calls the assignment operator of Group.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other Switch.

Parameters:
p | A pointer to the Switch to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the Switch p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as a Group, they are equivalent if they have the same anti-aliasing state, stipple factor, stipple pattern, and width.
See also:
Group

Reimplemented from Group.

NVSG_API unsigned int getNumberOfMasks ( ) const

Get the number of masks in this switch.

Returns:
unsigned int number of masks.
Remarks:
the number of masks will always be >= 1.
See also:
Group

NVSG_API MaskIterator getFirstMaskIterator ( ) const

Get the first mask iterator.

Returns:
MaskIterator of the first in the list.
See also:
MaskIterator

NVSG_API MaskIterator getLastMaskIterator ( ) const

Get one past the last mask iterator.

Returns:
MaskIterator of one past the last in the list.
See also:
MaskIterator

NVSG_API MaskIterator getNextMaskIterator ( MaskIterator it ) const

Get the next mask iterator.

Parameters:
it A MaskIterator obtained from a call to getFirstMaskIterator
Returns:
MaskIterator of one next in the list.
See also:
MaskIterator

NVSG_API const MaskKey getMaskKey ( MaskIterator it ) const

Extract the mask key from a MaskIterator.

Parameters:
it A MaskIterator obtained from a call to getFirstMaskIterator
Returns:
MaskKey contained in the MaskIterator.
See also:
MaskIterator, MaskKey

NVSG_API const SwitchMask& getSwitchMask ( MaskIterator it ) const

Extract the switch mask from a MaskIterator.

Parameters:
it A MaskIterator obtained from a call to getFirstMaskIterator
Returns:
SwitchMask contained in the MaskIterator.
See also:
MaskIterator, SwitchMask

NVSG_API const MaskKey getActiveMask ( ) const

Get the key of the active mask.

Returns:
MaskKey representing the active mask.
See also:
MaskKey

NVSG_API bool setActiveMask ( MaskKey k )

Set the active mask to the one that was registered with the given MaskKey.

Parameters:
k A MaskKey which was previously registered with addMask.
Returns:
bool Signifying whether a mask with that key was found.
See also:
MaskKey

NVSG_API void addMask | ( | MaskKey | key,
 |  | const SwitchMask & | sm
 | ) |

Add a new mask to the set of masks for this switch.

Parameters:
key | A MaskKey to use to refer to this mask later.
sm | A SwitchMask containing the children to activate when this mask is active.
Remarks:
All keys are considered unique, so adding a mask with the same key as an existing mask will silently replace the existing mask.
See also:
removeMask, SwitchMask, MaskKey

NVSG_API bool removeMask ( MaskKey key )

Remove a mask from the set of masks for this switch.

Parameters:
key The MaskKey to remove.
Returns:
bool Signifying whether a mask with that key was found.
Remarks:
You must not remove the mask identified by the DEFAULT_MASK_KEY. Doing so, would result in undefined behavior.
See also:
removeMask, SwitchMask, MaskKey

virtual NVSG_API void init ( ) [protected, virtual]

initializes internal data structures

virtual NVSG_API void postRemoveChild ( unsigned int index ) [protected, virtual]

Called from the framework immediately after a child has been removed from the Switch.

Parameters:
index Zero-based position that previously has referenced the removed child node.
Remarks:
This function takes care of updating the indices in the container that holds the information on the active children. Removing children from the switch may have influence on the position of other children. NOTE: The masks contained within the switch are updated to reflect the child that has been lost.
See also:
Group::postRemoveChild

Reimplemented from Group.

virtual NVSG_API void postAddChild ( unsigned int index ) [protected, virtual]

Called from the framework immediately after a child was added to the Switch.

Parameters:
index Zero-based position where the child node was added.
Remarks:
This function takes care of updating the indices in the container that holds the information on the active children. Adding children to the switch may have influence on the position of other children. NOTE: The masks contained within the switch are updated to reflect the insertion of the child.
See also:
Group::postAddChild

Reimplemented from Group.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Calculates the bounding box of this Switch.

Returns:
The axis-aligned bounding box of this Switch.
Remarks:
This function is called by the framework when re-calculation of the bounding box is required for this Switch.

Reimplemented from Group.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( void ) const [protected, virtual]

Called from the framework if re-calculation of the Group's bounding sphere is required.

Returns:
The function returns a nvmath::Sphere3f that represents the actual bounding sphere of this Switch. The bounding sphere encloses the active children of the Switch.
Remarks:
The function calculates the bounding sphere by accumulating the bounding spheres of all active child nodes.
See also:
Group::calculateBoundingSphere, nvmath::Sphere3f

Reimplemented from Group.

virtual NVSG_API unsigned short determineHintsContainment ( unsigned short hints ) const [protected, virtual]

Determine the hints containment status of this Switch.

Parameters:
hints An unsigned short whose bits encode the hints containment to determine.
Returns:
An unsigned short whose bits encode the hints that are to be determined and also set in this Switch or any of it's active children.
Remarks:
This function is called by the framework, if getHintsContainment is called while the hint containment flags mark that information as invalid.
See also:
containsHints, invalidateHintsContainment, getHintsContainment

Reimplemented from Group.

virtual NVSG_API bool determineTransparencyContainment ( ) const [protected, virtual]

Called from the framework if re-determination of the transparency containment cache is required.

Returns:
The function returns true if the Switch contains at least one child which contains StateSet, that causes the corresponding geometry to appear transparent. Otherwise, the function returns false.
Remarks:
The function iterates through the child nodes and for each node determines transparency containment. The iteration stops with the first child node found that contains at least one StateSet, and that causes the corresponding geometry to appear transparent.
See also:
Group::determineTransparencyContainment, StateSet::isTransparent

Reimplemented from Group.

virtual NVSG_API bool determineCgFxContainment ( ) const [protected, virtual]

Determines the CgFx containment status.

Returns:
true, if tree underneath this Switch contains at least one CgFx, otherwise false.
Remarks:
This overrides Node::determineCgFxContainment, since the tree underneath a Switch can contain a CgFx.

Reimplemented from Group.

virtual NVSG_API bool determineLightContainment ( ) const [protected, virtual]

Determines the LightSource containment status.

Returns:
true, if this Switch contains a LightSource, otherwise false.
Remarks:
This overrides Node::determineLightContainment, since a Switch can hold a LightSource directly or within the underlying sub-tree.

Reimplemented from Group.

virtual NVSG_API bool determineLODContainment ( ) const [protected, virtual]

Determines the LOD containment status.

Returns:
true, if tree underneath this Switch contains at least one LOD, otherwise false.
Remarks:
This overrides Node::determineLODContainment, since the tree underneath a Switch can contain a LOD.

Reimplemented from Group.

virtual NVSG_API bool determineVolumeNodeContainment ( ) const [protected, virtual]

Determines the VolumeNode containment status.

Returns:
true, if tree underneath this Switch contains at least one VolumeNode, otherwise false.
Remarks:
This overrides Node::determineVolumeNodeContainment, since the tree underneath a Switch can contain a VolumeNode.

Reimplemented from Group.

The documentation for this class was generated from the following file:
  • Switch.h
Generated on Tue Jan 15 10:29:19 2008 for NVSGSDK by NVIDIA


Member List

Switch Member List

This is the complete list of members for Switch, including all inherited members.
activateClipPlane(unsigned int index) | Group |
addChild(NodeHandle *child, unsigned int position=~0) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addLightSource(LightSourceHandle *lsHdl) | Group |
addMask(MaskKey key, const SwitchMask &sm) | Switch |
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const | Switch | [protected, virtual]
calculateBoundingSphere(void) const | Switch | [protected, virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
deactivateClipPlane(unsigned int index) | Group |
DEFAULT_MASK_KEY enum value (defined in Switch) | Switch |
determineAnimationContainment() const | Group | [protected, virtual]
determineCgFxContainment() const | Switch | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Switch | [protected, virtual]
determineLightContainment() const | Switch | [protected, virtual]
determineLODContainment() const | Switch | [protected, virtual]
determineTransparencyContainment() const | Switch | [protected, virtual]
determineVolumeNodeContainment() const | Switch | [protected, virtual]
enterCS() const | Object | [inline, protected]
getActive(std::vector< unsigned int > &indices) const | Switch |
getActiveMask() const | Switch |
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getChild(unsigned int position) const | Group | [inline]
getChildPositions(NodeHandle *node, std::vector< unsigned int > &positions) const | Group |
getClipPlane(unsigned int index) const | Group | [inline]
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getFirstMaskIterator() const | Switch |
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getLastMaskIterator() const | Switch |
getLightSource(unsigned int index) const | Group | [inline]
getMaskKey(MaskIterator it) const | Switch |
getName() const | Object |
getNextMaskIterator(MaskIterator it) const | Switch |
getNumberOfActive() const | Switch |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfLightSources() const | Group | [inline]
getNumberOfMasks() const | Switch |
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getSwitchMask(MaskIterator it) const | Switch |
getUserData() const | Object | [inline]
Group() | Group |
Group(const Node &rhs) | Group | [explicit]
Group(const Group &rhs) | Group |
hasChild(NodeHandle *node) const | Group | [inline]
hasLightSource(LightSourceHandle *lsHdl) const | Group | [inline]
init() | Switch | [protected, virtual]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCaches(NodeHandle *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isActive() const | Switch |
isActive(unsigned int index) const | Switch |
isClipPlaneActive(unsigned int index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Switch | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
MaskIterator typedef | Switch |
MaskKey typedef | Switch |
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
NonConstMaskIterator typedef | Switch | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Switch &rhs) | Switch |
nvsg::Group::operator=(const Group &rhs) | Group |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
postAddChild(unsigned int index) | Switch | [protected, virtual]
postRemoveChild(unsigned int index) | Switch | [protected, virtual]
preAddChild(unsigned int position) | Group | [protected, virtual]
preRemoveChild(unsigned int position) | Group | [protected, virtual]
removeChild(NodeHandle *child) | Group |
removeChild(unsigned int position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeLightSource(unsigned int index) | Group |
removeMask(MaskKey key) | Switch |
replaceChild(NodeHandle *newChild, NodeHandle *oldChild) | Group |
replaceChild(NodeHandle *newChild, unsigned int position) | Group |
replaceLightSource(unsigned int index, LightSourceHandle *lsHdl) | Group |
replaceLightSource(LightSourceHandle *newHdl, LightSourceHandle *oldHdl) | Group |
setActive() | Switch |
setActive(unsigned int index) | Switch |
setActiveMask(MaskKey k) | Switch |
setAnnotation(const std::string &anno) | Object |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setInactive() | Switch |
setInactive(unsigned int index) | Switch |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
Switch() | Switch |
Switch(const Group &rhs) | Switch | [explicit]
Switch(const Switch &rhs) | Switch |
SwitchMask typedef | Switch |
validateIncarnation() const | Group | [virtual]
~Group() | Group | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
~Switch() | Switch | [virtual]
Generated on Tue Jan 15 10:29:19 2008 for NVSGSDK by NVIDIA


switchMask_t Struct Reference

The switchMask_t structure specifies how a SwitchMask is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t maskKey
Specifies the key to identify this mask.

uint_t numChildren
Specifies the number of active children stored with this mask.

uint_t children
Specifies the file offset to the zero-based indexes referencing the active children.

Detailed Description

The switchMask_t structure specifies how a SwitchMask is stored in a .NBF file.

Member Data Documentation

uint_t maskKey

Specifies the key to identify this mask.

uint_t numChildren

Specifies the number of active children stored with this mask.

uint_t children

Specifies the file offset to the zero-based indexes referencing the active children.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

switchMask_t Member List

This is the complete list of members for switchMask_t, including all inherited members.
children | switchMask_t
maskKey | switchMask_t
numChildren | switchMask_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


SWMRSync Class Reference

Single write, multiple read synchronization class. More...

#include <SWMRSync.h>

List of all members.

Public Member Functions

NVSG_API | SWMRSync ()
Default constructor.

NVSG_API | SWMRSync (const SWMRSync &rhs)
Copy constructor.

NVSG_API | ~SWMRSync (void)
Default destructor.

NVSG_API bool | lockExclusive () const
Lock the object for exclusive access.

NVSG_API void | unlockExclusive () const
Unlock the object from exclusive access.

NVSG_API bool | lockShared () const
Lock the object for shared access.

NVSG_API void | unlockShared () const
Unlock the object from shared access.

Detailed Description

Single write, multiple read synchronization class.

Remarks:
This class provides the functionality for locking to ensure a single write, multiple read synchronization. That is, an unlimited number of clients can have read access, but only one client can have write access, and when a client has write access, no other client can get read access. An Object, for example, holds a member of type SWMRSync to manage the read/write operations.

Constructor & Destructor Documentation

NVSG_API SWMRSync ( )

Default constructor.

Remarks:
Performs initialization of the internal mutex object.

NVSG_API SWMRSync ( const SWMRSync & rhs )

Copy constructor.

Remarks:
Performs initialization of the internal mutex object. Does not copy data from the source object.

NVSG_API ~SWMRSync ( void )

Default destructor.

Remarks:
Performs deletion of the internal mutex object.

Member Function Documentation

bool lockExclusive ( ) const [inline]

Lock the object for exclusive access.

Returns:
true, if exclusive access is granted.
Remarks:
This function waits until it gets exclusive access to the object. After getting exclusive access, it is safe to write to the object, and no other thread has read or write access to that object.
See also:
unlockExclusive, lockShared

void unlockExclusive ( ) const [inline]

Unlock the object from exclusive access.

Remarks:
After unlocking the object from exclusive access, it is unsafe to have read or write access to that object.
See also:
lockExclusive, unlockShared

bool lockShared ( ) const [inline]

Lock the object for shared access.

Returns:
true, if shared access is granted.
Remarks:
This function waits until it gets shared access to the object. After getting shared access, it is safe to read from the object, but not to write to it. No other thread has write access to that object then.
See also:
unlockShared, lockExclusive

void unlockShared ( ) const [inline]

Unlock the object from shared access.

Remarks:
After unlocking the object from shared access, it is unsafe to have read or write access to that object. Any other thread, trying to get exclusive access, can now get it.
See also:
lockShared, unlockExclusive

The documentation for this class was generated from the following file:
  • SWMRSync.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

SWMRSync Member List

This is the complete list of members for SWMRSync, including all inherited members.
lockExclusive() const | SWMRSync | [inline]
lockShared() const | SWMRSync | [inline]
SWMRSync() | SWMRSync |
SWMRSync(const SWMRSync &rhs) | SWMRSync |
unlockExclusive() const | SWMRSync | [inline]
unlockShared() const | SWMRSync | [inline]
~SWMRSync(void) | SWMRSync |
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


texBinding_t Struct Reference

The texBinding_t structure specifies how a texture binding is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t texUnit
Specifies the texture unit where the actual NBFTextureAttributeItem object is bound to.

uint_t texAttribItem
Specifies the file offset to the corresponding NBFTextureAttributeItem object.

Detailed Description

The texBinding_t structure specifies how a texture binding is stored in a .NBF file.

Texture bindings, in this context, need to be considered in conjunction with NBFTextureAttribute and NBFTextureAttributeItem objects.

Member Data Documentation

uint_t texUnit

Specifies the texture unit where the actual NBFTextureAttributeItem object is bound to.

uint_t texAttribItem

Specifies the file offset to the corresponding NBFTextureAttributeItem object.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

texBinding_t Member List

This is the complete list of members for texBinding_t, including all inherited members.
texAttribItem | texBinding_t
texUnit | texBinding_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


texCoordSet_t Struct Reference

The texCoordSet_t structure specifies how a texture coordinate set is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t numTexCoords
Specifies the number of texture coordinates contained in the actual set.

uint_t coordDim
uint_t texCoords
Specifies the file offset to the contained texture coordinates.

Detailed Description

The texCoordSet_t structure specifies how a texture coordinate set is stored in a .NBF file.

Texture coordinate sets, in this context, need to be considered in conjunction with NBFVertexAttributeSet objects.

Member Data Documentation

uint_t numTexCoords

Specifies the number of texture coordinates contained in the actual set.

uint_t coordDim

Specifies the dimension, in terms of float, of the contained texture coordinates. < Texture coordinates can be either one, two, three, or four dimensional.

uint_t texCoords

Specifies the file offset to the contained texture coordinates.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

texCoordSet_t Member List

This is the complete list of members for texCoordSet_t, including all inherited members.
coordDim | texCoordSet_t
numTexCoords | texCoordSet_t
texCoords | texCoordSet_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


texImage_t Struct Reference

The texImage_t structure specifies how a texture image is stored in a .NBF file. More...

#include <NBF.h>

Collaboration diagram for texImage_t:

[legend]
List of all members.

Public Member Functions

PADDING (12)
Padding bits to ensure offset of scene is on a 4-byte boundary, regardless of packing.

Public Attributes

uint_t flags
Creation flags.

str_t file
Specifies the filename of the image file in case the image is from a file.

uint_t width
Specifies the width of the texture in pixels.

uint_t height
Specifies the height of the texture in pixels.

uint_t depth
Specifies the depth of the texture in pixels.

uint_t pixelFormat
Specifies the format of the pixel data.

uint_t dataType
Specifies the type of the pixel data.

uint_t pixels
Specifies the file offset to the raw pixel data.

Detailed Description

The texImage_t structure specifies how a texture image is stored in a .NBF file.

Texture images are considered in conjunction with NBFTextureAttributeItem objects.

Member Function Documentation

PADDING ( 12 )

Padding bits to ensure offset of scene is on a 4-byte boundary, regardless of packing.

Member Data Documentation

uint_t flags

Creation flags.

str_t file

Specifies the filename of the image file in case the image is from a file.

uint_t width

Specifies the width of the texture in pixels.

uint_t height

Specifies the height of the texture in pixels.

uint_t depth

Specifies the depth of the texture in pixels.

uint_t pixelFormat

Specifies the format of the pixel data.

uint_t dataType

Specifies the type of the pixel data.

uint_t pixels

Specifies the file offset to the raw pixel data.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

texImage_t Member List

This is the complete list of members for texImage_t, including all inherited members.
dataType | texImage_t
depth | texImage_t
file | texImage_t
flags | texImage_t
height | texImage_t
PADDING(12) | texImage_t
pixelFormat | texImage_t
pixels | texImage_t
width | texImage_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


TextureAttribute Class Reference

Texture attribute. More...

#include <TextureAttribute.h>

Inheritance diagram for TextureAttribute:

[legend]
Collaboration diagram for TextureAttribute:

[legend]
List of all members.

Public Types

enum | { INVALID_ITEM = ~0 }
Specifies an invalid binding. More...

Public Member Functions

NVSG_API | TextureAttribute (void)
Default-constructs a TextureAttribute.

NVSG_API | TextureAttribute (const StateAttribute &rhs)
Constructs a TextureAttribute from a StateAttribute.

NVSG_API | TextureAttribute (const TextureAttribute &rhs)
Constructs a TextureAttribute as a copy from another TextureAttribute.

virtual NVSG_API | ~TextureAttribute (void)
Destructs a TextureAttribute.

NVSG_API void | bindTextureAttributeItem (TextureAttributeItemHandle *item, unsigned int unit)
Binds an existing TextureAttributeItem.

NVSG_API void | unbindTextureAttributeItem (unsigned int unit)
Unbinds a TextureAttributeItem.

NVSG_API unsigned int | getFirstItem (void) const
NVSG_API unsigned int | getNextItem (unsigned int unit) const
Retrieves the very next texture unit a TextureAttributeItem is bound to.

NVSG_API unsigned int | getNumberOfItems (void) const
Retrieves the number of bound TextureAttributeItem objects.

NVSG_API TextureAttributeItemHandle * | getTextureAttributeItem (unsigned int unit) const
Retrieves the TextureAttributeItem bound to the specified texture unit.

NVSG_API TextureAttribute & | operator= (const TextureAttribute &rhs)
Assigns values from another TextureAttribute object.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Tests for equivalence with an other TextureAttribute.

virtual NVSG_API bool | validateIncarnation () const
Mark the Incarnation of this Object as valid.

Detailed Description

Texture attribute.

This maintains bindings between abstract texture units and TextureAttributeItem objects. For this purpose it provides an interface to bind a certain TextureAttributeItem to a specified texture unit or to unbind a TextureAttributeItem from a certain texture unit. It also provides an interface to iterate through all bounded TextureAttributeItem objects.

As a StateAttribute, a TextureAttribute can be added to a StateSet of a certain GeoNode for texturing purposes.

Member Enumeration Documentation

anonymous enum

Specifies an invalid binding.

Remarks:
This particular identifier is used as end criteria when iterating through all currently bound TextureAttributeItem objects:
 for ( unsigned int tu = pAttrib->getFirstItem()
     ; tu != TextureAttribute::INVALID_ITEM
     ; tu = pAttrib->getNextItem(tu))
 {
 }
See also:
getFirstItem, getNextItem

Constructor & Destructor Documentation

NVSG_API TextureAttribute ( void )

Default-constructs a TextureAttribute.

Remarks:
A TextureAttribute will be instantiated and default constructed by creating an associated TextureAttributeHandle through CreateHandle(TextureAttributeHandle), which returns a pointer to a TextureAttributeHandle as follows:
     TextureAttributeHandle * hTexAttrib =
       CreateHandle(TextureAttributeHandle);
A default constructed TextureAttribute initially has no TextureAttributeItem bound.

To access the TextureAttribute API, you need to explicitely acquire access for either write or read-only operations on the object. The NVSG SDK provides the convenient helper templates WritableObject and ReadableObject to serve this purpose. These two helper templates are defined in the nvutil namespace. Instantiated objects of these template classes can be used similar as an ordinary pointer:
     // generate a TextureAttributeItem to be bound to the TextureAttribute below
     TextureAttributeItemHandle * hTexAttribItem =
       CreateHandle(TextureAttributeItemHandle);

     // acquire write access to the TextureAttributeItem to assign a TextureImage
     { // limit write access to this scope
       WritableObject<TextureAttributeItem> texAttribItem(hTexAttribItem);
       texAttribItem->setTextureImage(
         TextureImage::createFromFile("sunset.jpg", std::vector<std::string>()) );
       [...]
     } // write access will be released after leaving this scope

     // acquire write access to the TextureAttribute to bind the
     // TextureAttributeItem created before
     { // limit write access to this scope
       WritableObject<TextureAttribute> texAttrib(hTexAttrib);
       texAttrib->bindTextureAttributeItem( hTexAttribItem, 0 );
     } // write access will be released after leaving this scope

NVSG_API TextureAttribute ( const StateAttribute & rhs )

Constructs a TextureAttribute from a StateAttribute.

Parameters:
rhs Specifies the source StateAttribute.
Remarks:
This is kind of a 'partial' copy constructor. Partial, because only the StateAttribute part of the new instantiated TextureAttribute is copied from the rhs StateAttribute. The TextureAttribute specific data will be default-initialized.

This partial copy constructor will be invoked by the CreateHandleFromBase macro.

NVSG_API TextureAttribute ( const TextureAttribute & rhs )

Constructs a TextureAttribute as a copy from another TextureAttribute.

Parameters:
rhs Specifies the source TextureAttribute object.
Remarks:
This copy constructor will be invoked by the TextureAttributeHandle's clone member function.

virtual NVSG_API ~TextureAttribute ( void ) [virtual]

Destructs a TextureAttribute.

Remarks:
This destructor is called when the associated TextureAttributeHandle gets destroyed, that is - when its reference count transfers from 1 to 0. All bound TextureAttributeItems will be unbound, and hence, unreferenced, causing them to get deleted if they are no longer referenced anywhere else.
Note:
The calling thread needs to release previously acquired write or read-only accesses to this TextureAttribute object prior to unreference the associated TextureAttributeHandle object. Otherwise, this results in undefined behavior.

Member Function Documentation

NVSG_API void bindTextureAttributeItem | ( | TextureAttributeItemHandle * | item,
 |  | unsigned int | unit
 | ) |

Binds an existing TextureAttributeItem.

Parameters:
item | Specifies the TextureAttributeItem object to be bound.
unit | Specifies the zero-based texture unit, where to bind the TextureAttributeItem object.
Remarks:
This allows you to bind a TextureAttributeItem to a specified texture unit. If another TextureAttributeItem previously was bound to the same unit, it will be unbound, and hence, unreferenced, causing it to get deleted if it is no longer referenced anywhere else.
Note:
If unit exceeds the number of texture units provided by your current graphics system, the bound TextureAttributeItem will not be processed by the renderer.
See also:
unbindTextureAttributeItem

NVSG_API void unbindTextureAttributeItem ( unsigned int unit )

Unbinds a TextureAttributeItem.

Parameters:
unit Specifies the texture unit to unbind a currently bound TextureAttributeItem from.
Remarks:
This allows you to unbind the TextureAttributeItem that was last bound to the specified texture unit through bindTextureAttributeItem. The TextureAttributeItem then will be unreferenced, causing it to get deleted if no longer referenced anywhere else. Immediately after this call, no TextureAttributeItem is bound to that unit.
See also:
bindTextureAttributeItem

unsigned int getFirstItem ( void ) const [inline]

Retrieves the first zero-based texture unit a TextureAttributeItem is bound to.

Returns:
The function returns a zero-based identifier indicating the first texture unit a TextureAttributeItem is bound to, or INVALID_ITEM, if currently no TextureAttributeItem is bound.
Remarks:
Use this to initiate the iteration of all bound TextureAttributeItems. This function returns the first texture unit found with a valid binding. After that, use getNextItem to iterate through all remaining bindings.

Use getTextureAttributeItem to receive the bound TextureAttributeItem from the texture unit returned by getFirstItem, or getNextItem, respectively.
    // assume hTexAttrib a pointer to a valid TextureAttributeItemHandle

    // NOTE:
    // we need to write-lock the TextureAttribute here, because the
    // edit operations performed to the 'owned' TextureAttributeItem
    // objects below, will cause the incarnation count of the owner
    // to increase, which in turn requires write-access to the owner.
    // Using ReadableObjects instead, would result in a deadlock on
    // a multithreaded configuration!
    WritableObject<TextureAttribute> texAttrib(hTexAttrib);

    for ( unsigned int tu = texAttrib->getFirstItem()
         ; tu != TextureAttribute::INVALID_ITEM
          ; tu = texAttrib->getNextItem(tu) )
    {
        WritableObject<TextureAttributeItem> theItem(texAttrib->getTextureAttributeItem(tu));
        theItem->setEnvMode(TEM_BLEND);
        theItem->setEnvColor(Vec4f(0.2f, 0.2f, 0.2f, 0.5f));
    }
See also:
getNextItem, INVALID_ITEM

unsigned int getNextItem ( unsigned int unit ) const [inline]

Retrieves the very next texture unit a TextureAttributeItem is bound to.

Parameters:
unit Specifies the texture unit returned by a previous getFirstItem, or getNextItem.
Returns:
The function returns a zero-based identifier indicating the next texture unit, following unit, a TextureAttributeItem is bound to, or INVALID_ITEM, if no such unit is available.
Remarks:
Use this in a forward iteration loop after you established the very first texture unit, a TextureAttributeItem is bound to, through getFirstItem.
See also:
getFirstItem

unsigned int getNumberOfItems ( void ) const [inline]

Retrieves the number of bound TextureAttributeItem objects.

Returns:
The number of TextureAttributeItem objects currently bound.
Remarks:
You must not use this to forward iterate through the current bindings, because there might be gaps in the chain of zero-based texture units. If for example two TextureAttributeItem objects are bound in total, and assume the TextureAttributeItem objects are bound to texture unit 2 and 3, getNumberOfItems will return 2, but getTextureAttributeItem(unit) will return NULL for unit < 2. Instead you should use getFirstItem, getNextItem to forward iterate to all valid bindings.
See also:
getTextureAttributeItem, getFirstItem, getNextItem

TextureAttributeItemHandle * getTextureAttributeItem ( unsigned int unit ) const [inline]

Retrieves the TextureAttributeItem bound to the specified texture unit.

Parameters:
unit Specifies the texture unit to query.
Returns:
A pointer to the TextureAttributeItemHandle representing the TextureAttributeItem bound to the specified texture unit, or NULL if no TextureAttributeItem is bound to that unit.

NVSG_API TextureAttribute& operator= ( const TextureAttribute & rhs )

Assigns values from another TextureAttribute object.

Parameters:
rhs Specifies the source TextureAttribute object.
Returns:
A reference to the left-hand-sided TextureAttribute object.
Remarks:
This assignment operator will be invoked when assigning an existing TextureAttribute object to another TextureAttribute object.

All TextureAttributeItem objects currently bound to the left-hand-sided TextureAttribute will be unbound prior to re-assigning the new bindings from the right-hand-sided TextureAttribute. This will unreference all the previously bound TextureAttributeItem objects, causing them to get deleted if no longer referenced anywhere else.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Tests for equivalence with an other TextureAttribute.

Parameters:
p | Pointer to the object to test for equivalence.
ignoreNames | Object names will be ignored if true is specified here.
deepCompare | A deep compare will be performed if true is specified here.
Returns:
true if the TextureAttribute p is equivalent to this TextureAttribute.
Remarks:
This function actually overrides Object::isEquivalent. This is the reason for the passed object to be of type Object, rather than of type TextureAttribute. For all objects of type other than TextureAttribute, this function returns false. Only objects of type TextureAttribute will be considered for further comparison on eqivalence.

If true is specified for the deepCompare parameter, the function will iterate through all valid bindings of both TextureAttribute objects, and in turn performs an equivalence test on each pair of TextureAttributeItem objects. If instead false is specified for the deepCompare parameter, the function just performs a fast pointer-compare on the current bindings.
See also:
TextureAttributeItem::isEquivalent

Reimplemented from Object.

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Mark the Incarnation of this Object as valid.

Returns:
true, if the incarnation was invalid before, otherwise false.
Remarks:
If the Incarnation was invalid before, it is incremented and set as valid.

For Object-derived classes that maintain a kind of parent-child relationship, the particular implementation need to validate the Incarnations from top to bottom.
See also:
getIncarnation, invalidateIncarnation

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • TextureAttribute.h
Generated on Tue Jan 15 10:29:20 2008 for NVSGSDK by NVIDIA


Member List

TextureAttribute Member List

This is the complete list of members for TextureAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
bindTextureAttributeItem(TextureAttributeItemHandle *item, unsigned int unit) | TextureAttribute |
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getDataID() const | Object | [virtual]
getFirstItem(void) const | TextureAttribute | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNextItem(unsigned int unit) const | TextureAttribute | [inline]
getNumberOfItems(void) const | TextureAttribute | [inline]
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getTextureAttributeItem(unsigned int unit) const | TextureAttribute | [inline]
getUserData() const | Object | [inline]
INVALID_ITEM enum value (defined in TextureAttribute) | TextureAttribute |
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | TextureAttribute | [virtual]
isTransparent(void) const | StateAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const TextureAttribute &rhs) | TextureAttribute |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
TextureAttribute(void) | TextureAttribute |
TextureAttribute(const StateAttribute &rhs) | TextureAttribute |
TextureAttribute(const TextureAttribute &rhs) | TextureAttribute |
unbindTextureAttributeItem(unsigned int unit) | TextureAttribute |
validateIncarnation() const | TextureAttribute | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
~TextureAttribute(void) | TextureAttribute | [virtual]
Generated on Tue Jan 15 10:29:20 2008 for NVSGSDK by NVIDIA


TextureAttributeItem Class Reference

Texture attribute item. More...

#include <TextureAttribute.h>

Inheritance diagram for TextureAttributeItem:

[legend]
Collaboration diagram for TextureAttributeItem:

[legend]
List of all members.

Public Member Functions

NVSG_API | TextureAttributeItem (void)
Default-constructs a TextureAttributeItem.

NVSG_API | TextureAttributeItem (const Object &rhs)
Constructs a TextureAttributeItem from an Object.

NVSG_API | TextureAttributeItem (const TextureAttributeItem &rhs)
Constructs a TextureAttributeItem as a copy from another TextureAttributeItem.

virtual NVSG_API | ~TextureAttributeItem ()
Destructs a TextureAttributeItem.

virtual NVSG_API bool | isDataShared (void) const
Returns whether the data of this object is shared.

virtual NVSG_API DataID | getDataID (void) const
Returns a 64-bit integer value, which uniquely identifies the object data.

NVSG_API TextureImageHandle * | getTextureImage () const
Returns the TextureImage assigned to the TextureAttributeItem.

NVSG_API void | setTextureImage (TextureImageHandle *texImg)
Assigns a TextureImage to the TextureAttributeItem.

NVSG_API const std::string & | getTextureFileName () const
Retrieves the file name associated with the attached TextureImage.

NVSG_API TextureTarget | getTextureTarget () const
Retrieves the TextureTarget.

NVSG_API void | setTextureTarget (TextureTarget target)
Sets the TextureTarget.

NVSG_API const nvmath::Vec4f & | getBorderColor (void) const
Returns the actual border color to be used with this TextureAttributeItem.

NVSG_API void | setBorderColor (const nvmath::Vec4f &color)
Sets the border color to be used with this TextureAttributeItem.

NVSG_API const nvmath::Vec4f & | getEnvColor (void) const
Returns the actual environment color of this TextureAttributeItem.

NVSG_API void | setEnvColor (const nvmath::Vec4f &color)
Sets the environment color to be used with this TextureAttributeItem.

NVSG_API TextureEnvMode | getEnvMode (void) const
Returns the actual used environment mode for this TextureAttributeItem.

NVSG_API void | setEnvMode (TextureEnvMode mode)
Sets the environment mode to be used with this TextureAttributeItem.

NVSG_API TextureEnvScale | getEnvScale (void) const
Returns the RGB scale for this TextureAttributeItem.

NVSG_API void | setEnvScale (TextureEnvScale scale)
Returns the RGB scale for this TextureAttributeItem.

NVSG_API TextureMagFilterMode | getMagFilterMode (void) const
Returns the actual filter mode used with magnification.

NVSG_API void | setMagFilterMode (TextureMagFilterMode mode)
Sets the filter mode to use with magnification.

NVSG_API TextureMinFilterMode | getMinFilterMode (void) const
Returns the actual filter mode used with minification.

NVSG_API void | setMinFilterMode (TextureMinFilterMode mode)
Sets the filter mode to use with minification.

NVSG_API bool | isMipmapped (TextureMinFilterMode mode) const
Convenience function to check if a minification filter mode requires mipmaps.

NVSG_API TextureWrapMode | getWrapMode (TexWrapCoordAxis target) const
Returns the actual wrap mode used for the specified texture coordinate.

NVSG_API void | setWrapMode (TexWrapCoordAxis target, TextureWrapMode mode)
Sets the wrap mode for the specified texture coordinate.

NVSG_API nvmath::Mat44f | getMatrix (void) const
Returns the currently specified texture matrix.

NVSG_API const nvmath::Quatf & | getOrientation (void) const
Returns the rotation part of the texture matrix.

NVSG_API void | setOrientation (const nvmath::Quatf &orientation)
Sets the rotation part of the texture matrix.

NVSG_API const nvmath::Vec3f & | getScaling (void) const
Returns the scaling part of the texture matrix.

NVSG_API void | setScaling (const nvmath::Vec3f &scale)
Sets the scaling part of the texture matrix.

NVSG_API const nvmath::Vec3f & | getTranslation (void) const
Returns the translation part of the texture matrix.

NVSG_API void | setTranslation (const nvmath::Vec3f &translation)
Sets the translation part of the texture matrix.

NVSG_API void | setTexGenMode (TexCoordAxis axis, TexGenMode mode)
Sets the texture-coordinate generation mode for the specified texture coordinate.

NVSG_API TexGenMode | getTexGenMode (TexCoordAxis axis) const
Returns the texture-coordinate generation mode for the specified coordinate.

NVSG_API void | setTexGenLinearPlane (TexCoordAxis axis, TexGenLinearPlane target, const nvmath::Vec4f &plane)
Sets the plane to be used with linear texture-coordinate generation.

NVSG_API const nvmath::Vec4f & | getTexGenLinearPlane (TexCoordAxis axis, TexGenLinearPlane plane) const
Returns the plane used with linear texture-coordinate generation.

NVSG_API TextureAttributeItem & | operator= (const TextureAttributeItem &rhs)
Assigns values from another TextureAttributeItem object.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Tests for equivalence with an other TextureAttributeItem.

Detailed Description

Texture attribute item.

A TextureAttributeItem object fully describes a texture together with its environment and parameter settings to be used to render a textured geometry.

The use of a TextureAttributeItem object is meaningful only in conjunction with a TextureAttribute object, that serves as a kind of container for texture attribute items.

Constructor & Destructor Documentation

NVSG_API TextureAttributeItem ( void )

Default-constructs a TextureAttributeItem.

Remarks:
A TextureAttributeItem will be instantiated and default constructed by creating an associated TextureAttributeItemHandle through CreateHandle(TextureAttributeItemHandle), which returns a pointer to a TextureAttributeItemHandle as follows:
     TextureAttributeItemHandle * hTexAttribItem =
       CreateHandle(TextureAttributeItemHandle);
A default constructed TextureAttributeItem has no TextureImage assigned to it. The texture border color initially is black, and the filtering initially is set to use bilinear filtering for both, minification and magnification. Wrap modes initially are set to repeat for all axes. The environment color initially is black, and the environment mode is set to modulate by default. Scaling initially is disabled. Texture coordinate generation also is off by default.

To access the TextureAttributeItem API, you need to explicitely acquire access for either write or read-only operations on the object. The NVSG SDK provides the convenient helper templates WritableObject and ReadableObject to serve this purpose. These two helper templates are defined in the nvutil namespace. Instantiated objects of these template classes can be used similar as an ordinary pointer:
     // acquire write access to the TextureAttributeItem
     { // limit write access to this scope
       WritableObject<TextureAttributeItem> texAttribItem(hTexAttribItem);
       texAttribItem->setTextureImage(
         TextureImage::createFromFile("sunset.jpg", std::vector<std::string>()) );
       [...]
     } // write access will be released after leaving this scope

NVSG_API TextureAttributeItem ( const Object & rhs )

Constructs a TextureAttributeItem from an Object.

Parameters:
rhs Specifies the source Object.
Remarks:
This is kind of a 'partial' copy constructor. Partial, because only the Object part of the new instantiated TextureAttributeItem is copied from the rhs Object. The TextureAttributeItem specific data will be default-initialized.

This partial copy constructor will be invoked by the CreateHandleFromBase macro.

NVSG_API TextureAttributeItem ( const TextureAttributeItem & rhs )

Constructs a TextureAttributeItem as a copy from another TextureAttributeItem.

Parameters:
rhs Specifies the source TextureAttributeItem object.
Remarks:
The new instantiated TextureAttributeItem will be initialized with the same texture parameter settings, texture environment settings, and texture-coordinate generation settings as for the rhs TextureAttributeItem object.

If the rhs TextureAttributeItem has a TextureImage assigned, the TextureImage will not be deep-copied, but the same TextureImage will be assigned to the new instantiated TextureAttributeItem, which in turn increments the reference counter for that TextureImage.

This copy constructor will be invoked by the TextureAttributeItemHandle's clone member function.

virtual NVSG_API ~TextureAttributeItem ( ) [virtual]

Destructs a TextureAttributeItem.

Remarks:
This destructor is called when the associated TextureAttributeItemHandle gets destroyed, that is - when its reference count transfers from 1 to 0. A previously attached TextureImage will be unreferenced, causing it to get deleted if it is no longer referenced anywhere else.
Note:
The calling thread needs to release previously acquired write or read-only accesses to this TextureAttributeItem object prior to unreference the associated TextureAttributeItemHandle object. Otherwise, this results in undefined behavior.

Member Function Documentation

virtual NVSG_API bool isDataShared ( void ) const [virtual]

Returns whether the data of this object is shared.

Returns:
true if the object data is shared, false otherwise.

Reimplemented from Object.

virtual NVSG_API DataID getDataID ( void ) const [virtual]

Returns a 64-bit integer value, which uniquely identifies the object data.

Returns:
A DataID, that is - a 64-bit integer value, which uniquely identifies the Object data.

Reimplemented from Object.

TextureImageHandle * getTextureImage ( ) const [inline]

Returns the TextureImage assigned to the TextureAttributeItem.

Returns:
A pointer to the TextureImageHandle specifying the TextureImage currently assigned to the TextureAttributeItem. The function returns a null pointer if no TextureImage is currently assigned.
Remarks:
A TextureImage can be assigned to the TextureAttributeItem using setTextureImage.
See also:
setTextureImage

NVSG_API void setTextureImage ( TextureImageHandle * texImg )

Assigns a TextureImage to the TextureAttributeItem.

Parameters:
texImg Pointer to the TextureImageHandle specifying the TextureImage to assign.
Remarks:
A previously assigned TextureImage will be unassigned prior to assign the new TextureImage specified by texImg. If the previously assigned TextureImage is not referenced by any other objects, it will be destroyed as it gets unassigned.

NVSG_API const std::string& getTextureFileName ( ) const

Retrieves the file name associated with the attached TextureImage.

Returns:
The file name associated with the attached TextureImage. If no TextureImage is assigned, an empty string will be returned.
See also:
setTextureImage, getTextureImage

TextureTarget getTextureTarget ( ) const [inline]

Retrieves the TextureTarget.

Returns:
The function returns the TextureTarget specified for the TextureAttributeItem.
Remarks:
The TextureAttributeItem's TextureTarget remains unspecified until it will be specified through setTextureTarget.
See also:
setTextureTarget, TextureTarget

NVSG_API void setTextureTarget ( TextureTarget target )

Sets the TextureTarget.

Parameters:
target Indicates the TextureTarget to which to bind the associated TextureImage.
Remarks:
When a renderer first evaluates a TextureAttributeItem it binds the TextureImage, that was assigned to the TextureAttributeItem through setTextureImage, to a particular TextureTarget. This function lets you specify the TextureTarget to which the assigned TextureImage should be bound. Specifying a TextureTarget which is incompatible to the assigned TextureImage results in undefined behavior.
See also:
getTextureTarget, setTextureImage

const nvmath::Vec4f & getBorderColor ( void ) const [inline]

Returns the actual border color to be used with this TextureAttributeItem.

Returns:
A 4-component vector (RGBA) specifying the actual border color to be used.
See also:
setBorderColor

NVSG_API void setBorderColor ( const nvmath::Vec4f & color )

Sets the border color to be used with this TextureAttributeItem.

Parameters:
color Specifies the new border color.
Remarks:
This allows you to alter the border color currently used. The initial border color is black.
See also:
getBorderColor

const nvmath::Vec4f & getEnvColor ( void ) const [inline]

Returns the actual environment color of this TextureAttributeItem.

Returns:
A 4-component vector (RGBA) specifying the current environment color.
See also:
setEnvColor

void setEnvColor ( const nvmath::Vec4f & color ) [inline]

Sets the environment color to be used with this TextureAttributeItem.

Parameters:
color Specifies the new environment color.
Remarks:
This allows you to alter the environment color currently used. The initial environment color is black.

The environment color is considered only if the TEM_BLEND environment mode also was specified through setEnvMode. The luminance, or color value is used somewhat like an alpha value to blend the fragment's color with the environment color.
See also:
getEnvColor, setEnvMode

TextureEnvMode getEnvMode ( void ) const [inline]

Returns the actual used environment mode for this TextureAttributeItem.

Returns:
A TextureEnvMode enum specifying the actual environment mode.
See also:
setEnvMode

NVSG_API void setEnvMode ( TextureEnvMode mode )

Sets the environment mode to be used with this TextureAttributeItem.

Parameters:
mode Specifies the new texture environment mode.
Remarks:
This allows you to alter the texture environment mode to use. Accepted modes are TEM_REPLACE, TEM_MODULATE, TEM_DECAL, TEM_BLEND, TEM_ADD, TEM_ADD_SIGNED, TEM_SUBTRACT, TEM_INTERPOLATE, TEM_DOT3_RGB, and TEM_DOT3_RGBA. The initial texture environment mode is TEM_MODULATE.
See also:
getEnvMode

TextureEnvScale getEnvScale ( void ) const [inline]

Returns the RGB scale for this TextureAttributeItem.

Returns:
A TextureEnvScale enum specifying the environment scale.
See also:
setEnvScale

NVSG_API void setEnvScale ( TextureEnvScale scale )

Returns the RGB scale for this TextureAttributeItem.

Parameters:
scale Specifies the new environment scale.
Remarks:
This allows scaling the result of the texture environment operation. Currently, scaling only works with the following TextureEnv Modes: TEM_ADD_SIGNED, TEM_SUBTRACT, TEM_INTERPOLATE, TEM_DOT3_RGB, and TEM_DOT3_RGBA. Accepted values for scale are TES_1X, TES_2X, and TES_4X. The initial scale value is TES_1X, which means, scaling off.
See also:
getEnvScale

TextureMagFilterMode getMagFilterMode ( void ) const [inline]

Returns the actual filter mode used with magnification.

Returns:
A TextureMagFilterMode enum specifying the actual magnifying filter mode.
See also:
setMagFilterMode

NVSG_API void setMagFilterMode ( TextureMagFilterMode mode )

Sets the filter mode to use with magnification.

Parameters:
mode Specifies the new filter mode to use with magnification.
Remarks:
This allows you to alter the filter mode to use with magnification. Accepted filter modes used for magnification are TFM_MAG_NEAREST, and TFM_MAG_LINEAR. The initial filter mode is TFM_MAG_LINEAR.
See also:
getMagFilterMode

TextureMinFilterMode getMinFilterMode ( void ) const [inline]

Returns the actual filter mode used with minification.

Returns:
A TextureMinFilterMode enum specifying the actual filter mode used with minification.
See also:
setMinFilterMode

NVSG_API void setMinFilterMode ( TextureMinFilterMode mode )

Sets the filter mode to use with minification.

Parameters:
mode Specifies the new filter mode to use with minification.
Remarks:
This allows you to alter the filter mode to use with minification. Accepted filter modes used for minification are TFM_MIN_NEAREST, TFM_MIN_LINEAR, TFM_MIN_LINEAR_MIPMAP_LINEAR, TFM_MIN_NEAREST_MIPMAP_NEAREST, TFM_MIN_NEAREST_MIPMAP_LINEAR, and TFM_MIN_LINEAR_MIPMAP_NEAREST. The four _MIPMAP_ filter modes require mipmaps available in the assigned TextureImage. The initial filter mode is TFM_MIN_LINEAR.
See also:
getMinFilterMode

bool isMipmapped ( TextureMinFilterMode mode ) const [inline]

Convenience function to check if a minification filter mode requires mipmaps.

Parameters:
mode Specifies the minification filter mode to check.

TextureWrapMode getWrapMode ( TexWrapCoordAxis target ) const [inline]

Returns the actual wrap mode used for the specified texture coordinate.

Parameters:
target Specifies the texture coordinate to query the wrap mode for. Accepted values are TWCA_S, TWCA_T, and TWCA_R.
Returns:
A TextureWrapMode enum specifying the actual wrap parameter.
See also:
setWrapMode

NVSG_API void setWrapMode | ( | TexWrapCoordAxis | target,
 |  | TextureWrapMode | mode
 | ) |

Sets the wrap mode for the specified texture coordinate.

Parameters:
target | Specifies the texture coordinate.
mode | Specifies the new wrap mode.
Remarks:
This allows you to re-specify the wrap mode to use for the indicated texture coordinate. Accepted values for the texture coordinate are TWCA_S, TWCA_T, and TWCA_R. Accepted values for the wrap mode are TWM_REPEAT, TWM_CLAMP, TWM_MIRROR_REPEAT, TWM_CLAMP_TO_EDGE, TWM_CLAMP_TO_BORDER, TWM_MIRROR_CLAMP, TWM_MIRROR_CLAMP_TO_EDGE, and TWM_MIRROR_CLAMP_TO_BORDER. The initial wrap mode is TWM_REPEAT for all texture coordinates.
See also:
getWrapMode

nvmath::Mat44f getMatrix ( void ) const [inline]

Returns the currently specified texture matrix.

Returns:
A 4x4 matrix specifying the actual texture matrix.
Remarks:
The related texture coordinates are multiplied by the texture matrix before any texture mapping occurs. The initial value for the texture matrix is the identity matrix. You are allowed to modify the texture matrix through setOrientation, setScaling, and setTranslation.
See also:
setOrientation, setScaling, setTranslation

const nvmath::Quatf & getOrientation ( void ) const [inline]

Returns the rotation part of the texture matrix.

Returns:
A quaternion specifying the rotation part of the currently specified texture matrix.
See also:
getMatrix, setOrientation

NVSG_API void setOrientation ( const nvmath::Quatf & orientation )

Sets the rotation part of the texture matrix.

Parameters:
orientation Specifies the new rotation.
Remarks:
This allows you to re-specify the rotation to be applied to the related texture coordinates before any texture mapping occurs.
See also:
getMatrix, getOrientation.

const nvmath::Vec3f & getScaling ( void ) const [inline]

Returns the scaling part of the texture matrix.

Returns:
A 3-component vector specifying the scaling.
See also:
getMatrix, setScaling

NVSG_API void setScaling ( const nvmath::Vec3f & scale )

Sets the scaling part of the texture matrix.

Parameters:
scale Specifies the new scaling.
Remarks:
This allows you to re-specify the scaling to be applied to the related texture coordinates before any texture mapping occurs.
See also:
getMatrix, getScaling.

const nvmath::Vec3f & getTranslation ( void ) const [inline]

Returns the translation part of the texture matrix.

Returns:
A 3-component vector specifying the translation.
See also:
getMatrix, setTranslation

NVSG_API void setTranslation ( const nvmath::Vec3f & translation )

Sets the translation part of the texture matrix.

Parameters:
translation Specifies the new translation.
Remarks:
This allows you to re-specify the translation to be applied to the related texture coordinates before any texture mapping occurs.
See also:
getMatrix, getTranslation.

NVSG_API void setTexGenMode | ( | TexCoordAxis | axis,
 |  | TexGenMode | mode
 | ) |

Sets the texture-coordinate generation mode for the specified texture coordinate.

Parameters:
axis | Specifies the texture coordinate for which to respecify the generation mode.
mode | Specifies the texture-coordinate generation mode.
Remarks:
This allows you to re-specify the texture-coordinate generation mode for the indicated texture coordinate. Accepted values for the texture coordinate specified by axis are TCA_S, TCA_T, TCA_R, and TCA_Q. Accepted values for the texture-coordinate generation mode are TGM_OFF, TGM_OBJECT_LINEAR, TGM_EYE_LINEAR, TGM_SPHERE_MAP, TGM_REFLECTION_MAP, and TGM_NORMAL_MAP. The initial value for the texture-coordinate generation mode is TGM_OFF for all texture coordinates, which means, texture-coordinate generation off.

If you specify a texture-coordinate generation mode other than TGM_OFF, automatic texture-coordinate generation will be enabled for the particular texture coordinate.

For the TGM_OBJECT_LINEAR and TGM_EYE_LINEAR generation mode, the linear plane, you are allowed to specify through setTexGenLinearPlane, will be taken into account for automatic texture-coordinate generation.
See also:
getTexGenMode, setTexGenLinearPlane

TexGenMode getTexGenMode ( TexCoordAxis axis ) const [inline]

Returns the texture-coordinate generation mode for the specified coordinate.

Returns:
A TexGenMode enum specifying the current texture-coordinate generation mode used for the specified coordinate. Accepted values for axis are TCA_S, TCA_T, TCA_R, and TCA_Q.
See also:
setTexGenMode

NVSG_API void setTexGenLinearPlane | ( | TexCoordAxis | axis,
 |  | TexGenLinearPlane | target,
 |  | const nvmath::Vec4f & | plane
 | ) |

Sets the plane to be used with linear texture-coordinate generation.

Parameters:
axis | Specifies the texture coordinate for which to specify the plane.
target | Specifies the target for which to specify the plane.
plane | Specifies the plane to use with linear texture-coordinate generation.
Remarks:
This function lets you specify distinct planes to be used with the linear texture-generation modes TGM_OBJECT_LINEAR, and TGM_EYE_LINEAR. For other texture-coordinate generation modes, these linear planes are of no relevance. Different planes can be specifies for each available texture-coordinate. Accepted values to specify the texture coordinate, indicated by axis, are TCA_S, TCA_T, TCA_R, and TCA_Q. For target, TGLP_OBJECT, TGLP_EYE, or TGLP_OBJECT_AND_EYE, are allowed values. If you specifying TGLP_OBJECT_AND_EYE, the specified plane will be used for both, the TGM_OBJECT_LINEAR, and the TGM_EYE_LINEAR texture-coordinate generation mode.

Initial plane values for the different texture coordinates, and for both linear generation modes are as follows:
     TCA_S = (1, 0, 0, 0)
     TCA_T = (0, 1, 0, 0)
     TCA_R = (0, 0, 0, 0)
     TCA_Q = (0, 0, 0, 0)
Note:
Other than setTexGenMode, the function does not automatically enable texture-coordinate generation. You need to explicitely call setTexGenMode accordingly.
See also:
getTexGenLinearPlane, setTexGenMode

const nvmath::Vec4f & getTexGenLinearPlane | ( | TexCoordAxis | axis,
 |  | TexGenLinearPlane | plane
 | ) | const [inline]

Returns the plane used with linear texture-coordinate generation.

Parameters:
axis | Specifies the texture coordinate for which to query the plane. Accepted values are TCA_S, TCA_t, TCA_R, and TCA_Q.
plane | Specifies the linear generation mode for which to query the plane. Accepted values are TGLP_OBJECT and TGLP_EYE.
Returns:
a 4-component vector specifying the plane.
Note:
You must not specify TGLP_OBJECT_AND_EYE for plane! Doing so results in undefined behavior.
See also:
setTexGenLinearPlane

NVSG_API TextureAttributeItem& operator= ( const TextureAttributeItem & rhs )

Assigns values from another TextureAttributeItem object.

Parameters:
rhs Specifies the source TextureAttributeItem object.
Returns:
A reference to the left-hand-sided TextureAttributeItem object.
Remarks:
This assignment operator will be invoked when assigning an existing TextureAttributeItem object to another TextureAttributeItem object.

A TextureImage that previously was assigned to the left-hand-sided TextureAttributeItem, will be unreferenced, causing the TextureImage to get deleted if it is not reference anywhere else.

If the rhs TextureAttributeItem has a TextureImage assigned, the TextureImage will not be deep-copied, but the same TextureImage will be assigned to the left-hand-sided TextureAttributeItem, which in turn increments the reference counter for that TextureImage.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Tests for equivalence with an other TextureAttributeItem.

Parameters:
p | Pointer to the object to test for equivalence.
ignoreNames | Object names will be ignored if true is specified here.
deepCompare | A deep compare will be performed if true is specified here. This does not apply to a TextureAttributeItem, though, and therefore is ignored.
Returns:
true if the TextureAttributeItem p is equivalent to this TextureAttributeItem.
Remarks:
This function actually overrides Object::isEquivalent. This is the reason for the passed object to be of type Object, rather than of type TextureAttributeItem. For all objects of type other than TextureAttributeItem, this function returns false. Only objects of type TextureAttributeItem will be considered for further comparison on eqivalence.

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • TextureAttribute.h
Generated on Tue Jan 15 10:29:20 2008 for NVSGSDK by NVIDIA


Member List

TextureAttributeItem Member List

This is the complete list of members for TextureAttributeItem, including all inherited members.
addOwner(typename TextureAttributeHandle::ObjectType *obj) | OwnedObject< TextureAttributeHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< TextureAttributeHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBorderColor(void) const | TextureAttributeItem | [inline]
getDataID(void) const | TextureAttributeItem | [virtual]
getEnvColor(void) const | TextureAttributeItem | [inline]
getEnvMode(void) const | TextureAttributeItem | [inline]
getEnvScale(void) const | TextureAttributeItem | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getMagFilterMode(void) const | TextureAttributeItem | [inline]
getMatrix(void) const | TextureAttributeItem | [inline]
getMinFilterMode(void) const | TextureAttributeItem | [inline]
getName() const | Object |
getNumberOfOwners() const | OwnedObject< TextureAttributeHandle > |
getObjectCode() const | Object | [inline]
getOrientation(void) const | TextureAttributeItem | [inline]
getOwner(unsigned int index) const | OwnedObject< TextureAttributeHandle > |
getScaling(void) const | TextureAttributeItem | [inline]
getTexGenLinearPlane(TexCoordAxis axis, TexGenLinearPlane plane) const | TextureAttributeItem | [inline]
getTexGenMode(TexCoordAxis axis) const | TextureAttributeItem | [inline]
getTextureFileName() const | TextureAttributeItem |
getTextureImage() const | TextureAttributeItem | [inline]
getTextureTarget() const | TextureAttributeItem | [inline]
getTranslation(void) const | TextureAttributeItem | [inline]
getUserData() const | Object | [inline]
getWrapMode(TexWrapCoordAxis target) const | TextureAttributeItem | [inline]
invalidateIncarnation() | OwnedObject< TextureAttributeHandle > | [virtual]
isDataShared(void) const | TextureAttributeItem | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | TextureAttributeItem | [virtual]
isMipmapped(TextureMinFilterMode mode) const | TextureAttributeItem | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const TextureAttributeItem &rhs) | TextureAttributeItem |
nvsg::OwnedObject< TextureAttributeHandle >::operator=(const OwnedObject< TextureAttributeHandle > &rhs) | OwnedObject< TextureAttributeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< TextureAttributeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< TextureAttributeHandle > | [protected]
OwnedObject(const OwnedObject< TextureAttributeHandle > &rhs) | OwnedObject< TextureAttributeHandle > | [protected]
OwnerIterator typedef | OwnedObject< TextureAttributeHandle > | [protected]
ownersBegin() const | OwnedObject< TextureAttributeHandle > | [inline, protected]
ownersBegin() | OwnedObject< TextureAttributeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< TextureAttributeHandle > | [inline, protected]
ownersEnd() | OwnedObject< TextureAttributeHandle > | [inline, protected]
removeOwner(typename TextureAttributeHandle::ObjectType *obj) | OwnedObject< TextureAttributeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setBorderColor(const nvmath::Vec4f &color) | TextureAttributeItem |
setEnvColor(const nvmath::Vec4f &color) | TextureAttributeItem | [inline]
setEnvMode(TextureEnvMode mode) | TextureAttributeItem |
setEnvScale(TextureEnvScale scale) | TextureAttributeItem |
setMagFilterMode(TextureMagFilterMode mode) | TextureAttributeItem |
setMinFilterMode(TextureMinFilterMode mode) | TextureAttributeItem |
setName(const std::string &name) | Object |
setOrientation(const nvmath::Quatf &orientation) | TextureAttributeItem |
setScaling(const nvmath::Vec3f &scale) | TextureAttributeItem |
setTexGenLinearPlane(TexCoordAxis axis, TexGenLinearPlane target, const nvmath::Vec4f &plane) | TextureAttributeItem |
setTexGenMode(TexCoordAxis axis, TexGenMode mode) | TextureAttributeItem |
setTextureImage(TextureImageHandle *texImg) | TextureAttributeItem |
setTextureTarget(TextureTarget target) | TextureAttributeItem |
setTranslation(const nvmath::Vec3f &translation) | TextureAttributeItem |
setUserData(const void *userData) | Object | [inline]
setWrapMode(TexWrapCoordAxis target, TextureWrapMode mode) | TextureAttributeItem |
TextureAttributeItem(void) | TextureAttributeItem |
TextureAttributeItem(const Object &rhs) | TextureAttributeItem |
TextureAttributeItem(const TextureAttributeItem &rhs) | TextureAttributeItem |
validateIncarnation() const | Object | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< TextureAttributeHandle > | [protected]
~TextureAttributeItem() | TextureAttributeItem | [virtual]
Generated on Tue Jan 15 10:29:20 2008 for NVSGSDK by NVIDIA


TextureAttributeItemData Class Reference

Data of a texture attribute item that is worth sharing. More...

#include <TextureAttribute.h>

Inheritance diagram for TextureAttributeItemData:

[legend]
Collaboration diagram for TextureAttributeItemData:

[legend]
List of all members.

Public Member Functions

NVSG_API TextureAttributeItemData (const TextureAttributeItemData &rhs)
Copy constructor.

Detailed Description

Data of a texture attribute item that is worth sharing.

Constructor & Destructor Documentation

NVSG_API TextureAttributeItemData ( const TextureAttributeItemData & rhs )

Copy constructor.

Initialize a new copy from rhs

The documentation for this class was generated from the following file:
  • TextureAttribute.h
Generated on Tue Jan 15 10:29:19 2008 for NVSGSDK by NVIDIA


Member List

TextureAttributeItemData Member List

This is the complete list of members for TextureAttributeItemData, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
TextureAttributeItemData(const TextureAttributeItemData &rhs) | TextureAttributeItemData |
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:19 2008 for NVSGSDK by NVIDIA


TextureImage Class Reference

A texture image abstraction class. More...

#include <TextureImage.h>

Inheritance diagram for TextureImage:

[legend]
List of all members.

Public Types

enum TextureGPUFormat {
TGF_DEFAULT, TGF_FIXED, TGF_FLOAT, TGF_NONLINEAR,
TGF_INTEGER, TGF_COMPRESSED_FIXED, TGF_FLOAT16, TGF_FLOAT32,
TGF_FIXED8, TGF_FIXED10, TGF_FIXED16, TGF_ALPHA8,
TGF_ALPHA16, TGF_SIGNED_ALPHA8, TGF_SIGNED_ALPHA16, TGF_LUMINANCE8,
TGF_LUMINANCE16, TGF_SIGNED_LUMINANCE8, TGF_SIGNED_LUMINANCE16, TGF_LUMINANCE8_ALPHA8,
TGF_LUMINANCE16_ALPHA16, TGF_SIGNED_LUMINANCE8_ALPHA8, TGF_SIGNED_LUMINANCE16_ALPHA16, TGF_COMPRESSED_LUMINANCE,
TGF_COMPRESSED_LUMINANCE_ALPHA, TGF_COMPRESSED_LUMINANCE_LATC, TGF_SIGNED_COMPRESSED_LUMINANCE_LATC, TGF_COMPRESSED_LUMINANCE_ALPHA_LATC,
TGF_SIGNED_COMPRESSED_LUMINANCE_ALPHA_LATC, TGF_COMPRESSED_RED_RGTC, TGF_SIGNED_COMPRESSED_RED_RGTC, TGF_COMPRESSED_RG_RGTC,
TGF_SIGNED_COMPRESSED_RG_RGTC, TGF_RGB8, TGF_SIGNED_RGB8, TGF_RGB16,
TGF_RGBA8, TGF_SIGNED_RGBA8, TGF_RGB10, TGF_RGB10_A2,
TGF_RGBA16, TGF_SRGB, TGF_SRGBA, TGF_COMPRESSED_SRGB,
TGF_COMPRESSED_SRGBA, TGF_COMPRESSED_SRGB_DXT1, TGF_COMPRESSED_SRGB_DXT3, TGF_COMPRESSED_SRGB_DXT5,
TGF_COMPRESSED_SRGBA_DXT1, TGF_COMPRESSED_RGB, TGF_COMPRESSED_RGBA, TGF_COMPRESSED_RGB_DXT1,
TGF_COMPRESSED_RGB_DXT3, TGF_COMPRESSED_RGB_DXT5, TGF_COMPRESSED_RGBA_DXT1, TGF_DEPTH16,
TGF_DEPTH24, TGF_DEPTH32, TGF_DEPTH24_STENCIL8, TGF_LUMINANCE16F,
TGF_LUMINANCE32F, TGF_LUMINANCE_ALPHA16F, TGF_LUMINANCE_ALPHA32F, TGF_RGB16F,
TGF_RGB32F, TGF_RGBA16F, TGF_RGBA32F, TGF_SIGNED_RGB_INTEGER32,
TGF_SIGNED_RGB_INTEGER16, TGF_SIGNED_RGB_INTEGER8, TGF_RGB_INTEGER32, TGF_RGB_INTEGER16,
TGF_RGB_INTEGER8, TGF_SIGNED_RGBA_INTEGER32, TGF_SIGNED_RGBA_INTEGER16, TGF_SIGNED_RGBA_INTEGER8,
TGF_RGBA_INTEGER32, TGF_RGBA_INTEGER16, TGF_RGBA_INTEGER8, TGF_SIGNED_LUMINANCE_INTEGER32,
TGF_SIGNED_LUMINANCE_INTEGER16, TGF_SIGNED_LUMINANCE_INTEGER8, TGF_LUMINANCE_INTEGER32, TGF_LUMINANCE_INTEGER16,
TGF_LUMINANCE_INTEGER8, TGF_SIGNED_LUMINANCE_ALPHA_INTEGER32, TGF_SIGNED_LUMINANCE_ALPHA_INTEGER16, TGF_SIGNED_LUMINANCE_ALPHA_INTEGER8,
TGF_LUMINANCE_ALPHA_INTEGER32, TGF_LUMINANCE_ALPHA_INTEGER16, TGF_LUMINANCE_ALPHA_INTEGER8, TGF_UNSIGNED_FLOAT_SHARED_EXPONENT,
TGF_UNSIGNED_FLOAT_PACKED
}
Enumeration type to describe the format of the data when it is resident. More...

enum {
F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD = BIT0, F_IMAGE_STREAM = BIT2, F_NO_IMAGE_CREATION = BIT4, F_SCALE_FILTER_BOX = 0,
F_SCALE_FILTER_TRIANGLE = BIT7, F_SCALE_FILTER_BELL = BIT8, F_SCALE_FILTER_BSPLINE = BIT7 | BIT8, F_SCALE_FILTER_LANCZOS3 = BIT9,
F_SCALE_FILTER_MASK = BIT7 | BIT8 | BIT9, F_SCALE_POT_NEAREST = 0, F_SCALE_POT_ABOVE = BIT16, F_SCALE_POT_BELOW = BIT17,
F_SCALE_POT_MASK = F_SCALE_POT_ABOVE | F_SCALE_POT_BELOW
}
Flags considered for image processing. More...

Public Member Functions

NVSG_API | TextureImage ()
Default-constructs a TextureImage. A default created TextureImage uses a triangle filter for scaling and mipmap creation. Image data later specified through createImage will be copied to the internal data structures and released after image upload.

NVSG_API | TextureImage (const TextureImage &)
Constructs a TextureImage as a copy of another TextureImage.

virtual NVSG_API | ~TextureImage ()
NVSG_API void | setCreationFlags (unsigned int flags)
Sets creation flags to consider for further image processing.

NVSG_API void | setTextureGPUFormat (TextureGPUFormat fmt)
Sets the textures GPU, or internal, format.

NVSG_API TextureGPUFormat | getTextureGPUFormat (void) const
Gets the textures GPU, or internal, format.

NVSG_API const std::string & | getFileName () const
Returns the name of the file from which the TextureImage was created.

NVSG_API unsigned int | createImage (unsigned int width, unsigned int height, unsigned int depth, Image::PixelFormat format, Image::PixelDataType type, const void *pixels, const std::vector< const void * > &mipmaps=std::vector< const void * >())
Creates an image.

NVSG_API unsigned int | addImage (unsigned int width, unsigned int height, unsigned int depth, Image::PixelFormat format, Image::PixelDataType type)
Add an Image structure without pixel data to the TextureImage.

NVSG_API void | setImageData (unsigned int image, const void *pixels, const std::vector< const void * > &mipmaps=std::vector< const void * >())
Set the pixel data of an Image.

NVSG_API void | releaseImagePixels ()
Releases all contained image data. Release the memory used for the image pixels.

NVSG_API bool | reloadImagePixels ()
Reload the TextureImage.

NVSG_API void | incrementMipmapUseCount ()
Increments (increases by one) the mipmap use count The function increments the mipmap use count for this Texture image by one.

NVSG_API void | decrementMipmapUseCount ()
Decrements (decreases by one) the mipmap use count The function increments the mipmap use count for this Texture image by one.

NVSG_API unsigned int | getMipmapUseCount () const
Returns the actual mipmap use count.

NVSG_API bool | createMipmaps ()
Create all mipmap levels for all included images.

NVSG_API unsigned int | getNumberOfImages () const
Get the number of Images of the TextureImage (e.g. 6 for cubemaps).

NVSG_API unsigned int | getNumberOfMipmaps (unsigned int image=0) const
Get the number of mipmap levels for the specified image.

NVSG_API Image::PixelFormat | getFormat (unsigned int image=0, unsigned int mipmap=0) const
Returns the PixelFormat of the specified mipmap level for a given image.

NVSG_API Image::PixelDataType | getType (unsigned int image=0, unsigned int mipmap=0) const
Returns the PixelDataType of the specified image.

NVSG_API unsigned int | getWidth (unsigned int image=0, unsigned int mipmap=0) const
Get the width of the specified image in pixels.

NVSG_API unsigned int | getHeight (unsigned int image=0, unsigned int mipmap=0) const
Get the height of the specified image in pixels.

NVSG_API unsigned int | getDepth (unsigned int image=0, unsigned int mipmap=0) const
Get the depth of the specified image in pixels.

NVSG_API unsigned int | getBytesPerPixel (unsigned int image=0, unsigned int mipmap=0) const
Returns the number of bytes per pixel of the specified mipmap.

NVSG_API unsigned int | getBytesPerScanLine (unsigned int image=0, unsigned int mipmap=0) const
Get the number of bytes per line of the specified mipmap level of the specified image.

NVSG_API unsigned int | getBytesPerPlane (unsigned int image=0, unsigned int mipmap=0) const
Get the number of bytes per plane (slice) of the specified mipmap level of the specified image.

NVSG_API unsigned int | getNumberOfBytes (unsigned int image=0, unsigned int mipmap=0) const
Get the number of bytes of the specified mipmap level of the specified image.

NVSG_API unsigned int | getTotalNumberOfBytes () const
Returns the number of bytes used for all included images and mipmap levels.

NVSG_API const void * | getPixels (unsigned int image=0, unsigned int mipmap=0) const
Returns a pointer to the raw pixel data of the specified mipmap.

NVSG_API bool | getSubImagePixels (unsigned int image, unsigned int mipmap, unsigned int x_offset, unsigned int y_offset, unsigned int z_offset, unsigned int width, unsigned int height, unsigned int depth, void *subPixels) const
getSubImagePixels copies a portion of an existing 1-, 2-, or 3-dimensional image.

NVSG_API bool | setSubImagePixels (unsigned int image, unsigned int mipmap, unsigned int x_offset, unsigned int y_offset, unsigned int z_offset, unsigned int width, unsigned int height, unsigned int depth, const void *subPixels)
setSubImagePixels sets a portion of an existing 1-, 2-, or 3-dimensional image.

NVSG_API unsigned int | getUnpackAlignment () const
Returns the alignment for the start of each pixel row in memory.

NVSG_API bool | scale (unsigned int image, unsigned int width, unsigned int height=1, unsigned int depth=1)
Scale the specified image.

NVSG_API bool | convertPixelFormat (Image::PixelFormat newFormat)
the new pixel format.

NVSG_API bool | scaleToPowerOfTwo (unsigned int sizeLimit)
Scales containing images to power-of-two.

NVSG_API bool | is1D () const
Returns whether the texture image represents a 1-dimensional texture image.

NVSG_API bool | is2D () const
Returns whether the texture image represents a 2-dimensional texture image.

NVSG_API bool | is2DArray () const
Returns whether the texture image represents a 2-dimensional texture image array.

NVSG_API bool | is1DArray () const
Returns whether the texture image represents a 1-dimensional texture image array.

NVSG_API bool | is3D () const
Returns whether the texture image represents a 3-dimensional texture image.

NVSG_API bool | isCubeMap () const
Returns whether the texture image represents a cube map.

NVSG_API bool | isFloatingPoint () const
Returns whether the texture image represents a floating point texture image.

NVSG_API bool | isFixedPoint () const
Returns whether the texture image represents a fixed point texture image.

NVSG_API bool | isCompressed () const
Returns whether the texture image represents a compressed texture image.

NVSG_API bool | isImageStream () const
Returns whether the texture image is treated as an image stream.

NVSG_API void | convert2DToCubeMap ()
Will convert a 2D image to 6 cubemap faces.

NVSG_API void | demandUpload ()
Forces a re-upload of the texture image.

NVSG_API bool | isUploadDemanded () const
Returns whether a re-upload of the texture image is required.

NVSG_API void | finishUpload ()
Finishes an image upload.

NVSG_API unsigned int | getCreationFlags () const
Returns the creation flag status of the TextureImage object.

NVSG_API TextureImage & | operator= (const TextureImage &rhs)
Assigns new contents to a TextureImage object.

NVSG_API void | mirrorX (unsigned int image)
Mirror the image over the x-axis.

NVSG_API void | mirrorY (unsigned int image)
Mirror the image over the y-axis.

Static Public Member Functions

NVSG_API TextureImageHandle * | createFromFile (const std::string &filename, const std::vector< std::string > &searchPaths, unsigned int creationFlags=0)
Instantiates a TextureImage object filled with image data loaded from a file.

Detailed Description

A texture image abstraction class.

Member Enumeration Documentation

enum TextureGPUFormat

Enumeration type to describe the format of the data when it is resident.

anonymous enum

Flags considered for image processing.

Enumeration values:
F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD | Serves as a hint to the upload code to keep the image data in process memory even after image upload.
F_IMAGE_STREAM | Forces the image to be treated as an image stream, that is, no pixel data will be copied to internal structures.
F_NO_IMAGE_CREATION | Only create the information data for this TextureImage, don't load the texture data.
F_SCALE_FILTER_BOX | scale the image with a box filter (nearest)
F_SCALE_FILTER_TRIANGLE | scale the image with a triangle filter (linear)
F_SCALE_FILTER_BELL | scale the image with a bell filter
F_SCALE_FILTER_BSPLINE | scale the image with a bspline filter
F_SCALE_FILTER_LANCZOS3 | scale the image with a lanczos3 filter
F_SCALE_POT_NEAREST | always scale to nearest power of two if scaling is required (default)
F_SCALE_POT_ABOVE | always scale to the next power of two if scaling is required
F_SCALE_POT_BELOW | always scale to the highest power of two below if scaling is required

Constructor & Destructor Documentation

NVSG_API TextureImage ( )

Default-constructs a TextureImage. A default created TextureImage uses a triangle filter for scaling and mipmap creation. Image data later specified through createImage will be copied to the internal data structures and released after image upload.

NVSG_API TextureImage ( const TextureImage & )

Constructs a TextureImage as a copy of another TextureImage.

virtual NVSG_API ~TextureImage ( ) [virtual]

Destructs a TextureImage

Member Function Documentation

NVSG_API TextureImageHandle* createFromFile | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | unsigned int | creationFlags = 0
 | ) | [static]

Instantiates a TextureImage object filled with image data loaded from a file.

Parameters:
filename | Specifies the name of the file to load the image data from.
searchPaths | Paths to search for the file.
creationFlags | Optional creation flags.
Returns:
The function returns a pointer to a valid TextureImageHandle if succeeded. Otherwise a null pointer will be returned.
Remarks:
The function instantiates a TextureImage object and initializes it with image data loaded from the file specified by filename.
The actual image loading will be performed through PlugIns, thus the available PlugIns determine which image formats are supported for loading. By default, NVSG will look for TextureLoader PlugIns inside the application directory. Use addPlugInSearchPath() to specify additional directories, if your loader PlugIns lie somewhere else.

Client code may provide optional creation flags:

Specify the F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD to give a hint to the upload code to keep the image data in process memory even after image upload.

NVSG_API void setCreationFlags ( unsigned int flags )

Sets creation flags to consider for further image processing.

Parameters:
flags Creation flags to consider for further image processing.
Remarks:

This function lets you specify certain creation flags which affect subsequent image processing.
Possible creation flags are:
F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD
F_NO_SCALING
F_IMAGE_STREAM
F_SCALE_FILTER_BOX
F_SCALE_FILTER_BELL
F_SCALE_FILTER_BSPLINE
F_SCALE_FILTER_LANCZOS3
F_SCALE_FILTER_MASK

void setTextureGPUFormat ( TextureGPUFormat fmt ) [inline]

Sets the textures GPU, or internal, format.

This method sets flags that request that the image be converted to a particular format when uploaded to the GPU. Compressed formats can be selected through this method, and Integer formats can be selected by this method as well. The default is TGF_DEFAULT which is OpenGL's default of using either fixed or floating point format for textures, using the same methods that were used in previous versions of NVSG. Please see the extended documentation for those defaults.

Parameters:
fmt The format from the TextureGPUFormat enum to use.
Remarks:
This is a suggestion only - the GPU is free to use a compatible format if the requested format is not available.
See also:
TextureImage::TextureGPUFormat, TextureImage::getTextureGPUFormat

TextureImage::TextureGPUFormat getTextureGPUFormat ( void ) const [inline]

Gets the textures GPU, or internal, format.

This method returns the GPU format that was requested by the user.

Remarks:
Note that this is not necessarily the format that the texture will reside in on the GPU, just what the users selection was.
See also:
TextureImage::TextureGPUFormat, TextureImage::setTextureGPUFormat

const std::string & getFileName ( ) const [inline]

Returns the name of the file from which the TextureImage was created.

Returns:
The function returns the name of the file from which the TextureImage was created. If the TextureImage was not created from a file, an empty string will be returned.
See also:
createFromFile, createImage

NVSG_API unsigned int createImage | ( | unsigned int | width,
 |  | unsigned int | height,
 |  | unsigned int | depth,
 |  | Image::PixelFormat | format,
 |  | Image::PixelDataType | type,
 |  | const void * | pixels,
 |  | const std::vector< const void * > & | mipmaps = std::vector< const void * >()
 | ) |

Creates an image.

Use this function to create a single image of the specified dimensions, pixel format, and pixel data type.

If the F_IMAGE_STREAM flag was not specified at object instantiation, the pixel data pointed to by pixels will be copied to the internal data structures. If, on the other hand, the F_IMAGE_STREAM flag was specified at object instantiation, no pixel data will be copied to the internal structures but only the address specified by pixels will be stored. The image will be treated as an image stream in the latter case.

Note, that the pixel data pointed to by pixels always must match the specified dimensions, pixel format, and data type. Otherwise this would result in undefined behavior.

The behavior also is undefined if an invalid pointer will be passed through pixels.

In addition to the level 0 image, additional mipmap levels can be specified through createImage. The user can do so by passing the pointers to the raw pixel data of the additional mipmap levels through mipmaps. If an incomplete mipmap chain is specified, the missing levels are added using the current filter settings. Note that, specifying an incomplete chain with F_IMAGE_STREAM set is an error; no mipmaps are created in this case.

The passed mipmap levels are assumed to be sorted from level 1 to level n. The dimensions of the mipmaps are assumed to be according to the particular level, that is - level 1 mipmap is assumed of dimension (with(level 0) / 2) x (height(level 0) / 2) x (depth(level 0)/2) pixel, level 2 mipmap is assumed of dimension (with(level 1) / 2) x (height(level 1) / 2) x (depth(level 1)/2) pixels, and so on, down to 1 x 1 x 1 pixels for the last level.

The additional mipmap levels are assumed to have the same bytes per pixel as the level 0 image. The additional mipmap levels are also assumed to be of the same pixel format, and data type as the level 0 image.

Returns:
The zero based index of the image if creation was successful. Otherwise the function returns -1 indicating that the image creation failed.
See also:
Image
Parameters:
width | width in pixels
height | height in pixels
depth | depth in pixels
format | format of image data
type | type of image data
pixels | raw pixel data
mipmaps | !< additional mipmap levels (optional)

NVSG_API unsigned int addImage | ( | unsigned int | width,
 |  | unsigned int | height,
 |  | unsigned int | depth,
 |  | Image::PixelFormat | format,
 |  | Image::PixelDataType | type
 | ) |

Add an Image structure without pixel data to the TextureImage.

Parameters:
width | The width of the Image to add.
height | The height of the Image to add.
depth | The depth of the Image to add.
format | The PixelFormat of the Image to add.
type | The PixelDataType of the Image to add.
Returns:
The index of the Image in this TextureImage.
Remarks:
This function adds an Image structure to the TextureImage, but does not allocate memory for the pixel data.
See also:
createImage, setImageData, Image

NVSG_API void setImageData | ( | unsigned int | image,
 |  | const void * | pixels,
 |  | const std::vector< const void * > & | mipmaps = std::vector< const void * >()
 | ) |

Set the pixel data of an Image.

Parameters:
image | The index of the Image to set the data.
pixels | A pointer to the pixel data to set.
mipmaps | An optional vector of pointers to pixel data for the mipmaps.
Remarks:
If the TextureImage is a streaming image (F_IMAGE_STREAM is set), the pointer to the pixel data of the Image at index image just points to pixels. Any data in mipmaps is ignored then.
Otherwise the memory for the pixels are allocated if needed and copied to the Image at index image. If there are mipmaps provided, the data is also copied.
Note:
The behavior is undefined if image is greater or equal to the number of images in this TextureImage. Furthermore, it is assumed that pixels point to memory that is large enough to hold the complete data of the Image. If mipmaps are provided, it is assumed that each of the pointers in mipmaps point to memory that is large enough to hold the complete data of the corresponding mipmap level of the Image. If an incomplete mipmap chain is specified, the missing levels are added using the current filter settings. Note that, specifying an incomplete chain with F_IMAGE_STREAM set is an error; no mipmaps are created in this case.
See also:
createImage, addImage, Image

NVSG_API void releaseImagePixels ( )

Releases all contained image data. Release the memory used for the image pixels.

Remarks:
The function frees all image pixels of the TextureImage. Only size and format informations are kept.
See also:
reloadImagePixels

NVSG_API bool reloadImagePixels ( )

Reload the TextureImage.

Returns:
true if the images could be reloaded, otherwise false.
Remarks:
If for example the images data has been release at some point, it can be reloaded using this function.
See also:
load, releaseImagePixels

NVSG_API void incrementMipmapUseCount ( )

Increments (increases by one) the mipmap use count The function increments the mipmap use count for this Texture image by one.

This function should be called by the client whenever the corresponding minification filter settings change from a non-mipmap filter mode to a mipmap filter mode.

The function serves sharing of this TextureImage between multiple clients that probably have different corresponding minification filter settings. Mipmaps are required if at least one client has mipmap filtering on.

See also:
decrementMipmapUseCount, getMipmapUseCount

NVSG_API void decrementMipmapUseCount ( )

Decrements (decreases by one) the mipmap use count The function increments the mipmap use count for this Texture image by one.

This function should be called by the client whenever the corresponding minification filter settings change from a mipmap filter mode to a non-mipmap filter mode.

If at upload time the mipmap use count is zero, no mipmap generation will be forced, nor will existing mipmaps be uploaded to the graphics hardware.

See also:
incrementMipmapUseCount, getMipmapUseCount

unsigned int getMipmapUseCount ( ) const [inline]

Returns the actual mipmap use count.

Returns:
The function returns the actual mipmap use count for this TextureImage. If the mipmap use count is non-zero, at least one client has corresponding minification filter settings that require mipmaps to be generated and uploaded for this TextureImage. Upload code should evaluate this count for conditional mipmap creation and upload. Mipmap creation, if required, can be performed by calling createMipmaps.
See also:
incrementMipmapUseCount, decrementMipmapUseCount, createMipmaps

NVSG_API bool createMipmaps ( )

Create all mipmap levels for all included images.

Returns:
true if all levels have been created successfully, false otherwise.
Remarks:
This function explicitly creates all mipmap levels for all images included. Previously created levels will be released.
Note:
The behavior is undefined if any of the images is not a power-of-two image or if any of the images has overlaps.

unsigned int getNumberOfImages ( ) const [inline]

Get the number of Images of the TextureImage (e.g. 6 for cubemaps).

Returns:
The number of images of the corresponding TextureImage.
See also:
getNumberOfMipmaps

unsigned int getNumberOfMipmaps ( unsigned int image = 0 ) const [inline]

Get the number of mipmap levels for the specified image.

Parameters:
image An optional index of the image to get the number of mipmap levels for.
Returns:
The number of mipmap levels of the image.
Note:
The behavior is undefined if image is larger than or equal to the number of images this TextureImage holds.
See also:
getNumberOfImages
Parameters:
image Zero-based image index.

Image::PixelFormat getFormat | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Returns the PixelFormat of the specified mipmap level for a given image.

The function returns the PixelFormat of the pixel data stored at mipmap level mipmap of the image specified by image. See the PixelFormat enumeration type for known pixel formats. A mipmap level of 0 always identifies the image itself.

Passing an invalid image index as well as an invalid mipmap level results in undefined behavior! A valid image index ranges from 0 to getNumberOfImages()-1. A valid mipmap level ranges from 0 to getNumberOfMipmaps(image)-1.

Returns:
A PixelFormat enum specifying the pixel format.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

Image::PixelDataType getType | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Returns the PixelDataType of the specified image.

The function returns the PixelDataType of the pixel data stored at mipmap level mipmap of the image specified by image. See the PixelDataType enumeration type for known types. A mipmap level of 0 always identifies the image itself.

Passing an invalid image index as well as an invalid mipmap level results in undefined behavior! A valid image index ranges from 0 to getNumberOfImages()-1. A valid mipmap level ranges from 0 to getNumberOfMipmaps(image)-1.

Returns:
A PixelDataType enum specifying the pixel data type.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

unsigned int getWidth | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Get the width of the specified image in pixels.

Parameters:
image | Optional index of the image to get width of. Default is zero.
mipmap | Optional index of the mipmap level of the specified image to get width of. Default is zero, that is the top level image.
Returns:
The width of the specified image in pixels.
Note:
The behavior is undefined if image is larger or equal to the number of images in this TextureImage, or if mipmap is larger or equal to the number of mipmap levels of the specified image.

The returned value is the width over the complete image, including overlaps.

See also:
getHeight, getDepth, getOverlapSize

unsigned int getHeight | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Get the height of the specified image in pixels.

Parameters:
image | Optional index of the image to get width of. Default is zero.
mipmap | Optional index of the mipmap level of the specified image to get width of. Default is zero, that is the top level image.
Returns:
The height of the specified image in pixels.
Note:
The behavior is undefined if image is larger or equal to the number of images in this TextureImage, or if mipmap is larger or equal to the number of mipmap levels of the specified image.

The returned value is the height over the complete image, including overlaps.

See also:
getWidth, getDepth, getOverlapSize

unsigned int getDepth | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Get the depth of the specified image in pixels.

Parameters:
image | Optional index of the image to get width of. Default is zero.
mipmap | Optional index of the mipmap level of the specified image to get width of. Default is zero, that is the top level image.
Returns:
The depth of the specified image in pixels.
Note:
The behavior is undefined if image is larger or equal to the number of images in this TextureImage, or if mipmap is larger or equal to the number of mipmap levels of the specified image.

The returned value is the depth over the complete image, including overlaps.

See also:
getWidth, getHeight, getOverlapSize

unsigned int getBytesPerPixel | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Returns the number of bytes per pixel of the specified mipmap.

The function returns the number of bytes per pixel of the mipmap at level mipmap of the image specified by image. A mipmap level of 0 always identifies the image itself.

Passing an invalid image index as well as an invalid mipmap level results in undefined behavior! A valid image index ranges from 0 to getNumberOfImages()-1. A valid mipmap level ranges from 0 to getNumberOfMipmaps(image)-1.

Returns:
The number of bytes per pixel of the specified mipmap.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

unsigned int getBytesPerScanLine | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Get the number of bytes per line of the specified mipmap level of the specified image.

Parameters:
image | An optional index of the image to get information from. The default value is zero.
mipmap | An optional index of the mipmap level to get information from. The default value is zero.
Returns:
The number of bytes per line of the Image at mipmap level mipmap at the index image.
Remarks:
A mipmap level of zero identifies the image itself.
Note:
The behavior is undefined if image is larger than or equal to the number of images or if mipmap is larger than or equal to the number of mipmap levels of the Image image this TextureImage holds information for.
See also:
getNumberOfImages, getNumberOfMipmaps, getBytesPerPixel, getBytesPerPlane, getNumberOfBytes

unsigned int getBytesPerPlane | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Get the number of bytes per plane (slice) of the specified mipmap level of the specified image.

Parameters:
image | An optional index of the image to get information from. The default value is zero.
mipmap | An optional index of the mipmap level to get information from. The default value is zero.
Returns:
The number of bytes per plane (slice) of the Image at mipmap level mipmap at the index image.
Remarks:
A mipmap level of zero identifies the image itself.
Note:
The behavior is undefined if image is larger than or equal to the number of images or if mipmap is larger than or equal to the number of mipmap levels of the Image image this TextureImage holds information for.
See also:
getNumberOfImages, getNumberOfMipmaps, getBytesPerPixel, getBytesPerScanLine, getNumberOfBytes

unsigned int getNumberOfBytes | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Get the number of bytes of the specified mipmap level of the specified image.

Parameters:
image | An optional index of the image to get information from. The default value is zero.
mipmap | An optional index of the mipmap level to get information from. The default value is zero.
Returns:
The number of bytes of the Image at mipmap level mipmap at the index image.
Remarks:
A mipmap level of zero identifies the image itself.
Note:
The behavior is undefined if image is larger than or equal to the number of images or if mipmap is larger than or equal to the number of mipmap levels of the Image image this TextureImage holds information for.
See also:
getNumberOfImages, getNumberOfMipmaps, getBytesPerPixel, getBytesPerScanLine, getBytesPerPlane

unsigned int getTotalNumberOfBytes ( ) const [inline]

Returns the number of bytes used for all included images and mipmap levels.

Returns:
The number of bytes used for all included images and mipmap levels.

const void * getPixels | ( | unsigned int | image = 0,
 |  | unsigned int | mipmap = 0
 | ) | const [inline]

Returns a pointer to the raw pixel data of the specified mipmap.

The function returns a pointer to the raw pixel data of the mipmap at level mipmap of the image specified by image. A mipmap level of 0 always identifies the image itself.

Passing an invalid image index as well as an invalid mipmap level results in undefined behavior! A valid image index ranges from 0 to getNumberOfImages()-1. A valid mipmap level ranges from 0 to getNumberOfMipmaps(image)-1.

Returns:
A pointer to the raw pixel data of the specified mipmap.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

NVSG_API bool getSubImagePixels | ( | unsigned int | image,
 |  | unsigned int | mipmap,
 |  | unsigned int | x_offset,
 |  | unsigned int | y_offset,
 |  | unsigned int | z_offset,
 |  | unsigned int | width,
 |  | unsigned int | height,
 |  | unsigned int | depth,
 |  | void * | subPixels
 | ) | const

getSubImagePixels copies a portion of an existing 1-, 2-, or 3-dimensional image.

Parameters:
image | Index into vector of images.
mipmap | Zero-based mipmap level
x_offset | Pixel offset in the x direction of the image
y_offset | Pixel offset in the y direction of the image
z_offset | Pixel offset in the z direction of the image
width | Width of the sub image
height | Height of the sub image
depth | Depth of the sub image
subPixels | Target address to copy data to.
Returns:
The function returns true on success. Otherwise it returns false (for example if the image does not exist (e.g. after upload), or if the sub image boundary exceeds the existing image)
Remarks:
The function copies width x height x depth x getBytesPerPixel() raw pixel data from the specified offset of the existing image to the buffer pointed to by subPixels.

The user is responsible for providing a buffer large enough to hold the requested data.
See also:
setSubImagePixels

NVSG_API bool setSubImagePixels | ( | unsigned int | image,
 |  | unsigned int | mipmap,
 |  | unsigned int | x_offset,
 |  | unsigned int | y_offset,
 |  | unsigned int | z_offset,
 |  | unsigned int | width,
 |  | unsigned int | height,
 |  | unsigned int | depth,
 |  | const void * | subPixels
 | ) |

setSubImagePixels sets a portion of an existing 1-, 2-, or 3-dimensional image.

Parameters:
image | Index into vector of images
mipmap | Zero-based mipmap level
x_offset | Pixel offset in the x direction of the image
y_offset | Pixel offset in the y direction of the image
z_offset | Pixel offset in the z direction of the image
width | Width of the sub image
height | Height of the sub image
depth | Depth of the sub image
subPixels | Source address to copy data from.
Returns:
The function returns true on success. Otherwise it returns false (for example if the image does not exist (e.g. after upload), or if the sub image boundary exceeds the existing image)
Remarks:
The function sets width x height x depth x getBytesPerPixel() pixel data from the specified offset of the existing image to that of the raw data in the buffer pointed to by subPixels.

The PixelDataType of the data pointed to by subPixels must match the PixelDataType of the existing image. Behavior would be undefined otherwise.
See also:
getSubImagePixels

unsigned int getUnpackAlignment ( ) const [inline]

Returns the alignment for the start of each pixel row in memory.

NVSG_API bool scale | ( | unsigned int | image,
 |  | unsigned int | width,
 |  | unsigned int | height = 1,
 |  | unsigned int | depth = 1
 | ) |

Scale the specified image.

Parameters:
image | The index of the image to scale.
width | The desired width of the scaled image.
height | The optional height of the scaled image. The default is 1.
depth | The optional depth of the scaled image. The default is 1.
Returns:
true if the scaling was successful, false otherwise.
Remarks:
The function scales the image specified by image according to the input dimensions passed. The filter to use is specified by the creation flags.
Note:
The behavior is undefined if image is larger than or equal to the number of images in this TextureImage, of if that image has overlaps.
Parameters:
image | Zero-based index of the image to scale.
width | Desired width of the scaled image.
height | Desired height of the scaled image.
depth | Desired depth of the scaled image.

NVSG_API bool convertPixelFormat ( Image::PixelFormat newFormat )

the new pixel format.

Parameters:
newFormat The new pixel format for the entire TextureImage.
Remarks:
This function changes the pixel format of all images and all mipmaps contained in this TextureImage to the format supplied. If a format that doesn't contain an alpha channel is converted to one that does (ie: RGB -> BGRA) then the alpha channel is set to 0xff.

NVSG_API bool scaleToPowerOfTwo ( unsigned int sizeLimit )

Scales containing images to power-of-two.

Parameters:
sizeLimit Specifies the platform dependent size limit that must not be exceeded during scaling.
Returns:
true if scaling was successful, false otherwise.
The function scales all containing images to become power of two in each dimension. By default, the function always scales to the nearest power of two. This behavior can be changed by specifying a certain creation flag at TextureImage instantiation. If you specified F_SCALE_POT_BELOW, the single dimensions will always be scaled down to the highest power of two below the actual size. If you specified F_SCALE_POT_ABOVE, the single dimensions always will be scaled up to the very next power of two. If both flags were specified at instantiation, the function falls back to the default algorithm. Independent of the algorithm used for scaling, the function always clamps each dimension to the specified sizeLimit.

The behavior is undefined if called for a TextureImage that was instantiated with the F_IMAGE_STREAM flag specified. The behavior also is undefined if called for a TextureImage that does not contain any images or for which all images already have been released (e.g. after upload).

Note:
If the scaling failed, the function left behind the pixel data of containing images undefined!

bool is1D ( ) const [inline]

Returns whether the texture image represents a 1-dimensional texture image.

Returns:
true if the texture image represents a 1-dimensional texture image, false otherwise.

bool is2D ( ) const [inline]

Returns whether the texture image represents a 2-dimensional texture image.

Returns:
true if the texture image represents a 2-dimensional texture image, false otherwise.

bool is2DArray ( ) const [inline]

Returns whether the texture image represents a 2-dimensional texture image array.

Returns:
true if the texture image represents a 2-dimensional texture image array, false otherwise.

bool is1DArray ( ) const [inline]

Returns whether the texture image represents a 1-dimensional texture image array.

Returns:
true if the texture image represents a 1-dimensional texture image array, false otherwise.

bool is3D ( ) const [inline]

Returns whether the texture image represents a 3-dimensional texture image.

Returns:
true if the texture image represents a 3-dimensional texture image, false otherwise.

bool isCubeMap ( ) const [inline]

Returns whether the texture image represents a cube map.

A cube map consists of 6 images of dimension 2. /**

Returns:
true if the texture image represents a cube map, false otherwise.

NVSG_API bool isFloatingPoint ( ) const

Returns whether the texture image represents a floating point texture image.

Returns:
true if the texture image represents a floating point texture image, false otherwise.

NVSG_API bool isFixedPoint ( ) const

Returns whether the texture image represents a fixed point texture image.

Returns:
true if the texture image represents a fixed point texture image, false otherwise.

NVSG_API bool isCompressed ( ) const

Returns whether the texture image represents a compressed texture image.

Returns:
true if the texture image represents a compressed texture image, false otherwise.

bool isImageStream ( ) const [inline]

Returns whether the texture image is treated as an image stream.

Image streams are images for which the image data is not managed inside the TextureImage object.

Returns:
true if the image is treated as a image stream, false otherwise.

NVSG_API void convert2DToCubeMap ( )

Will convert a 2D image to 6 cubemap faces.

The 2D image must contain all faces in the vertical cross format, as it can be exported e.g. from HDRShop. Thus, the height of the 2D image must be 4/3 of the width. This function does not work with image streams.

void demandUpload ( ) [inline]

Forces a re-upload of the texture image.

The function marks the texture image as outdated, and hence, forces a re-upload with the very next render step.

The function in particular is useful for stream images, that is - images for which the image data is not managed inside the TextureImage object. For these kind of images the TextureImage object does not automatically realize any changes made to the image data but needs a hint from the user. Whenever the image data have changed and, as a consequence, a re-upload of the texture image is required, the user should call demandUpload to force the re-upload with the very next render step.

Note, that a re-upload of the texture image will not allocate a new platform dependent texture resource object but will reuse the former resource.

bool isUploadDemanded ( ) const [inline]

Returns whether a re-upload of the texture image is required.

Returns:
true if a re-upload is required, false otherwise.

NVSG_API void finishUpload ( )

Finishes an image upload.

The function should be called after the image upload succeed. It marks the image as being uploaded. If neither the F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD nor the F_IMAGE_STREAM flag was specified at TextureImage object instantiation, the function releases all internal image data.

Note:
A re-upload is not possible after the internal image data was released.

unsigned int getCreationFlags ( ) const [inline]

Returns the creation flag status of the TextureImage object.

Returns:
An unsigned integer value representing the actual creation flag status of this object.

NVSG_API TextureImage& operator= ( const TextureImage & rhs )

Assigns new contents to a TextureImage object.

The contents of the object specified by rhs will be assigned to this object.

NVSG_API void mirrorX ( unsigned int image )

Mirror the image over the x-axis.

This is equivalent to reversing the rows, thus converting between origin upper left and lower left.

Parameters:
image Zero-based index of the image to mirror.

NVSG_API void mirrorY ( unsigned int image )

Mirror the image over the y-axis.

This is equivalent to reversing the columns.

Parameters:
image Zero-based index of the image to mirror.

The documentation for this class was generated from the following file:
  • TextureImage.h
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Member List

TextureImage Member List

This is the complete list of members for TextureImage, including all inherited members.
addImage(unsigned int width, unsigned int height, unsigned int depth, Image::PixelFormat format, Image::PixelDataType type) | TextureImage |
convert2DToCubeMap() | TextureImage |
convertPixelFormat(Image::PixelFormat newFormat) | TextureImage |
createFromFile(const std::string &filename, const std::vector< std::string > &searchPaths, unsigned int creationFlags=0) | TextureImage | [static]
createImage(unsigned int width, unsigned int height, unsigned int depth, Image::PixelFormat format, Image::PixelDataType type, const void *pixels, const std::vector< const void * > &mipmaps=std::vector< const void * >()) | TextureImage |
createMipmaps() | TextureImage |
decrementMipmapUseCount() | TextureImage |
demandUpload() | TextureImage | [inline]
F_IMAGE_STREAM enum value | TextureImage |
F_NO_IMAGE_CREATION enum value | TextureImage |
F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD enum value | TextureImage |
F_SCALE_FILTER_BELL enum value | TextureImage |
F_SCALE_FILTER_BOX enum value | TextureImage |
F_SCALE_FILTER_BSPLINE enum value | TextureImage |
F_SCALE_FILTER_LANCZOS3 enum value | TextureImage |
F_SCALE_FILTER_MASK enum value (defined in TextureImage) | TextureImage |
F_SCALE_FILTER_TRIANGLE enum value | TextureImage |
F_SCALE_POT_ABOVE enum value | TextureImage |
F_SCALE_POT_BELOW enum value | TextureImage |
F_SCALE_POT_MASK enum value (defined in TextureImage) | TextureImage |
F_SCALE_POT_NEAREST enum value | TextureImage |
finishUpload() | TextureImage |
getBytesPerPixel(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getBytesPerPlane(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getBytesPerScanLine(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getCreationFlags() const | TextureImage | [inline]
getDepth(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getFileName() const | TextureImage | [inline]
getFormat(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getHeight(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getMipmapUseCount() const | TextureImage | [inline]
getNumberOfBytes(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getNumberOfImages() const | TextureImage | [inline]
getNumberOfMipmaps(unsigned int image=0) const | TextureImage | [inline]
getPixels(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getSubImagePixels(unsigned int image, unsigned int mipmap, unsigned int x_offset, unsigned int y_offset, unsigned int z_offset, unsigned int width, unsigned int height, unsigned int depth, void *subPixels) const | TextureImage |
getTextureGPUFormat(void) const | TextureImage | [inline]
getTotalNumberOfBytes() const | TextureImage | [inline]
getType(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getUnpackAlignment() const | TextureImage | [inline]
getWidth(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
incrementMipmapUseCount() | TextureImage |
is1D() const | TextureImage | [inline]
is1DArray() const | TextureImage | [inline]
is2D() const | TextureImage | [inline]
is2DArray() const | TextureImage | [inline]
is3D() const | TextureImage | [inline]
isCompressed() const | TextureImage |
isCubeMap() const | TextureImage | [inline]
isFixedPoint() const | TextureImage |
isFloatingPoint() const | TextureImage |
isImageStream() const | TextureImage | [inline]
isUploadDemanded() const | TextureImage | [inline]
mirrorX(unsigned int image) | TextureImage |
mirrorY(unsigned int image) | TextureImage |
operator=(const TextureImage &rhs) | TextureImage |
releaseImagePixels() | TextureImage |
reloadImagePixels() | TextureImage |
scale(unsigned int image, unsigned int width, unsigned int height=1, unsigned int depth=1) | TextureImage |
scaleToPowerOfTwo(unsigned int sizeLimit) | TextureImage |
setCreationFlags(unsigned int flags) | TextureImage |
setImageData(unsigned int image, const void *pixels, const std::vector< const void * > &mipmaps=std::vector< const void * >()) | TextureImage |
setSubImagePixels(unsigned int image, unsigned int mipmap, unsigned int x_offset, unsigned int y_offset, unsigned int z_offset, unsigned int width, unsigned int height, unsigned int depth, const void *subPixels) | TextureImage |
setTextureGPUFormat(TextureGPUFormat fmt) | TextureImage | [inline]
TextureGPUFormat enum name | TextureImage |
TextureImage() | TextureImage |
TextureImage(const TextureImage &) | TextureImage |
TGF_ALPHA16 enum value (defined in TextureImage) | TextureImage |
TGF_ALPHA8 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_FIXED enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_LUMINANCE enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_LUMINANCE_ALPHA enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_LUMINANCE_ALPHA_LATC enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_LUMINANCE_LATC enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RED_RGTC enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RG_RGTC enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGB enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGB_DXT1 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGB_DXT3 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGB_DXT5 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGBA enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGBA_DXT1 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGB enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGB_DXT1 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGB_DXT3 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGB_DXT5 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGBA enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGBA_DXT1 enum value (defined in TextureImage) | TextureImage |
TGF_DEFAULT enum value (defined in TextureImage) | TextureImage |
TGF_DEPTH16 enum value (defined in TextureImage) | TextureImage |
TGF_DEPTH24 enum value (defined in TextureImage) | TextureImage |
TGF_DEPTH24_STENCIL8 enum value (defined in TextureImage) | TextureImage |
TGF_DEPTH32 enum value (defined in TextureImage) | TextureImage |
TGF_FIXED enum value (defined in TextureImage) | TextureImage |
TGF_FIXED10 enum value (defined in TextureImage) | TextureImage |
TGF_FIXED16 enum value (defined in TextureImage) | TextureImage |
TGF_FIXED8 enum value (defined in TextureImage) | TextureImage |
TGF_FLOAT enum value (defined in TextureImage) | TextureImage |
TGF_FLOAT16 enum value (defined in TextureImage) | TextureImage |
TGF_FLOAT32 enum value (defined in TextureImage) | TextureImage |
TGF_INTEGER enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE16 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE16_ALPHA16 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE16F enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE32F enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE8 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE8_ALPHA8 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA16F enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA32F enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_NONLINEAR enum value (defined in TextureImage) | TextureImage |
TGF_RGB10 enum value (defined in TextureImage) | TextureImage |
TGF_RGB10_A2 enum value (defined in TextureImage) | TextureImage |
TGF_RGB16 enum value (defined in TextureImage) | TextureImage |
TGF_RGB16F enum value (defined in TextureImage) | TextureImage |
TGF_RGB32F enum value (defined in TextureImage) | TextureImage |
TGF_RGB8 enum value (defined in TextureImage) | TextureImage |
TGF_RGB_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_RGB_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_RGB_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA16 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA16F enum value (defined in TextureImage) | TextureImage |
TGF_RGBA32F enum value (defined in TextureImage) | TextureImage |
TGF_RGBA8 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_ALPHA16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_ALPHA8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_COMPRESSED_LUMINANCE_ALPHA_LATC enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_COMPRESSED_LUMINANCE_LATC enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_COMPRESSED_RED_RGTC enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_COMPRESSED_RG_RGTC enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE16_ALPHA16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE8_ALPHA8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_ALPHA_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_ALPHA_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_ALPHA_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGB8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGB_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGB_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGB_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGBA8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGBA_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGBA_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGBA_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SRGB enum value (defined in TextureImage) | TextureImage |
TGF_SRGBA enum value (defined in TextureImage) | TextureImage |
TGF_UNSIGNED_FLOAT_PACKED enum value (defined in TextureImage) | TextureImage |
TGF_UNSIGNED_FLOAT_SHARED_EXPONENT enum value (defined in TextureImage) | TextureImage |
~TextureImage() | TextureImage | [virtual]
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


TextureLoader Class Reference

Pure virtual base class for texture loader plugins. More...

#include <PlugInterface.h>

Inheritance diagram for TextureLoader:

[legend]
Collaboration diagram for TextureLoader:

[legend]
List of all members.

Public Member Functions

NVSG_API TextureImageHandle * | load (const std::string &filename, const std::vector< std::string > &searchPaths=std::vector< std::string >(), const unsigned int &creationFlags=0)
Function to load a TextureImage.

NVSG_API bool | reload (TextureImageHandle *tih, const std::vector< std::string > &searchPaths=std::vector< std::string >())
Function to reload a TextureImage.

Protected Member Functions

virtual NVSG_API | ~TextureLoader ()
Protected virtual destructor.

virtual NVSG_API TextureImageHandle * | createTextureImageHandle ()
Virtual function to create a TextureImageHandle.

virtual NVSG_API bool | onLoad (const std::string &filename, nvsg::TextureImage *texImg, const std::vector< std::string > &searchPaths)=0
Pure virtual interface called on loading a TextureImage file.

Detailed Description

Pure virtual base class for texture loader plugins.

Note:
TextureLoader are not yet implemented as plugins.

Constructor & Destructor Documentation

virtual NVSG_API ~TextureLoader ( ) [protected, virtual]

Protected virtual destructor.

Prohibits ordinary client code from

  • creating a TextureLoader derived object on stack and
  • calling delete on a pointer to TextureLoader.
    Note:
    This will not prohibit client code from calling delete on a pointer to a TextureLoader derived object. Normally this is not that critical, because one almost always uses a pointer to the base class when working with TextureLoader plug-ins.
    Nevertheless, it would be far less error prone if classes that inherit from TextureLoader also make their destructor protected.

Member Function Documentation

NVSG_API TextureImageHandle* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths = std::vector< std::string >(),
 |  | const unsigned int & | creationFlags = 0
 | ) |

Function to load a TextureImage.

Parameters:
filename | The name of the texture file to load.
searchPaths | An optional set of search paths to use for files referenced within the texture file specified by filename.
creationFlags | An optional set of creation flags
Returns:
A pointer to the created TextureImageHandle, or NULL if the loading failed.
Remarks:
Creates a TextureImageHandle and calls onLoad() with filename, the created TextureImage, and searchPaths.
Note:
The behavior is undefined if the file filename does not exist or is not of the appropriate type.
See also:
reload, onLoad

NVSG_API bool reload | ( | TextureImageHandle * | tih,
 |  | const std::vector< std::string > & | searchPaths = std::vector< std::string >()
 | ) |

Function to reload a TextureImage.

Parameters:
tih | A pointer to the TextureImage to reload.
searchPaths | An optional set of search paths to use for files referenced within the texture file specified by filename.
Returns:
true if reloading the TextureImage was successful, otherwise false.
Remarks:
Any previously loaded pixel data is released, and the file specified by tih is reloaded. It is assumed that the TextureImage is cleared, that is, it has no images.
See also:
load, onLoad

virtual NVSG_API TextureImageHandle* createTextureImageHandle ( ) [protected, virtual]

Virtual function to create a TextureImageHandle.

Returns:
A pointer to a created TextureImageHandle.
Remarks:
This function is called in load. The default implementation just creates a TextureImageHandle. A class derived from TextureLoader can decide to overwrite this function to create an object that is derived from TextureImageHandle.
See also:
VolLoader

Reimplemented in VolLoader.

virtual NVSG_API bool onLoad | ( | const std::string & | filename,
 |  | nvsg::TextureImage * | texImg,
 |  | const std::vector< std::string > & | searchPaths
 | ) | [protected, pure virtual]

Pure virtual interface called on loading a TextureImage file.

Parameters:
filename | The name of the texture file to load.
texImg | A pointer to the TextureImage to load the data into.
searchPaths | A set of search paths used for files referenced within the texture file.
Returns:
true, if the TextureImage was successfully loaded, otherwise false.
Remarks:
Loads a TextureImage from the file specified by filename. The PlugIn must create the image(s) in the OpenGL compatible orientation, that has its image origin in the lower left. TextureImage offers mirrorX() and mirrorY() routines that a Loader PlugIn can use to achieve this orientation.
See also:
load, reload

Implemented in ILTexLoader, and VolLoader.

The documentation for this class was generated from the following file:
  • PlugInterface.h
Generated on Tue Jan 15 10:29:13 2008 for NVSGSDK by NVIDIA


Member List

TextureLoader Member List

This is the complete list of members for TextureLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
createTextureImageHandle() | TextureLoader | [protected, virtual]
deleteThis(void)=0 | PlugIn | [protected, pure virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths=std::vector< std::string >(), const unsigned int &creationFlags=0) | TextureLoader |
onLoad(const std::string &filename, nvsg::TextureImage *texImg, const std::vector< std::string > &searchPaths)=0 | TextureLoader | [protected, pure virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
reload(TextureImageHandle *tih, const std::vector< std::string > &searchPaths=std::vector< std::string >()) | TextureLoader |
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~TextureLoader() | TextureLoader | [protected, virtual]
Generated on Tue Jan 15 10:29:13 2008 for NVSGSDK by NVIDIA


TextureSaver Class Reference

Pure virtual base class for texture saver plugins. More...

#include <PlugInterface.h>

Inheritance diagram for TextureSaver:

[legend]
Collaboration diagram for TextureSaver:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API bool | save (TextureImageHandle *image, const std::string &fileName)=0
Pure virtual interface function to save a TextureImage.

Protected Member Functions

virtual NVSG_API | ~TextureSaver ()
Protected virtual destructor.

Detailed Description

Pure virtual base class for texture saver plugins.

Note:
TextureSaver are not yet implemented as plugins.

Constructor & Destructor Documentation

virtual NVSG_API ~TextureSaver ( ) [protected, virtual]

Protected virtual destructor.

Prohibits ordinary client code from

  • creating a TextureSaver derived object on stack and
  • calling delete on a pointer to TextureSaver.
    Note:
    This will not prohibit client code from calling delete on a pointer to a TextureSaver derived object. Normally this is not that critical, because one almost always uses a pointer to the base class when working with TextureSaver plug-ins.
    Nevertheless, it would be far less error prone if classes that inherit from TextureSaver also make their destructor protected.

Member Function Documentation

virtual NVSG_API bool save | ( | TextureImageHandle * | image,
 |  | const std::string & | fileName
 | ) | [pure virtual]

Pure virtual interface function to save a TextureImage.

Saves the texture image image to the file given by filename.

Returns:
true, if the TextureImage was saved successfully, otherwise false.

Implemented in ILTexSaver, and VolSaver.

The documentation for this class was generated from the following file:
  • PlugInterface.h
Generated on Tue Jan 15 10:29:13 2008 for NVSGSDK by NVIDIA


Member List

TextureSaver Member List

This is the complete list of members for TextureSaver, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void)=0 | PlugIn | [protected, pure virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(TextureImageHandle *image, const std::string &fileName)=0 | TextureSaver | [pure virtual]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~TextureSaver() | TextureSaver | [protected, virtual]
Generated on Tue Jan 15 10:29:13 2008 for NVSGSDK by NVIDIA


TemplateTrace class Reference

Trace Class Template Reference

Trace class template. More...

#include <Trace.h>

List of all members.

Public Member Functions

Trace (const char *fn, bool traceOut)
Constructor for entering a function \ fn.

~Trace ()
Destructor for leaving a function.

Detailed Description

template<typename Functor>
class nvutil::Trace< Functor >

Trace class template.

Constructor & Destructor Documentation

Trace | ( | const char * | fn,
 |  | bool | traceOut
 | ) | [inline]

Constructor for entering a function \ fn.

~Trace ( ) [inline]

Destructor for leaving a function.

The documentation for this class was generated from the following file:
  • Trace.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

Trace Member List

This is the complete list of members for Trace, including all inherited members.
Trace(const char *fn, bool traceOut) | Trace | [inline]
~Trace() | Trace | [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


traceConsoleDebugOutput Struct Reference

output to console _AND_ attached debugger More...

#include <Trace.h>

List of all members.

Public Member Functions

void operator() (const char *str)
Function call operator to output a string.

Detailed Description

output to console _AND_ attached debugger

Member Function Documentation

void operator() ( const char * str ) [inline]

Function call operator to output a string.

The documentation for this struct was generated from the following file:
  • Trace.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

traceConsoleDebugOutput Member List

This is the complete list of members for traceConsoleDebugOutput, including all inherited members.
operator()(const char *str) traceConsoleDebugOutput [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


traceConsoleOutput Struct Reference

output to console More...

#include <Trace.h>

List of all members.

Public Member Functions

void operator() (const char *str)
Function call operator to output a string.

Detailed Description

output to console

Member Function Documentation

void operator() ( const char * str ) [inline]

Function call operator to output a string.

The documentation for this struct was generated from the following file:
  • Trace.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

traceConsoleOutput Member List

This is the complete list of members for traceConsoleOutput, including all inherited members.
operator()(const char *str) traceConsoleOutput [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


traceDebugOutput Struct Reference

output to attached debugger More...

#include <Trace.h>

List of all members.

Public Member Functions

void operator() (const char *str)
Function call operator to output a string.

Detailed Description

output to attached debugger

Member Function Documentation

void operator() ( const char * str ) [inline]

Function call operator to output a string.

The documentation for this struct was generated from the following file:
  • Trace.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

traceDebugOutput Member List

This is the complete list of members for traceDebugOutput, including all inherited members.
operator()(const char *str) traceDebugOutput [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


traceFileConsoleOutput Struct Reference

output to log file _AND_ console More...

#include <Trace.h>

List of all members.

Public Member Functions

void operator() (const char *str)
Function call operator to output a string.

Detailed Description

output to log file _AND_ console

Member Function Documentation

void operator() ( const char * str ) [inline]

Function call operator to output a string.

The documentation for this struct was generated from the following file:
  • Trace.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

traceFileConsoleOutput Member List

This is the complete list of members for traceFileConsoleOutput, including all inherited members.
operator()(const char *str) traceFileConsoleOutput [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


traceFileDebugOutput Struct Reference

output to log file _AND_ attached debugger More...

#include <Trace.h>

List of all members.

Public Member Functions

void operator() (const char *str)
Function call operator to output a string.

Detailed Description

output to log file _AND_ attached debugger

Member Function Documentation

void operator() ( const char * str ) [inline]

Function call operator to output a string.

The documentation for this struct was generated from the following file:
  • Trace.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

traceFileDebugOutput Member List

This is the complete list of members for traceFileDebugOutput, including all inherited members.
operator()(const char *str) traceFileDebugOutput [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


traceFileOutput Struct Reference

output to file More...

#include <Trace.h>

List of all members.

Public Member Functions

void operator() (const char *str)
Function call operator to output a string.

Detailed Description

output to file

Member Function Documentation

void operator() ( const char * str ) [inline]

Function call operator to output a string.

The documentation for this struct was generated from the following file:
  • Trace.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

traceFileOutput Member List

This is the complete list of members for traceFileOutput, including all inherited members.
operator()(const char *str) traceFileOutput [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


TemplateTraceFunctor struct Reference

TraceFunctor Struct Template Reference

uses the function given as template argument to print out a given string More...

#include <Trace.h>

List of all members.

Public Member Functions

void | operator() (const char *str)
Function call operator to print out a string.

void | format (const char *fmt,...)
Formatted output of a variable number of arguments.

Detailed Description

template<typename OutFunctor>
struct nvutil::TraceFunctor< OutFunctor >

uses the function given as template argument to print out a given string

Member Function Documentation

void operator() ( const char * str ) [inline]

Function call operator to print out a string.

void format | ( | const char * | fmt,
 |  | ... |
 | ) | [inline]

Formatted output of a variable number of arguments.

The documentation for this struct was generated from the following file:
  • Trace.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

TraceFunctor Member List

This is the complete list of members for TraceFunctor, including all inherited members.
format(const char *fmt,...) | TraceFunctor | [inline]
operator()(const char *str) | TraceFunctor | [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Trackball Class Reference

Trackball class for simulating a virtual trackball. More...

#include <Trackball.h>

List of all members.

Public Member Functions

Trackball (void)
Default constructor.

virtual | ~Trackball (void)
Default destructor.

void | apply (const nvmath::Vec2f &p0, const nvmath::Vec2f &p1, nvmath::Vec3f &axis, float &rad)
Start trackball calculation.

void | setSize (float size)
Set trackball size.

float | getSize (void)
Determine current size of the trackball.

Protected Member Functions

float | projectOntoTBSphere (const nvmath::Vec2f &p)
Project the x,y mouse position onto a sphere.

Protected Attributes

float | m_tbsize
Trackball size (default is 0.8f)

Detailed Description

Trackball class for simulating a virtual trackball.

This class simulates a virtual trackball using the last and current mouse position. It simply projects the stuff onto a sphere or hyperbolic sheet and calculates the axis and angle that is needed to rotate the trackball from the last to the current position.

Constructor & Destructor Documentation

Trackball ( void )

Default constructor.

virtual ~Trackball ( void ) [virtual]

Default destructor.

Member Function Documentation

void apply | ( | const nvmath::Vec2f & | p0,
 |  | const nvmath::Vec2f & | p1,
 |  | nvmath::Vec3f & | axis,
 |  | float & | rad
 | ) |

Start trackball calculation.

Calculate the axis and the angle (radians) by the given mouse coordinates. Project the points onto the virtual trackball, then figure out the axis of rotation, which is the cross product of p0 p1 and O p0 (O is the center of the ball, 0,0,0)

Note:
This is a deformed trackball-- is a trackball in the center, but is deformed into a hyperbolic sheet of rotation away from the center.
Parameters:
p0 | Last mouse position - components must be scaled to [-1,1]
p1 | Current mouse position - components must be scaled to [-1,1]
axis | Resulting axis
rad | Resulting angle

void setSize ( float size ) [inline]

Set trackball size.

Define the size of the trackball. Default size is 0.8f. This size should really be based on the distance from the center of rotation to the point on the object underneath the mouse. That point would then track the mouse as closely as possible.

Parameters:
size Trackball size

float getSize ( void ) [inline]

Determine current size of the trackball.

Returns:
Trackball size

float projectOntoTBSphere ( const nvmath::Vec2f & p ) [protected]

Project the x,y mouse position onto a sphere.

Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet if we are away from the center of the sphere.

Member Data Documentation

float m_tbsize [protected]

Trackball size (default is 0.8f)

The documentation for this class was generated from the following file:
  • Trackball.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

Trackball Member List

This is the complete list of members for Trackball, including all inherited members.
apply(const nvmath::Vec2f &p0, const nvmath::Vec2f &p1, nvmath::Vec3f &axis, float &rad) | Trackball |
getSize(void) | Trackball | [inline]
m_tbsize | Trackball | [protected]
projectOntoTBSphere(const nvmath::Vec2f &p) | Trackball | [protected]
setSize(float size) | Trackball | [inline]
Trackball(void) | Trackball |
~Trackball(void) | Trackball | [virtual]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


TrackballCameraManipulator Class Reference

Simulate a trackball-like camera mouse interaction. More...

#include <TrackballCameraManipulator.h>

Inheritance diagram for TrackballCameraManipulator:

[legend]
Collaboration diagram for TrackballCameraManipulator:

[legend]
List of all members.

Public Types

enum {
_NO_BTN_KEY = 0x0000, _LEFT_MOUSE_BTN = 0x0001, _MIDDLE_MOUSE_BTN = 0x0002, _SHIFT_KEY = 0x0004,
_CONTROL_KEY = 0x0008, _X_KEY = 0x0010, _Y_KEY = 0x0020, _Z_KEY = 0x0040
}
Button and key definitions. More...

Public Member Functions

NVSG_API | TrackballCameraManipulator ()
Default constructor.

virtual NVSG_API | ~TrackballCameraManipulator ()
Default destructor.

virtual NVSG_API bool | updateFrame ()
Apply changes for the next frame.

virtual NVSG_API bool | isActive ()
Give feedback of the activeness of the manipulator.

NVSG_API void | keyDown (UINT key)
Handle key press events.

NVSG_API void | keyUp (UINT key)
Handle key release events.

NVSG_API void | mouseButtonDown (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseButtonUp (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseMotion (int x, int y)
Handle mouse motion.

NVSG_API void | reset ()
Reset camera Manipulator object.

NVSG_API bool | isDolly ()
Test if the manipulator is in dolly mode.

NVSG_API bool | isPan ()
Test if the manipulator is in pan mode.

NVSG_API bool | isOrbit ()
Test if the manipulator is in orbit mode.

NVSG_API bool | isRotate ()
Test if the manipulator is in rotate mode.

Protected Member Functions

virtual bool | orbit ()
Do the orbit.

virtual bool | pan ()
Do the pan.

virtual bool | dolly ()
Do the dolly.

virtual bool | rotate ()
Do the rotate.

Protected Attributes

nvui::MouseInput m_mouseInput
MouseInput object for tracking mouse events.

nvui::MouseInput m_miLast
Used to compare current and last mouse input.

nvui::KeyInput m_keyInput
KeyInput object for tracking keyboard events.

nvutil::Trackball m_trackball
Trackball object that does all the calculations.

nvmath::Vec3f m_rotationAxis
Used to rotate.

int | m_trueX
int | m_trueY
Used to restart the orbit/pan operation on key down/up.

Static Protected Attributes

NVSG_API const UINT | DOLLY1
NVSG_API const UINT | DOLLY2
Button configuration for dolly (_LEFT_MOUSE_BTN | _SHIFT_KEY).

NVSG_API const UINT | PAN1
Button configuration for pan (_MIDDLE_MOUSE_BTN).

NVSG_API const UINT | PAN2
Button configuration for pan (_LEFT_MOUSE_BTN | _CONTROL_KEY).

NVSG_API const UINT | ORBIT
Button configuration for orbit (_LEFT_MOUSE_BTN).

NVSG_API const UINT | ROTATEXP
Button configuration for rotate around positive x-axis.

NVSG_API const UINT | ROTATEXN
Button configuration for rotate around negative x-axis.

NVSG_API const UINT | ROTATEYP
Button configuration for rotate around positive y-axis.

NVSG_API const UINT | ROTATEYN
Button configuration for rotate around negative y-axis.

NVSG_API const UINT | ROTATEZP
Button configuration for rotate around positive z-axis.

NVSG_API const UINT | ROTATEZN
Button configuration for rotate around negative z-axis.

Detailed Description

Simulate a trackball-like camera mouse interaction.

Namespace: nvui
Remarks:
This Manipulator is a special Manipulator that interprets/converts mouse movement into nvsg::Camera changes. You can orbit around the scene, pan the camera, and dolly in and out.

Keys & Buttons
Left mouse button : Orbit.
Middle mouse button : Pan.
Left & Middle mouse button : Dolly.
Ctrl + Left mouse button : Pan.
Shift + Left mouse button : Dolly.

When holding the x or the y key while orbiting or panning, the x or the y coordinate are held constant, respectively. Thus orbiting or panning is done with a fixed corresponding axis. If you use this manipulator, your application must use a mechanism, such as using OnIdle() that calls updateFrame(). If updateFrame() returns true you should call triggerRedraw of the render area so the updated frame will be drawn. You will find some code samples in the description of the Manipulator class. Also, the SimpleViewer tutorial source code shows how to use a manipulator with MFC, the ConsoleViewer tutorial source code shows the details on how to use a manipulator, and the ManipSampleViewer tutorial source code shows how to derive a new Manipulator class.
See also:
Manipulator

Member Enumeration Documentation

anonymous enum

Button and key definitions.

Remarks:
These values are used for the button and key state handling.
See also:
KeyInput, MouseInput
Enumeration values:
_NO_BTN_KEY | No button or key pressed.
_LEFT_MOUSE_BTN | Left mouse button pressed.
_MIDDLE_MOUSE_BTN | Middle mouse button pressed.
_SHIFT_KEY | Shift key pressed.
_CONTROL_KEY | Control key pressed.
_X_KEY | x key pressed: lock x axis
_Y_KEY | y key pressed: lock y axis
_Z_KEY | z key pressed

Constructor & Destructor Documentation

NVSG_API TrackballCameraManipulator ( )

Default constructor.

Remarks:
Initialize the TrackballCameraManipulator object.

virtual NVSG_API ~TrackballCameraManipulator ( ) [virtual]

Default destructor.

Member Function Documentation

virtual NVSG_API bool updateFrame ( ) [virtual]

Apply changes for the next frame.

Returns:
If there is a change regarding the last frame this function returns true.
Remarks:
This function updates the camera. The application should call this function from, for example, your idle handler. If it returns with a positive result - true - the application should call RenderArea::triggerRedraw.
Example
  if (m_pTrackballCamManip->updateFrame())
  {
    m_pRA->triggerRedraw();
  }
See also the sample code in the Manipulator class description and the ManipSampleViewer, SimpleViewer and ConsoleViewer tutorial source code.
See also:
RenderArea::triggerRedraw

Implements Manipulator.

virtual NVSG_API bool isActive ( ) [virtual]

Give feedback of the activeness of the manipulator.

Returns:
This function returns true when the manipulator is in active mode.
Remarks:
The TrackballCameraManipulator is active when he is internally in orbit, pan or dolly mode.

Implements Manipulator.

NVSG_API void keyDown ( UINT key )

Handle key press events.

Parameters:
key The key code of the pressed key. This Manipulator accepts only the _SHIFT_KEY and _CONTROL_KEY. Other key codes will lead to undefined behavior.
Remarks:
This function routes the key codes to the KeyInput class so the manipulator can react on keyboard input.
See also:
keyUp, KeyInput::keyDown

NVSG_API void keyUp ( UINT key )

Handle key release events.

Parameters:
key The key code of the released key. This Manipulator accepts only the _SHIFT_KEY and _CONTROL_KEY. Other key codes will lead to undefined behavior.
Remarks:
This function routes the key codes to the KeyInput class so the manipulator can react on keyboard input.
See also:
keyDown, KeyInput::keyUp

NVSG_API void mouseButtonDown | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code (or concatenation) of the pressed button(s). This Manipulator accepts only the _LEFT_MOUSE_BTN and _MIDDLE_MOUSE_BTN. Other button codes will lead to undefined behavior.
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse button code and the current mouse cursor position to the MouseInput object to store the events. Call this function from your mouse button handler of your application.
See also:
mouseButtonUp, MouseInput::mouseButtonUp

NVSG_API void mouseButtonUp | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code (or concatenation) of the released button(s). This Manipulator accepts only the _LEFT_MOUSE_BTN and _MIDDLE_MOUSE_BTN. Other button codes will lead to undefined behavior.
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse button code and the current mouse cursor position to the MouseInput object to store the events. Call this function from your mouse button handler of your application.
See also:
mouseButtonDown, MouseInput::mouseButtonDown

NVSG_API void mouseMotion | ( | int | x,
 |  | int | y
 | ) |

Handle mouse motion.

Parameters:
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse motion to the MouseInput object. Call this function from your mouse motion handler of your application.
See also:
MouseInput::mouseMotion

NVSG_API void reset ( )

Reset camera Manipulator object.

Remarks:
This function resets the key and button states of this Manipulator.
Note:
This function does not reset the mouse position since the mouse position will be updated via the mouseMotion function all the time. If you reset the mouse position manually you will see undesirable camera jumps.
See also:
MouseInput::resetButtonState, KeyInput::resetKeyState

NVSG_API bool isDolly ( )

Test if the manipulator is in dolly mode.

Returns:
This function returns true when the Manipulator is in dolly mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in dolly mode.

Dolly:
  • Left & Middle mouse button
  • Shift + Left mouse button

NVSG_API bool isPan ( )

Test if the manipulator is in pan mode.

Returns:
This function returns true when the Manipulator is in pan mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in pan mode.

Pan:
  • Middle mouse button
  • Ctrl + Left mouse button

NVSG_API bool isOrbit ( )

Test if the manipulator is in orbit mode.

Returns:
This function returns true when the Manipulator is in orbit mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in orbit mode.

Orbit:
  • Left mouse button

NVSG_API bool isRotate ( )

Test if the manipulator is in rotate mode.

Returns:
This function returns true when the Manipulator is in rotate mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in rotate mode.

Orbit:
  • x key -> rotate around positive x-axis
  • Shift + x key -> rotate around negative x-axis
  • y key -> rotate around positive y-axis
  • Shift + y key -> rotate around negative y-axis
  • z key -> rotate around positive z-axis
  • Shift + z key -> rotate around negative z-axis

virtual bool orbit ( ) [protected, virtual]

Do the orbit.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the orbit functionality.

virtual bool pan ( ) [protected, virtual]

Do the pan.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the pan functionality.

virtual bool dolly ( ) [protected, virtual]

Do the dolly.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the dolly functionality.

virtual bool rotate ( ) [protected, virtual]

Do the rotate.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the rotate functionality.

Member Data Documentation

NVSG_API const UINT DOLLY2 [static, protected]

Button configuration for dolly (_LEFT_MOUSE_BTN | _SHIFT_KEY).

NVSG_API const UINT PAN1 [static, protected]

Button configuration for pan (_MIDDLE_MOUSE_BTN).

NVSG_API const UINT PAN2 [static, protected]

Button configuration for pan (_LEFT_MOUSE_BTN | _CONTROL_KEY).

NVSG_API const UINT ORBIT [static, protected]

Button configuration for orbit (_LEFT_MOUSE_BTN).

NVSG_API const UINT ROTATEXP [static, protected]

Button configuration for rotate around positive x-axis.

NVSG_API const UINT ROTATEXN [static, protected]

Button configuration for rotate around negative x-axis.

NVSG_API const UINT ROTATEYP [static, protected]

Button configuration for rotate around positive y-axis.

NVSG_API const UINT ROTATEYN [static, protected]

Button configuration for rotate around negative y-axis.

NVSG_API const UINT ROTATEZP [static, protected]

Button configuration for rotate around positive z-axis.

NVSG_API const UINT ROTATEZN [static, protected]

Button configuration for rotate around negative z-axis.

nvui::MouseInput m_mouseInput [protected]

MouseInput object for tracking mouse events.

nvui::MouseInput m_miLast [protected]

Used to compare current and last mouse input.

nvui::KeyInput m_keyInput [protected]

KeyInput object for tracking keyboard events.

nvutil::Trackball m_trackball [protected]

Trackball object that does all the calculations.

nvmath::Vec3f m_rotationAxis [protected]

Used to rotate.

int m_trueY [protected]

Used to restart the orbit/pan operation on key down/up.

The documentation for this class was generated from the following file:
  • TrackballCameraManipulator.h
Generated on Tue Jan 15 10:29:43 2008 for NVSGSDK by NVIDIA


Member List

TrackballCameraManipulator Member List

This is the complete list of members for TrackballCameraManipulator, including all inherited members.
_CONTROL_KEY enum value | TrackballCameraManipulator |
_LEFT_MOUSE_BTN enum value | TrackballCameraManipulator |
_MIDDLE_MOUSE_BTN enum value | TrackballCameraManipulator |
_NO_BTN_KEY enum value | TrackballCameraManipulator |
_SHIFT_KEY enum value | TrackballCameraManipulator |
_X_KEY enum value | TrackballCameraManipulator |
_Y_KEY enum value | TrackballCameraManipulator |
_Z_KEY enum value | TrackballCameraManipulator |
dolly() | TrackballCameraManipulator | [protected, virtual]
DOLLY1 (defined in TrackballCameraManipulator) | TrackballCameraManipulator | [protected, static]
DOLLY2 | TrackballCameraManipulator | [protected, static]
isActive() | TrackballCameraManipulator | [virtual]
isDolly() | TrackballCameraManipulator |
isOrbit() | TrackballCameraManipulator |
isPan() | TrackballCameraManipulator |
isRotate() | TrackballCameraManipulator |
keyDown(UINT key) | TrackballCameraManipulator |
keyUp(UINT key) | TrackballCameraManipulator |
m_keyInput | TrackballCameraManipulator | [protected]
m_miLast | TrackballCameraManipulator | [protected]
m_mouseInput | TrackballCameraManipulator | [protected]
m_renderArea | Manipulator | [protected]
m_rotationAxis | TrackballCameraManipulator | [protected]
m_trackball | TrackballCameraManipulator | [protected]
m_trueX (defined in TrackballCameraManipulator) | TrackballCameraManipulator | [protected]
m_trueY | TrackballCameraManipulator | [protected]
Manipulator() | Manipulator |
mouseButtonDown(UINT btn, int x, int y) | TrackballCameraManipulator |
mouseButtonUp(UINT btn, int x, int y) | TrackballCameraManipulator |
mouseMotion(int x, int y) | TrackballCameraManipulator |
ORBIT | TrackballCameraManipulator | [protected, static]
orbit() | TrackballCameraManipulator | [protected, virtual]
pan() | TrackballCameraManipulator | [protected, virtual]
PAN1 | TrackballCameraManipulator | [protected, static]
PAN2 | TrackballCameraManipulator | [protected, static]
reset() | TrackballCameraManipulator |
rotate() | TrackballCameraManipulator | [protected, virtual]
ROTATEXN | TrackballCameraManipulator | [protected, static]
ROTATEXP | TrackballCameraManipulator | [protected, static]
ROTATEYN | TrackballCameraManipulator | [protected, static]
ROTATEYP | TrackballCameraManipulator | [protected, static]
ROTATEZN | TrackballCameraManipulator | [protected, static]
ROTATEZP | TrackballCameraManipulator | [protected, static]
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
TrackballCameraManipulator() | TrackballCameraManipulator |
updateFrame() | TrackballCameraManipulator | [virtual]
~Manipulator() | Manipulator | [virtual]
~TrackballCameraManipulator() | TrackballCameraManipulator | [virtual]
Generated on Tue Jan 15 10:29:43 2008 for NVSGSDK by NVIDIA


TrackballTransformManipulator Class Reference

Simulate a trackball like object mouse interaction. More...

#include <TrackballTransformManipulator.h>

Inheritance diagram for TrackballTransformManipulator:

[legend]
Collaboration diagram for TrackballTransformManipulator:

[legend]
List of all members.

Public Types

enum {
_NO_BTN_KEY = 0x0000, _LEFT_MOUSE_BTN = 0x0001, _MIDDLE_MOUSE_BTN = 0x0002, _SHIFT_KEY = 0x0004,
_CONTROL_KEY = 0x0008, _X_KEY = 0x0010, _Y_KEY = 0x0020
}
Button and key definitions. More...

Public Member Functions

NVSG_API | TrackballTransformManipulator (void)
Default constructor.

virtual NVSG_API | ~TrackballTransformManipulator (void)
Default destructor.

virtual NVSG_API bool | updateFrame ()
Apply changes for the next frame.

virtual NVSG_API bool | isActive ()
Give feedback of the activeness of the manipulator.

NVSG_API void | keyDown (UINT key)
Handle key press events.

NVSG_API void | keyUp (UINT key)
Handle key release events.

NVSG_API void | mouseButtonDown (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseButtonUp (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseMotion (int x, int y)
Handle mouse motion.

NVSG_API void | reset ()
Reset the TrackballTransformManipulator object.

NVSG_API bool | isDolly (void)
Test if the manipulator is in dolly mode.

NVSG_API bool | isPan (void)
Test if the manipulator is in pan mode.

NVSG_API bool | isRotate (void)
Test if the manipulator is in rotate mode.

Protected Member Functions

virtual bool | pan ()
Do the pan.

virtual bool | dolly ()
Do the dolly.

virtual bool | rotate ()
Do the rotate.

Protected Attributes

nvui::MouseInput m_mouseInput
MouseInput object for tracking mouse events.

nvui::KeyInput m_keyInput
KeyInput object for tracking keyboard events.

nvutil::Trackball | m_trackball
int | m_trueX
int | m_trueY
Used to restart the rotate/pan operation on key down/up.

Static Protected Attributes

NVSG_API const UINT | DOLLY1
Button configuration for dolly (_LEFT_MOUSE_BTN | _MIDDLE_MOUSE_BTN).

NVSG_API const UINT | DOLLY2
Button configuration for dolly (_LEFT_MOUSE_BTN | _SHIFT_KEY).

NVSG_API const UINT | PAN1
Button configuration for pan (_MIDDLE_MOUSE_BTN).

NVSG_API const UINT | PAN2
Button configuration for pan (_LEFT_MOUSE_BTN | _CONTROL_KEY).

NVSG_API const UINT | ROTATE
Button configuration for pan (_LEFT_MOUSE_BTN).

Detailed Description

Simulate a trackball like object mouse interaction.

Namespace: nvui
Remarks:
This Manipulator is a special Manipulator that interprets/converts mouse movement into nvsg::Transform changes. You can rotate the object, pan, and dolly it in and out. So you can freely move and place an object in your scene.

Keys & Buttons
Left mouse button : Rotate object
Middle mouse button : Pan object parallel to the screen.
Left & Middle mouse button : Dolly object in and out.
Ctrl + Left mouse button : Pan object parallel to the screen.
Shift + Left mouse button : Dolly object in and out.

When holding the x or the y key while orbiting or panning, the x or the y coordinate are held constant, respectively. Thus orbiting or panning is done with a fixed corresponding axis.
See the TransformManipulatorViewer tutorial source code on how to use a TrackballTransformManipulator in your application.

If you use this manipulator your application must use a mechanism, such as using OnIdle() that calls updateFrame(). If updateFrame() returns true you should call triggerRedraw of the render area so the updated frame will be drawn. You will find some code samples in the description of the Manipulator class. Also the SimpleViewer tutorial source code shows how to use a manipulator with MFC, the ConsoleViewer tutorial source code shows the details on how to use a manipulator and the ManipSampleViewer tutorial source code shows how to derive a new Manipulator class.
See also:
Manipulator

Member Enumeration Documentation

anonymous enum

Button and key definitions.

Remarks:
These values are used for the button and key state handling.
See also:
KeyInput, MouseInput
Enumeration values:
_NO_BTN_KEY | No button.
_LEFT_MOUSE_BTN | Left mouse button.
_MIDDLE_MOUSE_BTN | Middle mouse button.
_SHIFT_KEY | Shift key.
_CONTROL_KEY | Control key.
_X_KEY | x key pressed: lock x axis
_Y_KEY | y key pressed: lock y axis

Constructor & Destructor Documentation

NVSG_API TrackballTransformManipulator ( void )

Default constructor.

Remarks:
Initialize the TrackballTransformManipulator object.

virtual NVSG_API ~TrackballTransformManipulator ( void ) [virtual]

Default destructor.

Member Function Documentation

virtual NVSG_API bool updateFrame ( ) [virtual]

Apply changes for the next frame.

Returns:
If there is a change regarding the last frame this function returns true.
Remarks:
This function updates the nvsg::Transform. The application should call this function from, for example, your idle handler. If it returns with a positive result - true - the application should call RenderArea::triggerRedraw.
Example
  if (m_pTrackballTransformManip->updateFrame())
  {
    m_pRA->triggerRedraw();
  }
See also the sample code in the Manipulator class description and the TransformManipulatorViewer, ManipSampleViewer, SimpleViewer and ConsoleViewer tutorial source code.
See also:
RenderArea::triggerRedraw

Implements Manipulator.

virtual NVSG_API bool isActive ( ) [virtual]

Give feedback of the activeness of the manipulator.

Returns:
This function returns true when the manipulator is in active mode.
Remarks:
The TrackballTransformManipulator is active when he is internally in rotate, pan, or dolly mode.

Implements Manipulator.

NVSG_API void keyDown ( UINT key )

Handle key press events.

Parameters:
key The key code of the pressed key. This Manipulator accepts only the _SHIFT_KEY and _CONTROL_KEY. Other key codes will lead to undefined behavior.
Remarks:
This function routes the key codes to the KeyInput class so the manipulator can react on keyboard input.
See also:
keyUp, KeyInput::keyDown

NVSG_API void keyUp ( UINT key )

Handle key release events.

Parameters:
key The key code of the released key. This Manipulator accepts only the _SHIFT_KEY and _CONTROL_KEY. Other key codes will lead to undefined behavior.
Remarks:
This function routes the key codes to the KeyInput class so the manipulator can react on keyboard input.
See also:
keyDown, KeyInput::keyUp

NVSG_API void mouseButtonDown | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code (or concatenation) of the pressed button(s). This Manipulator accepts only the _LEFT_MOUSE_BTN and _MIDDLE_MOUSE_BTN. Other button codes will lead to undefined behavior.
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse button code and the current mouse cursor position to the MouseInput object to store the events. Call this function from your mouse button handler of your application.
See also:
mouseButtonUp, MouseInput::mouseButtonUp

NVSG_API void mouseButtonUp | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code (or concatenation) of the released button(s). This Manipulator accepts only the _LEFT_MOUSE_BTN and _MIDDLE_MOUSE_BTN. Other button codes will lead to undefined behavior.
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse button code and the current mouse cursor position to the MouseInput object to store the events. Call this function from your mouse button handler of your application.
See also:
mouseButtonDown, MouseInput::mouseButtonDown

NVSG_API void mouseMotion | ( | int | x,
 |  | int | y
 | ) |

Handle mouse motion.

Parameters:
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse motion to the MouseInput object. Call this function from your mouse motion handler of your application.
See also:
MouseInput::mouseMotion

NVSG_API void reset ( )

Reset the TrackballTransformManipulator object.

Remarks:
This function resets the key and button states of this Manipulator.
Note:
This function does not reset the mouse position since the mouse position will be updated via the mouseMotion function all the time. If you reset the mouse position manually you will see object jumps, which is not desireable.
See also:
MouseInput::resetButtonState, KeyInput::resetKeyState

NVSG_API bool isDolly ( void )

Test if the manipulator is in dolly mode.

Returns:
This function returns true when the Manipulator is in dolly mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in dolly mode.

Dolly:
  • Left & Middle mouse button
  • Shift + Left mouse button

NVSG_API bool isPan ( void )

Test if the manipulator is in pan mode.

Returns:
This function returns true when the Manipulator is in pan mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in pan mode.

Pan:
  • Middle mouse button
  • Ctrl + Left mouse button

NVSG_API bool isRotate ( void )

Test if the manipulator is in rotate mode.

Returns:
This function returns true when the Manipulator is in rotate mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in rotate mode.

Rotate:
  • Left mouse button

virtual bool pan ( ) [protected, virtual]

Do the pan.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the pan functionality.

virtual bool dolly ( ) [protected, virtual]

Do the dolly.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the dolly functionality.

virtual bool rotate ( ) [protected, virtual]

Do the rotate.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the dolly functionality.

Member Data Documentation

NVSG_API const UINT DOLLY1 [static, protected]

Button configuration for dolly (_LEFT_MOUSE_BTN | _MIDDLE_MOUSE_BTN).

NVSG_API const UINT DOLLY2 [static, protected]

Button configuration for dolly (_LEFT_MOUSE_BTN | _SHIFT_KEY).

NVSG_API const UINT PAN1 [static, protected]

Button configuration for pan (_MIDDLE_MOUSE_BTN).

NVSG_API const UINT PAN2 [static, protected]

Button configuration for pan (_LEFT_MOUSE_BTN | _CONTROL_KEY).

NVSG_API const UINT ROTATE [static, protected]

Button configuration for pan (_LEFT_MOUSE_BTN).

nvui::MouseInput m_mouseInput [protected]

MouseInput object for tracking mouse events.

nvui::KeyInput m_keyInput [protected]

KeyInput object for tracking keyboard events.

int m_trueY [protected]

Used to restart the rotate/pan operation on key down/up.

The documentation for this class was generated from the following file:
  • TrackballTransformManipulator.h
Generated on Tue Jan 15 10:29:44 2008 for NVSGSDK by NVIDIA


Member List

TrackballTransformManipulator Member List

This is the complete list of members for TrackballTransformManipulator, including all inherited members.
_CONTROL_KEY enum value | TrackballTransformManipulator |
_LEFT_MOUSE_BTN enum value | TrackballTransformManipulator |
_MIDDLE_MOUSE_BTN enum value | TrackballTransformManipulator |
_NO_BTN_KEY enum value | TrackballTransformManipulator |
_SHIFT_KEY enum value | TrackballTransformManipulator |
_X_KEY enum value | TrackballTransformManipulator |
_Y_KEY enum value | TrackballTransformManipulator |
dolly() | TrackballTransformManipulator | [protected, virtual]
DOLLY1 | TrackballTransformManipulator | [protected, static]
DOLLY2 | TrackballTransformManipulator | [protected, static]
getTransformPath() const | TransformManipulator | [inline]
isActive() | TrackballTransformManipulator | [virtual]
isDolly(void) | TrackballTransformManipulator |
isPan(void) | TrackballTransformManipulator |
isRotate(void) | TrackballTransformManipulator |
keyDown(UINT key) | TrackballTransformManipulator |
keyUp(UINT key) | TrackballTransformManipulator |
m_keyInput | TrackballTransformManipulator | [protected]
m_mouseInput | TrackballTransformManipulator | [protected]
m_renderArea | Manipulator | [protected]
m_trackball (defined in TrackballTransformManipulator) | TrackballTransformManipulator | [protected]
m_transformPath | TransformManipulator | [protected]
m_trueX (defined in TrackballTransformManipulator) | TrackballTransformManipulator | [protected]
m_trueY | TrackballTransformManipulator | [protected]
Manipulator() | Manipulator |
mouseButtonDown(UINT btn, int x, int y) | TrackballTransformManipulator |
mouseButtonUp(UINT btn, int x, int y) | TrackballTransformManipulator |
mouseMotion(int x, int y) | TrackballTransformManipulator |
pan() | TrackballTransformManipulator | [protected, virtual]
PAN1 | TrackballTransformManipulator | [protected, static]
PAN2 | TrackballTransformManipulator | [protected, static]
reset() | TrackballTransformManipulator |
rotate() | TrackballTransformManipulator | [protected, virtual]
ROTATE | TrackballTransformManipulator | [protected, static]
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
setTransformPath(const nvsg::Path *transformPath) | TransformManipulator |
TrackballTransformManipulator(void) | TrackballTransformManipulator |
TransformManipulator() | TransformManipulator |
updateFrame() | TrackballTransformManipulator | [virtual]
~Manipulator() | Manipulator | [virtual]
~TrackballTransformManipulator(void) | TrackballTransformManipulator | [virtual]
~TransformManipulator() | TransformManipulator | [virtual]
Generated on Tue Jan 15 10:29:44 2008 for NVSGSDK by NVIDIA


Trafo Class Reference

Transformation class. More...

#include <Trafo.h>

Collaboration diagram for Trafo:

[legend]
List of all members.

Public Member Functions

NVSG_API | Trafo (void)
Constructor: initialized to identity.

NVSG_API | Trafo (const Trafo &rhs)
Copy Constructor.

NVSG_API const Vec3f & | getCenter (void) const
Get the center of rotation of this transformation.

NVSG_API const Quatf & | getOrientation (void) const
Get the rotational part of this transformation.

NVSG_API const Quatf & | getScaleOrientation (void) const
Get the scale orientation part of this transform.

NVSG_API const Vec3f & | getScaling (void) const
Get the scaling part of this transformation.

NVSG_API const Vec3f & | getTranslation (void) const
Get the translational part of this transformation.

NVSG_API Mat44f | getMatrix (void) const
Get the current transformation.

NVSG_API Mat44f | getInverse (void) const
Get the current inverse transformation.

NVSG_API void | setCenter (const Vec3f &center)
Set the center of ration of the transformation.

NVSG_API void | setIdentity (void)
Set the Trafo to identity.

NVSG_API void | setOrientation (const Quatf &orientation)
Set the rotational part of the transformation, using a quaternion.

NVSG_API void | setScaleOrientation (const Quatf &scaleOrientation)
Set the scale orientational part of the transformation.

NVSG_API void | setScaling (const Vec3f &scaling)
Set the scaling part of the transformation.

NVSG_API void | setTranslation (const Vec3f &translation)
Set the translational part of the transformation.

NVSG_API void | setMatrix (const Mat44f &matrix)
Set the complete transformation by a Mat44f.

NVSG_API Trafo & | operator= (const Trafo &rhs)
Copy operator.

NVSG_API bool | operator== (const Trafo &t) const
Equality operator.

NVSG_API bool | operator!= (const Trafo &t) const

Related Functions

(Note that these are not member functions.)

NVSG_API Trafo | lerp (float alpha, const Trafo &t0, const Trafo &t1)

Detailed Description

Transformation class.

This class is used to ease transformation handling. It has an interface to rotate, scale, and translate and can produce a Mat44f that combines them.

Constructor & Destructor Documentation

NVSG_API Trafo ( void )

Constructor: initialized to identity.

NVSG_API Trafo ( const Trafo & rhs )

Copy Constructor.

Parameters:
rhs Trafo to copy

Member Function Documentation

const Vec3f & getCenter ( void ) const [inline]

Get the center of rotation of this transformation.

Returns:
Vec3f that describes the center or rotation.

const Quatf & getOrientation ( void ) const [inline]

Get the rotational part of this transformation.

Returns:
Quatf that describes the rotational part

const Quatf & getScaleOrientation ( void ) const [inline]

Get the scale orientation part of this transform.

Returns:
Quatf that describes the scale orientational part

const Vec3f & getScaling ( void ) const [inline]

Get the scaling part of this transformation.

Returns:
Vec3f that describes the scaling part

const Vec3f & getTranslation ( void ) const [inline]

Get the translational part of this transformation.

Returns:
Vec3f that describes the translational part

NVSG_API Mat44f getMatrix ( void ) const

Get the current transformation.

Returns:
The Mat44f that describes the transformation.
Remarks:
The transformation is the concatenation of the center translation C, scale orientation SO, scaling S, rotation R, and translation T, by the following formula:
    M = -C * SO^-1 * S * SO * R * C * T
See also:
getInverse

NVSG_API Mat44f getInverse ( void ) const

Get the current inverse transformation.

Returns:
The Mat44f that describes the inverse transformation.
Remarks:
The inverse transformation is the concatenation of the center translation C, scale orientation SO, scaling S, rotation R, and translation T, by the following formula:
    M = T^-1 * C^-1 * R^-1 * SO^-1 * S^-1 * SO * -C^-1
See also:
getMatrix

void setCenter ( const Vec3f & center ) [inline]

Set the center of ration of the transformation.

Parameters:
center center of rotation

NVSG_API void setIdentity ( void )

Set the Trafo to identity.

void setOrientation ( const Quatf & orientation ) [inline]

Set the rotational part of the transformation, using a quaternion.

Parameters:
orientation rotational part of transformation

void setScaleOrientation ( const Quatf & scaleOrientation ) [inline]

Set the scale orientational part of the transformation.

Parameters:
scaleOrientation scale orientational part of transform

void setScaling ( const Vec3f & scaling ) [inline]

Set the scaling part of the transformation.

Parameters:
scaling scaling part of transformation

void setTranslation ( const Vec3f & translation ) [inline]

Set the translational part of the transformation.

Parameters:
translation translational part of transformation

NVSG_API void setMatrix ( const Mat44f & matrix )

Set the complete transformation by a Mat44f.

The matrix is internally decomposed into a translation, rotation, scaleOrientation, and scaling.

Parameters:
matrix complete transformation

NVSG_API Trafo& operator= ( const Trafo & rhs )

Copy operator.

Parameters:
rhs Trafo to copy

NVSG_API bool operator== ( const Trafo & t ) const

Equality operator.

Returns:
true if this is equal to t, otherwise false
Parameters:
t Trafo to compare with

Friends And Related Function Documentation

NVSG_API Trafo lerp | ( | float | alpha,
 |  | const Trafo & | t0,
 |  | const Trafo & | t1
 | ) | [related]

This calculates the linear interpolation

 ( 1 - alpha ) * t0 + alpha * t1
Parameters:
alpha | interpolation parameter
t0 | starting value
t1 | ending value

The documentation for this class was generated from the following file:
  • Trafo.h
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


Member List

Trafo Member List

This is the complete list of members for Trafo, including all inherited members.
getCenter(void) const | Trafo | [inline]
getInverse(void) const | Trafo |
getMatrix(void) const | Trafo |
getOrientation(void) const | Trafo | [inline]
getScaleOrientation(void) const | Trafo | [inline]
getScaling(void) const | Trafo | [inline]
getTranslation(void) const | Trafo | [inline]
lerp(float alpha, const Trafo &t0, const Trafo &t1) | Trafo | [related]
operator!=(const Trafo &t) const (defined in Trafo) | Trafo | [inline]
operator=(const Trafo &rhs) | Trafo |
operator==(const Trafo &t) const | Trafo |
setCenter(const Vec3f &center) | Trafo | [inline]
setIdentity(void) | Trafo |
setMatrix(const Mat44f &matrix) | Trafo |
setOrientation(const Quatf &orientation) | Trafo | [inline]
setScaleOrientation(const Quatf &scaleOrientation) | Trafo | [inline]
setScaling(const Vec3f &scaling) | Trafo | [inline]
setTranslation(const Vec3f &translation) | Trafo | [inline]
Trafo(void) | Trafo |
Trafo(const Trafo &rhs) | Trafo |
Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


trafo_t Struct Reference

The trafo_t structure specifies how a transformation is stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

float4_t orientation
Specifies the orientational part of the transformation.

float3_t scaling
Specifies the scaling part of the transformation.

float3_t translation
Specifies the translational part of the transformation.

float3_t center
Specifies the center of rotation of the transformation.

float4_t scaleOrientation
Specifies the scale orientational part of the transformation.

Detailed Description

The trafo_t structure specifies how a transformation is stored in a .NBF file.

Member Data Documentation

float4_t orientation

Specifies the orientational part of the transformation.

float3_t scaling

Specifies the scaling part of the transformation.

float3_t translation

Specifies the translational part of the transformation.

float3_t center

Specifies the center of rotation of the transformation.

float4_t scaleOrientation

Specifies the scale orientational part of the transformation.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

trafo_t Member List

This is the complete list of members for trafo_t, including all inherited members.
center | trafo_t
orientation | trafo_t
scaleOrientation | trafo_t
scaling | trafo_t
translation | trafo_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Transform Class Reference

Transform node. More...

#include <Transform.h>

Inheritance diagram for Transform:

[legend]
Collaboration diagram for Transform:

[legend]
List of all members.

Public Member Functions

NVSG_API | Transform (void)
Default-constructs a Transform.

NVSG_API | Transform (const Group &rhs)
Constructs a Transform from a Group.

NVSG_API | Transform (const Transform &rhs)
Constructs a Transform as a copy of another Transform.

virtual NVSG_API | ~Transform (void)
Destructs a Transform.

virtual NVSG_API const nvmath::Trafo & | getTrafo (void) const
Get the transformation represented by this Transform.

virtual NVSG_API void | setTrafo (const nvmath::Trafo &trafo)
Set the transformation for this Transform.

NVSG_API bool | isJoint () const
Test if a Transform is a Joint.

NVSG_API Transform & | operator= (const Transform &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other Transform.

Protected Member Functions

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Calculates the bounding box of this Transform.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this Transform.

NVSG_API void | incrementJointCount ()
Increments the number of references as a joint.

NVSG_API void | decrementJointCount ()
Decrements the number of references as a joint.

Detailed Description

Transform node.

Namespace: nvsg
Remarks:
A Transform is a special Group node. In addition to the children held by a Transform like a Group, it contains a transformation that is appended to the current transformation. The children then are positioned relative to this transformation.
See also:
Group

Constructor & Destructor Documentation

NVSG_API Transform ( void )

Default-constructs a Transform.

NVSG_API Transform ( const Group & rhs )

Constructs a Transform from a Group.

Parameters:
rhs Group to construct the Transform from.
Remarks:
This is kind of a partial copy constructor only copying the Group part from the source object.

NVSG_API Transform ( const Transform & rhs )

Constructs a Transform as a copy of another Transform.

virtual NVSG_API ~Transform ( void ) [virtual]

Destructs a Transform.

Member Function Documentation

const nvmath::Trafo & getTrafo ( void ) const [inline, virtual]

Get the transformation represented by this Transform.

Returns:
A reference to the constant nvmath::Trafo, representing the transformation.
See also:
nvmath::Trafo, setTrafo

Reimplemented in AnimatedTransform.

virtual NVSG_API void setTrafo ( const nvmath::Trafo & trafo ) [virtual]

Set the transformation for this Transform.

Parameters:
trafo A reference to the constant nvmath::Trafo to use.
Remarks:
The transformation trafo is copied to the internal one, and the bounding sphere of the Transform is invalidated.
See also:
nvmath::Trafo, getTrafo

Reimplemented in AnimatedTransform.

bool isJoint ( ) const [inline]

Test if a Transform is a Joint.

Returns:
true, if this Transform is a Joint, otherwise false.
Remarks:
When a Transform is added as a Joint to a Skin, its joint counter is incremented. If the joint counter of a Transform is positive, it is considered to be a Joint.

NVSG_API Transform& operator= ( const Transform & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant Transform to copy from
Returns:
A reference to the assigned Transform
Remarks:
The assignment operator calls the assignment operator of Group, and copies the transformation.
See also:
Group, nvmath::Trafo

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other Transform.

Parameters:
p | A reference to the constant Transform to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparsion; default is false.
Returns:
true if the Transform p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as a Group, they are equivalent if they have the same transformation.
See also:
Group, nvmath::Trafo

Reimplemented from Group.

Reimplemented in AnimatedTransform.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Calculates the bounding box of this Transform.

Returns:
The axis-aligned bounding box of this Transform.
Remarks:
This function is called by the framework when re-calculation of the bounding box is required for this Transform.

Reimplemented from Group.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this Transform.

Returns:
A nvmath::Sphere3f that contains the complete Transform.
Remarks:
This function is called by the framework to determine a sphere that completely contains the Transform. First, the bounding sphere of the Group is determined, then this sphere is transformed according to the transformation.

Reimplemented from Group.

NVSG_API void incrementJointCount ( ) [protected]

Increments the number of references as a joint.

Remarks:
A Transform can be used as a joint by a Skin. For each Skin, that uses this Transform, its joint count is incremented. Whenever a joint is removed from a Skin, the joint count of the corresponding Transform is decremented. That is, when the joint count is larger than zero, this Transform is a joint, otherwise it isn't. This function is exclusively used by the Skin class.
See also:
decrementJointCount

NVSG_API void decrementJointCount ( ) [protected]

Decrements the number of references as a joint.

Remarks:
A Transform can be used as a joint by a Skin. For each Skin, that uses this Transform, its joint count is incremented. Whenever a joint is removed from a Skin, the joint count of the corresponding Transform is decremented. That is, when the joint count is larger than zero, this Transform is a joint, otherwise it isn't. This function is exclusively used by the Skin class.
See also:
decrementJointCount

The documentation for this class was generated from the following file:
  • Transform.h
Generated on Tue Jan 15 10:29:22 2008 for NVSGSDK by NVIDIA


Member List

Transform Member List

This is the complete list of members for Transform, including all inherited members.
activateClipPlane(unsigned int index) | Group |
addChild(NodeHandle *child, unsigned int position=~0) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addLightSource(LightSourceHandle *lsHdl) | Group |
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const | Transform | [protected, virtual]
calculateBoundingSphere() const | Transform | [protected, virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
deactivateClipPlane(unsigned int index) | Group |
decrementJointCount() | Transform | [protected]
determineAnimationContainment() const | Group | [protected, virtual]
determineCgFxContainment() const | Group | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineLightContainment() const | Group | [protected, virtual]
determineLODContainment() const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
determineVolumeNodeContainment() const | Group | [protected, virtual]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getChild(unsigned int position) const | Group | [inline]
getChildPositions(NodeHandle *node, std::vector< unsigned int > &positions) const | Group |
getClipPlane(unsigned int index) const | Group | [inline]
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getLightSource(unsigned int index) const | Group | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfLightSources() const | Group | [inline]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getTrafo(void) const | Transform | [inline, virtual]
getUserData() const | Object | [inline]
Group() | Group |
Group(const Node &rhs) | Group | [explicit]
Group(const Group &rhs) | Group |
hasChild(NodeHandle *node) const | Group | [inline]
hasLightSource(LightSourceHandle *lsHdl) const | Group | [inline]
incrementJointCount() | Transform | [protected]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCaches(NodeHandle *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isClipPlaneActive(unsigned int index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Transform | [virtual]
isJoint() const | Transform | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Transform &rhs) | Transform |
nvsg::Group::operator=(const Group &rhs) | Group |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
postAddChild(unsigned int position) | Group | [protected, virtual]
postRemoveChild(unsigned int position) | Group | [protected, virtual]
preAddChild(unsigned int position) | Group | [protected, virtual]
preRemoveChild(unsigned int position) | Group | [protected, virtual]
removeChild(NodeHandle *child) | Group |
removeChild(unsigned int position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeLightSource(unsigned int index) | Group |
replaceChild(NodeHandle *newChild, NodeHandle *oldChild) | Group |
replaceChild(NodeHandle *newChild, unsigned int position) | Group |
replaceLightSource(unsigned int index, LightSourceHandle *lsHdl) | Group |
replaceLightSource(LightSourceHandle *newHdl, LightSourceHandle *oldHdl) | Group |
setAnnotation(const std::string &anno) | Object |
setClipPlane(unsigned int index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setTrafo(const nvmath::Trafo &trafo) | Transform | [virtual]
setUserData(const void *userData) | Object | [inline]
Transform(void) | Transform |
Transform(const Group &rhs) | Transform |
Transform(const Transform &rhs) | Transform |
validateIncarnation() const | Group | [virtual]
~Group() | Group | [virtual]
~Node() | Node | [virtual]
~Object() | Object | [virtual]
~Transform(void) | Transform | [virtual]
Generated on Tue Jan 15 10:29:22 2008 for NVSGSDK by NVIDIA


TransformElement Class Reference

Helper class to hold transformation information used in the render lists. More...

#include <TransformElement.h>

Inheritance diagram for TransformElement:

[legend]
Collaboration diagram for TransformElement:

[legend]
List of all members.

Public Member Functions

NVSG_API | TransformElement (void)
Default constructor.

NVSG_API | TransformElement (const nvmath::Mat44f &mtw, const nvmath::Mat44f &wtm, TransformElement *parent, nvsg::GroupHandle *transform, bool lengthPreserving, bool mirror, bool fixed)
Constructor of a TransformElement.

NVSG_API TransformElement * | getParent () const
Get the TransformElement that represents the parent of this transformation, in the scene graph.

NVSG_API const nvmath::Mat44f & | getModelToWorld () const
Get the model-to-world transformation from the top of the scene graph to this object.

NVSG_API nvsg::GroupHandle * | getTransform () const
Get the handle of the object that this TransformElement represents.

NVSG_API const nvmath::Mat44f & | getWorldToModel () const
Get the world-to-model transformation from the top of the scene graph to this object.

NVSG_API bool | isFixed () const
Query, if the matrices of this TransformElement are likely to change on each frame.

NVSG_API bool | isLengthPreserving () const
Query, if the matrices of this TransformElement are length preserving.

NVSG_API bool | isMirroring () const
Query, if the matrices of this TransformElement are mirroring.

NVSG_API void | updateMatrices (const nvmath::Mat44f &matrix, const nvmath::Mat44f &inverse)
Update the matrices of this TransformElement.

Detailed Description

Helper class to hold transformation information used in the render lists.

Remarks:
This class holds the current modelToWorld and worldToModel transformations, a flag indicating if the transformation is length preserving, a flag indicating that the transformation is mirroring, and finally a flag, indicating that the transformation is fixed, that is, it's not expected to change between two frames.
See also:
BaseRenderElement

Constructor & Destructor Documentation

TransformElement ( void ) [inline]

Default constructor.

Remarks:
The default constructor sets the model to world and the world to model transformations to the identity matrix, links to no parent or TransformHandle, and marks the transformation that no normalization is needed, no mirroring takes place, and it is expected to be fixed between consecutive frames.

TransformElement | ( | const nvmath::Mat44f & | mtw,
 |  | const nvmath::Mat44f & | wtm,
 |  | TransformElement * | parent,
 |  | nvsg::GroupHandle * | transform,
 |  | bool | lengthPreserving,
 |  | bool | mirror,
 |  | bool | fixed
 | ) | [inline]

Constructor of a TransformElement.

Parameters:
mtw | A reference to the constant model to world matrix.
wtm | A reference to the constant world to model matrix.
parent | A pointer to the TransformElement that represents the parent of this transformation, in the scene graph.
transform | A pointer to the GroupHandle, giving the transformation.
lengthPreserving | A flag, that specifies, if true, that this transformation preserves the length of vectors, such that they need not be renormalized before usage.
mirror | A flag, that specifies, if true, that this transformation mirrors vectors.
fixed | A flag, that specifies, if true, that this transformation is not to be expected to vary from frame to frame, and thus can be cached.
Remarks:
The constructor sets all the values of a TransformElement as the constructor arguments specify.

Member Function Documentation

TransformElement * getParent ( ) const [inline]

Get the TransformElement that represents the parent of this transformation, in the scene graph.

Returns:
A pointer to the TransformElement that represents the parent of this transformation, in the scene graph.
See also:
getTransform

const nvmath::Mat44f & getModelToWorld ( ) const [inline]

Get the model-to-world transformation from the top of the scene graph to this object.

Returns:
A constant reference to the combined transformation from top of the scene graph to this object.
See also:
getWorldToModel

nvsg::GroupHandle * getTransform ( ) const [inline]

Get the handle of the object that this TransformElement represents.

Returns:
A pointer to the handle of the object that this TransformElement represents.
See also:
getParent

const nvmath::Mat44f & getWorldToModel ( ) const [inline]

Get the world-to-model transformation from the top of the scene graph to this object.

Returns:
A constant reference to the combined transformation from top the scene graph to this object.
See also:
getModelToWorld

bool isFixed ( ) const [inline]

Query, if the matrices of this TransformElement are likely to change on each frame.

Returns:
true, if the matrices of this TransformElement can be considered to be constant from frame to frame, otherwise false.
Remarks:
The transformation of a TransformElement is likely to change on each frame, if it represents the transformation of a Billboard, for example, or it is a direct or indirect child of a Billboard.
See also:
getTransform, isLengthPreserving, isMirroring

bool isLengthPreserving ( ) const [inline]

Query, if the matrices of this TransformElement are length preserving.

Returns:
true, if the matrices of this TransformElement are length preserving, otherwise false.
Remarks:
If a matrix is not length preserving, any vector that is multiplied with it may need to be renormalized before further usage.
See also:
isFixed, isMirroring

bool isMirroring ( ) const [inline]

Query, if the matrices of this TransformElement are mirroring.

Returns:
true, if the matrices of this TransformElement are mirroring.
See also:
isFixed, isLengthPreserving

void updateMatrices | ( | const nvmath::Mat44f & | matrix,
 |  | const nvmath::Mat44f & | inverse
 | ) | [inline]

Update the matrices of this TransformElement.

Parameters:
matrix | The local model-to-world transformation.
inverse | The local world-to-model transformation.
Remarks:
The parent's modelToWorld matrix is premultiplied with matrix, and the parent's worldToModel matrix is postmultiplied with inverse to get the combined modelToWorld and worldToModel matrices, respectively, represented by this TransformElement.

The documentation for this class was generated from the following file:
  • TransformElement.h
Generated on Tue Jan 15 10:29:37 2008 for NVSGSDK by NVIDIA


Member List

TransformElement Member List

This is the complete list of members for TransformElement, including all inherited members.
addRef() | BaseRenderElement | [inline]
BaseRenderElement() | BaseRenderElement | [inline, protected]
BaseRenderElement(const BaseRenderElement &rhs) | BaseRenderElement | [inline, protected]
getModelToWorld() const | TransformElement | [inline]
getParent() const | TransformElement | [inline]
getRefCnt() const | BaseRenderElement | [inline]
getTransform() const | TransformElement | [inline]
getWorldToModel() const | TransformElement | [inline]
isFixed() const | TransformElement | [inline]
isLengthPreserving() const | TransformElement | [inline]
isMirroring() const | TransformElement | [inline]
removeRef() | BaseRenderElement | [inline]
TransformElement(void) | TransformElement | [inline]
TransformElement(const nvmath::Mat44f &mtw, const nvmath::Mat44f &wtm, TransformElement *parent, nvsg::GroupHandle *transform, bool lengthPreserving, bool mirror, bool fixed) | TransformElement | [inline]
updateMatrices(const nvmath::Mat44f &matrix, const nvmath::Mat44f &inverse) | TransformElement | [inline]
~BaseRenderElement() | BaseRenderElement | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:37 2008 for NVSGSDK by NVIDIA


TransformManipulator Class Reference

Base class for all kinds of transform manipulators. More...

#include <TransformManipulator.h>

Inheritance diagram for TransformManipulator:

[legend]
Collaboration diagram for TransformManipulator:

[legend]
List of all members.

Public Member Functions

NVSG_API | TransformManipulator ()
Default constructor.

virtual NVSG_API | ~TransformManipulator ()
Default destructor.

NVSG_API void | setTransformPath (const nvsg::Path *transformPath)
Set the nvsg::Path to the nvsg::Transform node.

NVSG_API const nvsg::Path * | getTransformPath () const
Get the nvsg::Path to the nvsg::Transform that currently is under control.

Protected Attributes

const nvsg::Path * | m_transformPath
Complete nvsg::Path to the nvsg::Transform node.

Detailed Description

Base class for all kinds of transform manipulators.

Namespace: nvui
Remarks:
This class is the base class for all manipulators working on nvsg::Transforms. The TransformManipulator needs a full path from the root of the tree to the controlled nvsg::Transform node.

See the TransformManipulatorViewer tutorial source code on how to use a Transform manipulator in your application.

If you use this manipulator your application must use a mechanism, such as using OnIdle() that calls updateFrame(). If updateFrame() returns true you should call triggerRedraw of the render area so the updated frame will be drawn. You will find some code samples in the description of the Manipulator class. Also the SimpleViewer tutorial source code shows how to use a manipulator with MFC, the ConsoleViewer tutorial source code shows the details on how to use a manipulator, and the ManipSampleViewer tutorial source code shows how to derive a new Manipulator class.
See also:
Manipulator

Constructor & Destructor Documentation

NVSG_API TransformManipulator ( )

Default constructor.

Remarks:
Initialize the TransformManipulator object.

virtual NVSG_API ~TransformManipulator ( ) [virtual]

Default destructor.

Remarks:
The destructor takes care of decrementing the reference count of the provided nvsg::Path object.
See also:
setTransformPath

Member Function Documentation

NVSG_API void setTransformPath ( const nvsg::Path * transformPath )

Set the nvsg::Path to the nvsg::Transform node.

Parameters:
transformPath Complete path to the nvsg::Transform node. Null is a valid value to disconnect the TransformManipulator from the controlled object.
Remarks:
Attach the Manipulator to the desired nvsg::Transform in the tree by providing a complete nvsg::Path from the root node to the nvsg::Transform node.
This class takes care of incrementing and decrementing the reference count of the provided nvsg::Path object.

The application is responsible to make sure that the nvsg::Path stays valid during the usage of the Manipulator.
See also:
getTransformPath

const nvsg::Path * getTransformPath ( ) const [inline]

Get the nvsg::Path to the nvsg::Transform that currently is under control.

Returns:
Path to the controlled nvsg::Transform. If the TransformManipulator is not connected this function returns NULL.
Remarks:
The application is responsible to make sure that the nvsg::Path stays valid during the usage of the Manipulator.
See also:
setTransformPath

Member Data Documentation

const nvsg::Path* m_transformPath [protected]

Complete nvsg::Path to the nvsg::Transform node.

The documentation for this class was generated from the following file:
  • TransformManipulator.h
Generated on Tue Jan 15 10:29:44 2008 for NVSGSDK by NVIDIA


Member List

TransformManipulator Member List

This is the complete list of members for TransformManipulator, including all inherited members.
getTransformPath() const | TransformManipulator | [inline]
isActive()=0 | Manipulator | [pure virtual]
m_renderArea | Manipulator | [protected]
m_transformPath | TransformManipulator | [protected]
Manipulator() | Manipulator |
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
setTransformPath(const nvsg::Path *transformPath) | TransformManipulator |
TransformManipulator() | TransformManipulator |
updateFrame()=0 | Manipulator | [pure virtual]
~Manipulator() | Manipulator | [virtual]
~TransformManipulator() | TransformManipulator | [virtual]
Generated on Tue Jan 15 10:29:44 2008 for NVSGSDK by NVIDIA


TransformStack Class Reference

Utility class to hold a stack of concatenated transformation matrices. More...

#include <TransformStack.h>

Collaboration diagram for TransformStack:

[legend]
List of all members.

Public Member Functions

TransformStack ()
Default constructor.

NVSG_API const nvmath::Mat44f & | getClipToModel (void) const
Get the transformation from clip space to model space.

NVSG_API const nvmath::Mat44f & | getClipToView (void) const
Get the transformation from clip space to view space.

NVSG_API const nvmath::Mat44f & | getModelToClip (void) const
Get the transformation from model space to clip space.

NVSG_API const nvmath::Mat44f & | getModelToView (void) const
Get the transformation from model space to view space.

NVSG_API const nvmath::Mat44f & | getModelToWorld (void) const
Get the transformation from model space to world space.

NVSG_API const nvmath::Mat44f & | getViewToClip (void) const
Get the transformation from view space to clip space.

NVSG_API const nvmath::Mat44f & | getViewToModel (void) const
Get the transformation from view space to model space.

NVSG_API const nvmath::Mat44f & | getViewToWorld (void) const
Get the transformation from view space to world space.

NVSG_API const nvmath::Mat44f & | getWorldToModel (void) const
Get the transformation from world space to model space.

NVSG_API const nvmath::Mat44f & | getWorldToView (void) const
Get the transformation from world space to view space.

NVSG_API unsigned int | getStackDepth (void) const
Get the depth of the model <-> world transformation stack.

NVSG_API void | popModelToWorld (void)
Pop the top element of the model <-> world transformation stack.

NVSG_API void | pushModelToWorld (const nvmath::Mat44f &modelWorld, const nvmath::Mat44f &worldModel)
Push a new pair of matrices on the model <-> world transformation stack.

NVSG_API void | setViewToClip (const nvmath::Mat44f &viewClip, const nvmath::Mat44f &clipView)
Set the pair of matrices for the view <-> clip transformation.

NVSG_API void | setWorldToView (const nvmath::Mat44f &worldView, const nvmath::Mat44f &viewWorld)
Set the pair of matrices for the world <-> view transformation.

Detailed Description

Utility class to hold a stack of concatenated transformation matrices.

This class makes it easy to maintain all steps of the transformation pipeline from model space via world space and view space to clip space (and vice versa).
Individiual objects are defined in an local coordinate system called model space. There is often a hierarchy of modeling coordinate systems that are maintained by this class by using popModelToWorld and pushModelToWorld.
Objects are then transformed into the world space.
The view space is used to define a view volume. This system is used so that, with the eye or camera at the origin looking toward -z, decreasing values of z are farther away from the eye, x is to the right and y is up.
From view space, we next go to the clip space, that is we're using the projection to get logical 2D device coordinates (In contrast to physical device coordinates, which additionally need the viewport information).

With these terms, the transformation pipeline looks like that:
   model <-> world <-> view <-> clip

Constructor & Destructor Documentation

TransformStack ( ) [inline]

Default constructor.

Initializes the model <-> world transformation stacks.

Member Function Documentation

const nvmath::Mat44f & getClipToModel ( void ) const [inline]

Get the transformation from clip space to model space.

const nvmath::Mat44f & getClipToView ( void ) const [inline]

Get the transformation from clip space to view space.

const nvmath::Mat44f & getModelToClip ( void ) const [inline]

Get the transformation from model space to clip space.

const nvmath::Mat44f & getModelToView ( void ) const [inline]

Get the transformation from model space to view space.

const nvmath::Mat44f & getModelToWorld ( void ) const [inline]

Get the transformation from model space to world space.

const nvmath::Mat44f & getViewToClip ( void ) const [inline]

Get the transformation from view space to clip space.

const nvmath::Mat44f & getViewToModel ( void ) const [inline]

Get the transformation from view space to model space.

const nvmath::Mat44f & getViewToWorld ( void ) const [inline]

Get the transformation from view space to world space.

const nvmath::Mat44f & getWorldToModel ( void ) const [inline]

Get the transformation from world space to model space.

const nvmath::Mat44f & getWorldToView ( void ) const [inline]

Get the transformation from world space to view space.

unsigned int getStackDepth ( void ) const [inline]

Get the depth of the model <-> world transformation stack.

void popModelToWorld ( void ) [inline]

Pop the top element of the model <-> world transformation stack.

void pushModelToWorld | ( | const nvmath::Mat44f & | modelWorld,
 |  | const nvmath::Mat44f & | worldModel
 | ) | [inline]

Push a new pair of matrices on the model <-> world transformation stack.

Note:
modelWorld and worldModel should be inverse to each other to get correct results.
Parameters:
modelWorld | additional model to world transformation
worldModel | additional world to model transformation

void setViewToClip | ( | const nvmath::Mat44f & | viewClip,
 |  | const nvmath::Mat44f & | clipView
 | ) | [inline]

Set the pair of matrices for the view <-> clip transformation.

Note:
viewClip and clipView should be inverse to each other to get correct results.
Parameters:
viewClip | new view to clip transformation (projection)
clipView | new clip to view transformation

void setWorldToView | ( | const nvmath::Mat44f & | worldView,
 |  | const nvmath::Mat44f & | viewWorld
 | ) | [inline]

Set the pair of matrices for the world <-> view transformation.

Note:
worldView and viewWorld should be inverse to each other to get correct results.
Parameters:
worldView | new world to view transformation
viewWorld | new view to world transformation

The documentation for this class was generated from the following file:
  • TransformStack.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

TransformStack Member List

This is the complete list of members for TransformStack, including all inherited members.
getClipToModel(void) const | TransformStack | [inline]
getClipToView(void) const | TransformStack | [inline]
getModelToClip(void) const | TransformStack | [inline]
getModelToView(void) const | TransformStack | [inline]
getModelToWorld(void) const | TransformStack | [inline]
getStackDepth(void) const | TransformStack | [inline]
getViewToClip(void) const | TransformStack | [inline]
getViewToModel(void) const | TransformStack | [inline]
getViewToWorld(void) const | TransformStack | [inline]
getWorldToModel(void) const | TransformStack | [inline]
getWorldToView(void) const | TransformStack | [inline]
popModelToWorld(void) | TransformStack | [inline]
pushModelToWorld(const nvmath::Mat44f &modelWorld, const nvmath::Mat44f &worldModel) | TransformStack | [inline]
setViewToClip(const nvmath::Mat44f &viewClip, const nvmath::Mat44f &clipView) | TransformStack | [inline]
setWorldToView(const nvmath::Mat44f &worldView, const nvmath::Mat44f &viewWorld) | TransformStack | [inline]
TransformStack() | TransformStack | [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Traverser Class Reference

Virtual base class providing the common interface part of ExclusiveTraverser and SharedTraverser. More...

#include <Traverser.h>

Inheritance diagram for Traverser:

[legend]
Collaboration diagram for Traverser:

[legend]
List of all members.

Public Member Functions

NVSG_API void | setScene (nvsg::SceneHandle *scene)
Set a Scene to be used with this Traverser.

NVSG_API void | setViewState (nvsg::ViewStateHandle *viewState)
Set a ViewState to be used with this Traverser.

NVSG_API void | apply (nvsg::NodeHandle *root)
Start traversal from a specified node.

NVSG_API void | apply (nvsg::SceneHandle *scene)
Start the traversal of a Scene.

NVSG_API void | interruptTraversal ()
Immediately interrupt the current traversal.

NVSG_API bool | wasTraversalInterrupted ()
Check for traversal interruption.

Protected Types

enum {
NVSG_SCENE_DIRTY = BIT0, NVSG_ROOT_DIRTY = BIT1, NVSG_CULLTREE_DIRTY = BIT2, NVSG_TREE_DIRTY_MASK = NVSG_SCENE_DIRTY | NVSG_ROOT_DIRTY | NVSG_CULLTREE_DIRTY,
NVSG_VIEWSTATE_DIRTY = BIT3, NVSG_TRAVERSAL_INTERRUPTED = BIT4
}

Protected Member Functions

NVSG_API | Traverser ()
Default constructor.

virtual NVSG_API | ~Traverser ()
Protected destructor to prevent instantiation.

virtual NVSG_API void | lockViewState ()=0
Interface for locking the ViewState.

virtual NVSG_API void | unlockViewState ()=0
Interface for unlocking the ViewState.

virtual NVSG_API void | lockScene ()=0
Interface for locking the Scene.

virtual NVSG_API void | unlockScene ()=0
Interface for unlocking the Scene.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)=0
Interface for initiating the traversal.

virtual NVSG_API const nvsg::Object * | lockObject (nvsg::ObjectHandle *obj)=0
Interface for locking an Object.

virtual NVSG_API void | unlockObject (nvsg::ObjectHandle *obj)=0
Interface for unlocking an Object.

NVSG_API void | traverseObject (nvsg::ObjectHandle *obj)
Start traversing an ObjectHandle.

template<typename T> void | traverseObject (nvsg::ObjectHandle *obj, T arg)
Template to start traversal of an ObjectHandle with one arbitrary argument.

virtual NVSG_API bool | preApply (nvsg::NodeHandle *root)
Notifier called from the framework directly before traversal starts.

virtual NVSG_API void | postApply (nvsg::NodeHandle *root)
Notifier called from the framework directly after traversal.

virtual NVSG_API bool | preTraverseGroup (const nvsg::Group *grp)
Notifier called from the framework directly before a Group is traversed.

virtual NVSG_API void | postTraverseGroup (const nvsg::Group *grp)
Notifier called from the framework directly after a Group has been traversed.

virtual NVSG_API bool | preTraverseDrawables (const nvsg::GeoNode *gnode, unsigned int geomIndex)
Notifier called from the framework directly before the Drawable objects associated with one StateSet are traversed.

virtual NVSG_API void | postTraverseDrawables (const nvsg::GeoNode *gnode, unsigned int geomIndex)
Notifier called from the framework directly after the Drawable objects associated with one StateSet have been traversed.

template<typename T> void | traverseGroup (const T *grp)
Dispatcher to the particular overrides to traverse Group-derived Nodes.

NVSG_API void | traverseGeoNode (const nvsg::GeoNode *gnode)
Traversal of a GeoNode.

NVSG_API void | traverseShape (const nvsg::Shape *shape)
Traversal of a Shape.

NVSG_API void | traverseStateVariant (const nvsg::StateVariant *variant)
Traversal of a StateVariant.

NVSG_API void | traverseStatePass (const nvsg::StatePass *pass)
Traversal of a StatePass.

NVSG_API void | traverseTextureAttribute (const nvsg::TextureAttribute *texAttrib)
Traversal of a TextureAttribute.

NVSG_API void | traverseMapList (const nvsg::MapList *mapList)
Traversal of a MapList.

NVSG_API void | traverseVolumeNode (const nvsg::VolumeNode *volNode)
Traversal of a VolumeNode.

NVSG_API void | evaluateCullTree (const nvsg::ViewState *viewState)
Evaluate the current state of the cull tree.

Protected Attributes

std::stack< const nvsg::CullData * > | m_cullStack
The stack of CullData corresponding to the currently traversed tree.

unsigned int | m_currentAttrib
std::stack< unsigned int > | m_lodStack
The stack of LOD level; top is the current level.

size_t | m_lodCheckSum
size_t | m_lastLodCheckSum
nvutil::MemFunTbl< Traverser > m_mftbl
The table of handler functions.

nvutil::ProblemLog | m_problemLog
Problems occurred during construction go here.

nvsg::NodeHandle * m_root
A pointer to the current root node.

nvsg::SceneHandle * m_scene
A pointer to the current scene.

unsigned int | m_traverserBits
The bitfield of flags for a Traverser.

nvsg::ViewStateHandle * m_viewState
A pointer to the current view state.

bool volatile | m_interrupt
A flag, indicating an interrupt request.

Detailed Description

Virtual base class providing the common interface part of ExclusiveTraverser and SharedTraverser.

Remarks:
A traverser serves as a link between a scene graph and a defined operation to be performed on the scene graph. That is, according to a certain scene graph's hierarchy, a traverser iterates over all scene graph components and performs a defined operation for each by means of an overloadable handler routine. The Traverser class offers base functionality for all traversers. There are two traversers derived from Traverser: SharedTraverser and ExclusiveTraverser, that provide read-only access and read-write access, respectively, to the elements of the scene graph.
See also:
ExclusiveTraverser, SharedTraverser

Constructor & Destructor Documentation

NVSG_API Traverser ( ) [protected]

Default constructor.

Note:
The constructor is protected, and hence, a Traverser object cannot be instantiated directly, but only by deriving from Traverser.

virtual NVSG_API ~Traverser ( ) [protected, virtual]

Protected destructor to prevent instantiation.

Member Function Documentation

NVSG_API void setScene ( nvsg::SceneHandle * scene )

Set a Scene to be used with this Traverser.

Parameters:
scene A pointer to the SceneHandle to be used.
Remarks:
If scene is a different pointer than the current Scene pointer, its reference count is incremented and the reference count of a previously set Scene is decremented. Any caches for the Scene are marked as invalid.
See also:
setViewState

NVSG_API void setViewState ( nvsg::ViewStateHandle * viewState )

Set a ViewState to be used with this Traverser.

Parameters:
viewState A pointer to the ViewStateHandle to be used.
Remarks:
If viewState is a different pointer than the current ViewState pointer, its reference count is incremented and the reference count of a previously set ViewState is decremented. Any caches for the ViewState and the cull tree are marked as invalid.
See also:
setScene

NVSG_API void apply ( nvsg::NodeHandle * root )

Start traversal from a specified node.

Parameters:
root A pointer to the NodeHandle to start traversal with.
Remarks:
If preApply is successful, the Scene and the ViewState are locked, the traversal is executed by calling doApply, the Scene and the ViewState are unlocked again, and postApply is called with root.
Note:
Some traverser need a valid ViewState object which has to be set via setViewState.
See also:
apply

NVSG_API void apply ( nvsg::SceneHandle * scene )

Start the traversal of a Scene.

Parameters:
scene A pointer to the SceneHandle to traverse.
Remarks:
This convenience function simply sets the SceneHandle pointer scene via setScene, and initiates the traversal from the root node of scene.
See also:
setScene, apply

void interruptTraversal ( ) [inline]

Immediately interrupt the current traversal.

Remarks:
After this function has been called, no more Nodes are visited in the current traversal. The traversal point is back-tracked to the root without initiating any new actions.
Note:
This function is especially useful in a multithreaded environment, where one thread traverses a Scene while an other thread is allowed to interrupt the traversal under some circumstances.
See also:
wasTraversalInterrupted

bool wasTraversalInterrupted ( ) [inline]

Check for traversal interruption.

Returns:
true if the traversal was interrupted, otherwise false.
Note:
This function is especially useful if an operation on a Scene is a complex one, that needs multiple traversals. If one of those traversals was interrupted, the following traversals should be omitted.
See also:
interruptTraversal

virtual NVSG_API void lockViewState ( ) [protected, pure virtual]

Interface for locking the ViewState.

Remarks:
This function is called from the framework when the ViewState set by setViewState is to be locked.
See also:
setViewState, unlockViewState

Implemented in GLUploadTraverser, SharedModelViewTraverser, ExclusiveModelViewTraverser, SharedTraverser, and ExclusiveTraverser.

virtual NVSG_API void unlockViewState ( ) [protected, pure virtual]

Interface for unlocking the ViewState.

Remarks:
This function is called from the framework when the ViewState set by setViewState is to be unlocked.
See also:
setViewState, lockViewState

Implemented in SharedModelViewTraverser, ExclusiveModelViewTraverser, SharedTraverser, and ExclusiveTraverser.

virtual NVSG_API void lockScene ( ) [protected, pure virtual]

Interface for locking the Scene.

Remarks:
This function is called from the framework when the Scene set by setScene is to be locked.
See also:
setScene, unlockScene

Implemented in SharedTraverser, and ExclusiveTraverser.

virtual NVSG_API void unlockScene ( ) [protected, pure virtual]

Interface for unlocking the Scene.

Remarks:
This function is called from the framework when the Scene set by setScene is to be unlocked.
See also:
setScene, lockScene

Implemented in SharedTraverser, and ExclusiveTraverser.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, pure virtual]

Interface for initiating the traversal.

Parameters:
root A pointer to the NodeHandle to start traversal at.
Remarks:
This function is called from the framework after the Scene and the ViewState, if set, are locked. The actual traversal is assumed to be done here.
See also:
preApply, postApply, lockScene, unlockScene, lockViewState, unlockViewState

Implemented in WRLLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, AppTraverser, CullTraverser, DestrippingTraverser, EliminateTraverser, FrustumCullTraverser, GLTraverser, GLUploadTraverser, NormalizeTraverser, OptimizeTraverser, RayIntersectTraverser, RenderTraverser, SearchTraverser, SmoothTraverser, SharedTraverser, ExclusiveTraverser, UnifyTraverser, and VertexUnifyTraverser.

virtual NVSG_API const nvsg::Object* lockObject ( nvsg::ObjectHandle * obj ) [protected, pure virtual]

Interface for locking an Object.

Parameters:
obj A pointer to the ObjectHandle to lock.
Returns:
A pointer to a constant Object.
Remarks:
This function is called from the framework on traversing the ObjectHandle obj.
See also:
unlockObject, ExclusiveTraverser::lockObject, SharedTraverser::lockObject

Implemented in SharedTraverser, and ExclusiveTraverser.

virtual NVSG_API void unlockObject ( nvsg::ObjectHandle * obj ) [protected, pure virtual]

Interface for unlocking an Object.

Parameters:
obj A pointer to the ObjectHandle to unlock.
Remarks:
This function is called from the framework right after traversal of obj.
See also:
lockObject

Implemented in SharedTraverser, and ExclusiveTraverser.

void traverseObject ( nvsg::ObjectHandle * obj ) [inline, protected]

Start traversing an ObjectHandle.

Parameters:
obj A pointer to the ObjectHandle to traverse.
Remarks:
If the traversal was interrupted, the function immediately returns. Otherwise the Object is locked using lockObject, traversed by calling the corresponding handler function, and unlocked again using unlockObject.
Note:
The behavior is undefined if obj points to an invalid location.
See also:
lockObject, unlockObject, traverseObject

void traverseObject | ( | nvsg::ObjectHandle * | obj,
 |  | T | arg
 | ) | [inline, protected]

Template to start traversal of an ObjectHandle with one arbitrary argument.

Parameters:
obj | A pointer to the ObjectHandle to traverse.
arg | The value to use as the second argument on traversal.
Remarks:
If the traversal was interrupted, the function immediately returns. Otherwise the Object is locked using lockObject, traversed by calling the corresponding handler function, and unlocked again using unlockObject.
Note:
The behavior is undefined if obj points to an invalid location.
See also:
lockObject, unlockObject, traverseObject

virtual NVSG_API bool preApply ( nvsg::NodeHandle * root ) [protected, virtual]

Notifier called from the framework directly before traversal starts.

Parameters:
root A pointer to NodeHandle to be traversed.
Returns:
The default implementation always return true in order to continue traversal of root to proceed.
Remarks:
Custom traversers might override this notifier to process some pre-traversal work. A customized preApply notifier should return true to force the traversal of the specified root node to proceed. Returning false prevents the specified root node from being traversed.
At the time of call, a custom override can rely on the optional Scene and the optional ViewState both _not_ being locked for read or write access by the calling thread.
Note:
If the function returns false, traversal of root is skipped.

Not calling the base implementation might result in undefined runtime behavior.

Example:
    MyTraverser::doApply( nvsg::NodeHandle * root )
    {
      //  Do some pre-traversal bookholding or whatever
      //  ...

      //  call the base implementation and return
      return( Traverser::preApply( root ) );
    }
See also:
postApply

Reimplemented in NVSGSaveTraverser.

virtual NVSG_API void postApply ( nvsg::NodeHandle * root ) [protected, virtual]

Notifier called from the framework directly after traversal.

Parameters:
root A pointer to a NodeHandle that was just traversed.
Remarks:
Custom traversers might override this notifier to process some post-traversal work. It is strongly recommended for custom overrides to call the base implementation in their code.
At the time of call, a custom override can rely on the optional Scene and the optional ViewState both _not_ being locked for read or write access by the calling thread.
Note:
Not calling the base implementation might result in undefined runtime behavior.
See also:
preApply

Reimplemented in CullTraverser, and IdentityToGroupTraverser.

virtual NVSG_API bool preTraverseGroup ( const nvsg::Group * grp ) [protected, virtual]

Notifier called from the framework directly before a Group is traversed.

Parameters:
grp A pointer to the constant Group to traverse.
Returns:
The default implementation always returns true, in order to continue traversal.
Remarks:
Custom traversers can override this function for any tasks that need to be done directly before the Group grp is traversed.
Note:
If the function returns false, traversal of grp is skipped.

Not calling the base implementation might result in undefined runtime behavior.

See also:
postTraverseGroup

Reimplemented in RayIntersectTraverser, and RenderTraverser.

virtual NVSG_API void postTraverseGroup ( const nvsg::Group * grp ) [protected, virtual]

Notifier called from the framework directly after a Group has been traversed.

Parameters:
grp A pointer to the constant Group that was just traversed.
Remarks:
Custom traversers can override this function for any tasks that need to be done directly after the Group grp has been traversed.
Note:
Not calling the base implementation might result in undefined runtime behavior.
See also:
preTraverseGroup

Reimplemented in RayIntersectTraverser, and RenderTraverser.

virtual NVSG_API bool preTraverseDrawables | ( | const nvsg::GeoNode * | gnode,
 |  | unsigned int | geomIndex
 | ) | [protected, virtual]

Notifier called from the framework directly before the Drawable objects associated with one StateSet are traversed.

Parameters:
gnode | A pointer to the constant GeoNode currently traversed.
geomIndex | Index of the StateSet in gnode associated with the Drawable objects that are going to be traversed.
Returns:
The default implementation always returns true to continue traversal.
Remarks:
Custom traversers can override this function for any tasks that need to be done directly before the Drawable objects of the GeoNode gnode associated with the StateSet of gnode at index geomIndex are traversed.
Note:
If the function returns false, traversal of the specified Drawable objects is skipped.

Not calling the base implementation might result in undefined runtime behavior.

See also:
postTraverseDrawables

Reimplemented in CombineTraverser, and RenderTraverser.

virtual NVSG_API void postTraverseDrawables | ( | const nvsg::GeoNode * | gnode,
 |  | unsigned int | geomIndex
 | ) | [protected, virtual]

Notifier called from the framework directly after the Drawable objects associated with one StateSet have been traversed.

Parameters:
gnode | A pointer to the constant GeoNode currently traversed.
geomIndex | Index of the StateSet in gnode associated with the Drawable objects that were just traversed.
Remarks:
Custom traversers can override this function for any tasks that need to be done directly after the Drawable objects of the GeoNode gnode associated with the StateSet of gnode at index geomIndex are traversed.
Note:
Not calling the base implementation might result in undefined runtime behavior.
See also:
preTraverseDrawables

Reimplemented in RenderTraverser.

void traverseGroup ( const T * grp ) [protected]

Dispatcher to the particular overrides to traverse Group-derived Nodes.

Parameters:
grp A pointer to the constant Group-derived Node to traverse.
Remarks:
If preTraverseGroup() returned true, the lights contained in grp are traversed, and then, depending on the cull state of grp and it's actual type a special traversal is performed. After that, postTraverseGroup() is called.
See also:
preTraverseGroup, postTraverseGroup

NVSG_API void traverseGeoNode ( const nvsg::GeoNode * gnode ) [protected]

Traversal of a GeoNode.

Parameters:
gnode A pointer to the constant GeoNode to traverse.
Remarks:
Depending on the cull state of gnode, all Drawable objects of the GeoNode, that are at least partially visible, are traversed.
See also:
preTraverseDrawables, postTraverseDrawables

NVSG_API void traverseShape ( const nvsg::Shape * shape ) [protected]

Traversal of a Shape.

Parameters:
shape A pointer to the constant Shape to traverse.
Remarks:
Traverses all PrimitiveSet objects of shape.

NVSG_API void traverseStateVariant ( const nvsg::StateVariant * variant ) [protected]

Traversal of a StateVariant.

Parameters:
variant A pointer to the constant StateVariant to traverse.
Remarks:
Traverses all StatePass objects of variant.
See also:
traverseStatePass

NVSG_API void traverseStatePass ( const nvsg::StatePass * pass ) [protected]

Traversal of a StatePass.

Parameters:
pass A pointer to the constant StatePass to traverse.
Remarks:
Traverses all StateAttribute objects of pass.
See also:
traverseStateVariant

NVSG_API void traverseTextureAttribute ( const nvsg::TextureAttribute * texAttrib ) [protected]

Traversal of a TextureAttribute.

Parameters:
texAttrib A pointer to the constant TextureAttribute to traverse.
Remarks:
Traverses all TextureAttributeItem objects of texAttrib.

NVSG_API void traverseMapList ( const nvsg::MapList * mapList ) [protected]

Traversal of a MapList.

Parameters:
mapList A pointer to the constant MapList to traverse.
Remarks:
A ViewState holds a MapList, containing two-dimensional maps, that can be used to render, for example, overlays for menus or textual information to top of the scene. That MapList is traversed here.
See also:
ViewState::setMapList, ViewState::getMapList

NVSG_API void traverseVolumeNode ( const nvsg::VolumeNode * volNode ) [protected]

Traversal of a VolumeNode.

Parameters:
volNode A pointer to the constant VolumeNode to traverse.
Remarks:
Traverses the associated shader (a CgFx object) and the VolumeBrick objects that are at least partially visible.

NVSG_API void evaluateCullTree ( const nvsg::ViewState * viewState ) [protected]

Evaluate the current state of the cull tree.

Parameters:
viewState A pointer to the constant ViewState whose cull tree is evaluated
Remarks:
This function is used in the implementation of ExclusiveTraverser and SharedTraverser.

Member Data Documentation

std::stack<const nvsg::CullData *> m_cullStack [protected]

The stack of CullData corresponding to the currently traversed tree.

std::stack<unsigned int> m_lodStack [protected]

The stack of LOD level; top is the current level.

nvutil::MemFunTbl<Traverser> m_mftbl [protected]

The table of handler functions.

nvutil::ProblemLog m_problemLog [protected]

Problems occurred during construction go here.

nvsg::NodeHandle* m_root [protected]

A pointer to the current root node.

nvsg::SceneHandle* m_scene [protected]

A pointer to the current scene.

unsigned int m_traverserBits [protected]

The bitfield of flags for a Traverser.

nvsg::ViewStateHandle* m_viewState [protected]

A pointer to the current view state.

bool volatile m_interrupt [protected]

A flag, indicating an interrupt request.

The documentation for this class was generated from the following file:
  • Traverser.h
Generated on Tue Jan 15 10:29:37 2008 for NVSGSDK by NVIDIA


Member List

Traverser Member List

This is the complete list of members for Traverser, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root)=0 | Traverser | [protected, pure virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj)=0 | Traverser | [protected, pure virtual]
lockScene()=0 | Traverser | [protected, pure virtual]
lockViewState()=0 | Traverser | [protected, pure virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj)=0 | Traverser | [protected, pure virtual]
unlockScene()=0 | Traverser | [protected, pure virtual]
unlockViewState()=0 | Traverser | [protected, pure virtual]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
Generated on Tue Jan 15 10:29:37 2008 for NVSGSDK by NVIDIA


TriangleFilter Class Reference

ScaleFilter functor providing triangle filter functionality. More...

#include <TextureImage.h>

Inheritance diagram for TriangleFilter:

[legend]
Collaboration diagram for TriangleFilter:

[legend]
List of all members.

Public Member Functions

NVSG_API float | getSupportWidth (void) const
Get the support width of the TriangleFilter.

NVSG_API float | operator() (float t) const
Weight calculation operator.

Detailed Description

ScaleFilter functor providing triangle filter functionality.

A TriangleFilter has a support width of 1.0. For distances t between source and destination texel of up to 1.0, the weight is ( 1.0 - t ), otherwise 0.0.

Member Function Documentation

float getSupportWidth ( void ) const [inline, virtual]

Get the support width of the TriangleFilter.

Returns:
the support width of the TriangleFilter is 1.0.

Implements ScaleFilter.

float operator() ( float t ) const [inline, virtual]

Weight calculation operator.

Returns:
( 1.0 - t ), if t is less than or equal to 1.0, otherwise 0.0.

Implements ScaleFilter.

The documentation for this class was generated from the following file:
  • TextureImage.h
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Member List

TriangleFilter Member List

This is the complete list of members for TriangleFilter, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
getSupportWidth(void) const | TriangleFilter | [inline, virtual]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator()(float t) const | TriangleFilter | [inline, virtual]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Tue Jan 15 10:29:21 2008 for NVSGSDK by NVIDIA


Triangles Class Reference

IndependentPrimitiveSet for triangles. More...

#include <Triangles.h>

Inheritance diagram for Triangles:

[legend]
Collaboration diagram for Triangles:

[legend]
List of all members.

Public Member Functions

NVSG_API | Triangles ()
Default-constructs a Triangles.

NVSG_API | Triangles (const IndependentPrimitiveSet &rhs)
Constructs a Triangles from an IndependentPrimitiveSet.

NVSG_API | Triangles (const PrimitiveSet &rhs)
Constructs a Triangles from a PrimitiveSet.

NVSG_API | Triangles (const Triangles &rhs)
Constructs a Triangles as a copy from another Triangles.

virtual NVSG_API | ~Triangles ()
Destructs a Triangles.

NVSG_API bool | hasFaces () const
Query if this Triangles has faces.

NVSG_API unsigned int | getNumberOfFaces () const
Get the number of triangular faces.

NVSG_API const Face3 * | getFaces () const
Get a pointer to the faces.

NVSG_API void | setFaces (const Face3 *faces, unsigned int numFaces)
Set the faces of this Triangles.

NVSG_API void | setFaces (unsigned int pos, const Face3 *faces, unsigned int numFaces)
Set a subset of faces of this Triangles.

NVSG_API Triangles & | operator= (const Triangles &rhs)
Assignment operator.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (Triangles *t, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2)
Generate tangents and binormals for a Triangles.

NVSG_API void | generateNormals (Triangles *t)
Generate normals for a Triangles.

Detailed Description

IndependentPrimitiveSet for triangles.

Namespace: nvsg
Remarks:
A Triangles is an IndependentPrimitiveSet that holds an array of index-triples. Each of these triples describe a triangle with the indices pointing in the array of vertices. All vertex attributes (like normal, texture,...) are indexed with the same index.
See also:
IndependentPrimitiveSet, Points, Lines, Quads

Constructor & Destructor Documentation

NVSG_API Triangles ( )

Default-constructs a Triangles.

NVSG_API Triangles ( const IndependentPrimitiveSet & rhs )

Constructs a Triangles from an IndependentPrimitiveSet.

NVSG_API Triangles ( const PrimitiveSet & rhs )

Constructs a Triangles from a PrimitiveSet.

NVSG_API Triangles ( const Triangles & rhs )

Constructs a Triangles as a copy from another Triangles.

virtual NVSG_API ~Triangles ( ) [virtual]

Destructs a Triangles.

Member Function Documentation

bool hasFaces ( ) const [inline]

Query if this Triangles has faces.

Returns:
true, if this Triangles has at least three indices, otherwise false.
Remarks:
Each triple of successive indices represent one triangular face.
See also:
getNumberOfFaces, getFaces, setFaces

unsigned int getNumberOfFaces ( ) const [inline]

Get the number of triangular faces.

Returns:
The number of indices of this Triangles divided by three.
Remarks:
Each triple of successive indices represent one triangular face.
See also:
hasFaces, getFaces, setFaces

const Face3 * getFaces ( ) const [inline]

Get a pointer to the faces.

Returns:
A pointer to the constant indices of this IndependentPrimitiveSet.
Remarks:
Each triple of successive indices represent one triangular face.
See also:
hasFaces, getNumberOfFaces, setFaces

void setFaces | ( | const Face3 * | faces,
 |  | unsigned int | numFaces
 | ) | [inline]

Set the faces of this Triangles.

Parameters:
faces | A pointer to the constant faces to use.
numFaces | The number of faces, with three indices per face.
Remarks:
Copies three times numFaces indices from faces into this Triangles by just calling the appropriate setIndices.
Note:
The behavior is undefined if there are less than numFaces values of type nvsg::Face3 located at faces.
See also:
hasFaces, getNumberOfFaces, getFaces

void setFaces | ( | unsigned int | pos,
 |  | const Face3 * | faces,
 |  | unsigned int | numFaces
 | ) | [inline]

Set a subset of faces of this Triangles.

Parameters:
pos | The start position inside the range of pre-existing faces.
faces | A pointer to the constant faces to use.
numFaces | The number of faces.
Remarks:
Copies three times numFaces indices from faces into this Triangles, starting at position three times pos inside the range of pre-existing indices.
Pre-existing indices in the range [3*pos, 3*(pos + numFaces)) will be replaced. Pre-existing indices outside this range remain untouched.
If you specifiy (-1) for pos or pos specifies the number of faces currently stored, the faces pointed to by faces will be appended to the pre-existing faces.
Note:
The behavior is undefined if pos is neither a valid position inside the range of pre-existing faces, nor the number of faces currently stored, nor (-1).

The behaviour is undefined if there are less than numFaces values of type Face3 located at segments.

See also:
hasFaces, getNumberOfFaces, getFaces

NVSG_API Triangles& operator= ( const Triangles & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant Triangles to copy from.
Returns:
A reference to the assigned Triangles.
Remarks:
The assignment operator calls the assignment operator of IndependentPrimitiveSet.

Friends And Related Function Documentation

NVSG_API void calculateTangentSpace | ( | Triangles * | t,
 |  | unsigned int | tu = 0,
 |  | unsigned int | tg = 1,
 |  | unsigned int | bn = 2
 | ) | [related]

Generate tangents and binormals for a Triangles.

Parameters:
t | A pointer to the constant Triangles to create tangents and binormals for.
tu | The optional texture unit that holds texture coordinates to use; default is 0.
tg | The optional texture unit that is going to hold the tangents; default is 1.
bn | The optional texture unit that is going to hold the binormals; default is 2.
Remarks:
This routine calculates tangents and binormals for every vertex in the Triangles t. The tangent points along the second component of the texture parameterization. The binormal is calculated by the cross product of the normal and the tangent at that vertex.

NVSG_API void generateNormals ( Triangles * t ) [related]

Generate normals for a Triangles.

Parameters:
t A pointer to the constant Triangles to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • Triangles.h
Generated on Tue Jan 15 10:29:22 2008 for NVSGSDK by NVIDIA


Member List

Triangles Member List

This is the complete list of members for Triangles, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | IndependentPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
calculateTangentSpace(Triangles *t, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2) | Triangles | [related]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
generateNormals(Triangles *t) | Triangles | [related]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getFaces() const | Triangles | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getName() const | Object |
getNumberOfFaces() const | Triangles | [inline]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasFaces() const | Triangles | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const Triangles &rhs) | Triangles |
nvsg::IndependentPrimitiveSet::operator=(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setFaces(const Face3 *faces, unsigned int numFaces) | Triangles | [inline]
setFaces(unsigned int pos, const Face3 *faces, unsigned int numFaces) | Triangles | [inline]
setIndices(const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setIndices(unsigned int pos, const unsigned int *indices, unsigned int numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
Triangles() | Triangles |
Triangles(const IndependentPrimitiveSet &rhs) | Triangles |
Triangles(const PrimitiveSet &rhs) | Triangles |
Triangles(const Triangles &rhs) | Triangles |
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~Triangles() | Triangles | [virtual]
Generated on Tue Jan 15 10:29:22 2008 for NVSGSDK by NVIDIA


TriangulateTraverser Class Reference

Traverser that converts all flavors of quads to triangles. More...

#include <TriangulateTraverser.h>

Inheritance diagram for TriangulateTraverser:

[legend]
Collaboration diagram for TriangulateTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | TriangulateTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~TriangulateTraverser (void)
Protected destructor to prevent instantiation of a StrippingTraverser.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *p)
Handle a GeoNode object.

virtual NVSG_API void | handleQuads (nvsg::Quads *p)
Handle a Quads object.

virtual NVSG_API void | handleQuadStrips (nvsg::QuadStrips *p)
Handle a QuadStrips object.

Detailed Description

Traverser that converts all flavors of quads to triangles.

Converts Quads to Triangles, and QuadStrips to TriangleStrips.

Constructor & Destructor Documentation

NVSG_API TriangulateTraverser ( void )

Constructor.

virtual NVSG_API ~TriangulateTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a StrippingTraverser.

Member Function Documentation

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * p ) [protected, virtual]

Handle a GeoNode object.

The GeoNode is the primary object for quads-to-triangles conversion.

Parameters:
p GeoNode to handle

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuads ( nvsg::Quads * p ) [protected, virtual]

Handle a Quads object.

Replaces a Quads object by a Triangles object.

Parameters:
p Quads to handle

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadStrips ( nvsg::QuadStrips * p ) [protected, virtual]

Handle a QuadStrips object.

Replaces a QuadStrips object by a TrianglesStrips object.

Parameters:
p QuadStrips to handle

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • TriangulateTraverser.h
Generated on Tue Jan 15 10:29:39 2008 for NVSGSDK by NVIDIA


Member List

TriangulateTraverser Member List

This is the complete list of members for TriangulateTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | ExclusiveTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *p) | TriangulateTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *p) | TriangulateTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *p) | TriangulateTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
TriangulateTraverser(void) | TriangulateTraverser |
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
~TriangulateTraverser(void) | TriangulateTraverser | [protected, virtual]
Generated on Tue Jan 15 10:29:39 2008 for NVSGSDK by NVIDIA


TriFans Class Reference

StrippedPrimitiveSet for quad strips. More...

#include <TriFans.h>

Inheritance diagram for TriFans:

[legend]
Collaboration diagram for TriFans:

[legend]
List of all members.

Public Member Functions

NVSG_API | TriFans ()
Default-constructs a TriFans.

NVSG_API | TriFans (const StrippedPrimitiveSet &rhs)
Constructs a TriFans from a StrippedPrimitiveSet.

NVSG_API | TriFans (const TriFans &rhs)
Constructs a TriFans as a copy from another TriFans.

virtual NVSG_API | ~TriFans ()
Destructs a TriFans.

NVSG_API TriFans & | operator= (const TriFans &rhs)
Assignment operator.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (TriFans *tf, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2)
Generate tangents and binormals for a TriFans.

NVSG_API void | generateNormals (TriFans *q)
Generate normals for a TriFans.

Detailed Description

StrippedPrimitiveSet for quad strips.

Namespace: nvsg
Remarks:
A TriFans is a StrippedPrimitiveSet that represents the vertex attributes of the StrippedPrimitiveSet as triangle fans.
The number of vertices per IndexSet must be at least 3 for anything to be drawn.
See also:
LineStrips, StrippedPrimitiveSet, TriStrips

Constructor & Destructor Documentation

NVSG_API TriFans ( )

Default-constructs a TriFans.

NVSG_API TriFans ( const StrippedPrimitiveSet & rhs ) [explicit]

Constructs a TriFans from a StrippedPrimitiveSet.

NVSG_API TriFans ( const TriFans & rhs ) [explicit]

Constructs a TriFans as a copy from another TriFans.

virtual NVSG_API ~TriFans ( ) [virtual]

Destructs a TriFans.

Member Function Documentation

NVSG_API TriFans& operator= ( const TriFans & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant TriFans to copy from.
Returns:
A reference to the assigned TriFans.
Remarks:
The assignment operator calls the assignment operator of StrippedPrimitiveSet.

Friends And Related Function Documentation

NVSG_API void calculateTangentSpace | ( | TriFans * | tf,
 |  | unsigned int | tu = 0,
 |  | unsigned int | tg = 1,
 |  | unsigned int | bn = 2
 | ) | [related]

Generate tangents and binormals for a TriFans.

Parameters:
tf | A pointer to the TriFans to create tangents and binormals for.
tu | The optional texture unit that holds texture coordinates to use; default is 0.
tg | The optional texture unit that is going to hold the tangents; default is 1.
bn | The optional texture unit that is going to hold the binormals; default is 2.
Remarks:
This routine calculates tangents and binormals for every vertex in the TriFans tf. The tangent points along the second component of the texture parameterization. The binormal is calculated by the cross product of the normal and the tangent at that vertex.

NVSG_API void generateNormals ( TriFans * q ) [related]

Generate normals for a TriFans.

Parameters:
q A pointer to the TriFans to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • TriFans.h
Generated on Tue Jan 15 10:29:22 2008 for NVSGSDK by NVIDIA


Member List

TriFans Member List

This is the complete list of members for TriFans, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | StrippedPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | StrippedPrimitiveSet | [protected, virtual]
calculateTangentSpace(TriFans *tf, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2) | TriFans | [related]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
generateNormals(TriFans *q) | TriFans | [related]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const TriFans &rhs) | TriFans |
nvsg::StrippedPrimitiveSet::operator=(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setStrips(const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setStrips(unsigned int pos, const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
TriFans() | TriFans |
TriFans(const StrippedPrimitiveSet &rhs) | TriFans | [explicit]
TriFans(const TriFans &rhs) | TriFans | [explicit]
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [virtual]
~TriFans() | TriFans | [virtual]
Generated on Tue Jan 15 10:29:22 2008 for NVSGSDK by NVIDIA


TriStrips Class Reference

StrippedPrimitiveSet for triangle strips. More...

#include <TriStrips.h>

Inheritance diagram for TriStrips:

[legend]
Collaboration diagram for TriStrips:

[legend]
List of all members.

Public Member Functions

NVSG_API | TriStrips ()
Default-constructs a TriStrips.

NVSG_API | TriStrips (const StrippedPrimitiveSet &rhs)
Constructs a TriStrips from a StrippedPrimitiveSet.

NVSG_API | TriStrips (const TriStrips &rhs)
Constructs a TriStrips as a copy from another TriStrips.

virtual NVSG_API | ~TriStrips ()
Destructs a TriStrips.

NVSG_API TriStrips & | operator= (const TriStrips &rhs)
Assignment operator.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (TriStrips *ts, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2)
Generate tangents and binormals for a TriStrips.

NVSG_API void | generateNormals (TriStrips *q)
Generate normals for a TriStrips.

Detailed Description

StrippedPrimitiveSet for triangle strips.

Namespace: nvsg
Remarks:
A TriStrips is a StrippedPrimitiveSet that represents the vertex attributes of the StrippedPrimitiveSet as triangle strips.
If you have, for example, an array of eight vertices in the StrippedPrimitiveSet, one possibility to make them a cube is, to define three IndexSet elements like that:
    set[0] = { 0, 1, 2, 3, 4, 5, 6, 7, 0, 1 };
    set[1] = { 1, 7, 3, 5 };
    set[2] = { 6, 0, 4, 2 };
The ordering ensures that the triangles are all drawn with the same orientation so that the triangle strip correctly form part of a surface. Preserving the orientation is important for some operations, such as culling.
The number of vertices per IndexSet must be at least 3 for anything to be drawn.
See also:
LineStrips, StrippedPrimitiveSet, TriangleStrips

Constructor & Destructor Documentation

NVSG_API TriStrips ( )

Default-constructs a TriStrips.

NVSG_API TriStrips ( const StrippedPrimitiveSet & rhs ) [explicit]

Constructs a TriStrips from a StrippedPrimitiveSet.

NVSG_API TriStrips ( const TriStrips & rhs ) [explicit]

Constructs a TriStrips as a copy from another TriStrips.

virtual NVSG_API ~TriStrips ( ) [virtual]

Destructs a TriStrips.

Member Function Documentation

NVSG_API TriStrips& operator= ( const TriStrips & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant TriStrips to copy from.
Returns:
A reference to the assigned TriStrips.
Remarks:
The assignment operator calls the assignment operator of StrippedPrimitiveSet.

Friends And Related Function Documentation

NVSG_API void calculateTangentSpace | ( | TriStrips * | ts,
 |  | unsigned int | tu = 0,
 |  | unsigned int | tg = 1,
 |  | unsigned int | bn = 2
 | ) | [related]

Generate tangents and binormals for a TriStrips.

Parameters:
ts | A pointer to the TriStrips to create tangents and binormals for.
tu | The optional texture unit that holds texture coordinates to use; default is 0.
tg | The optional texture unit that is going to hold the tangents; default is 1.
bn | The optional texture unit that is going to hold the binormals; default is 2.
Remarks:
This routine calculates tangents and binormals for every vertex in the TriStrips ts. The tangent points along the second component of the texture parameterization. The binormal is calculated by the cross product of the normal and the tangent at that vertex.

NVSG_API void generateNormals ( TriStrips * q ) [related]

Generate normals for a TriStrips.

Parameters:
q A pointer to the TriStrips to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • TriStrips.h
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


Member List

TriStrips Member List

This is the complete list of members for TriStrips, including all inherited members.
addOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
attachHighlightObject(HighlightObjectHandle *obj=NULL) | Drawable |
calculateBoundingBox() const | StrippedPrimitiveSet | [protected, virtual]
calculateBoundingSphere() const | StrippedPrimitiveSet | [protected, virtual]
calculateTangentSpace(TriStrips *ts, unsigned int tu=0, unsigned int tg=1, unsigned int bn=2) | TriStrips | [related]
ConstOwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
containsAnimation() const | PrimitiveSet | [virtual]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
enterCS() const | Object | [inline, protected]
generateNormals(TriStrips *q) | TriStrips | [related]
getAnnotation() const | Object |
getBoundingBox() const | Drawable |
getBoundingSphere() const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< NodeHandle > |
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< NodeHandle > |
getSkin() const | PrimitiveSet | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getUserData() const | Object | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
invalidateAnimationContainment() | PrimitiveSet |
invalidateBoundingVolumes() | Drawable |
invalidateIncarnation() | OwnedObject< NodeHandle > | [virtual]
isCompatible(const PrimitiveSet *p) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const TriStrips &rhs) | TriStrips |
nvsg::StrippedPrimitiveSet::operator=(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::OwnedObject< NodeHandle >::operator=(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< NodeHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< NodeHandle > | [protected]
OwnedObject(const OwnedObject< NodeHandle > &rhs) | OwnedObject< NodeHandle > | [protected]
OwnerIterator typedef | OwnedObject< NodeHandle > | [protected]
ownersBegin() const | OwnedObject< NodeHandle > | [inline, protected]
ownersBegin() | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() const | OwnedObject< NodeHandle > | [inline, protected]
ownersEnd() | OwnedObject< NodeHandle > | [inline, protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
removeOwner(typename NodeHandle::ObjectType *obj) | OwnedObject< NodeHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setName(const std::string &name) | Object |
setSkin(SkinHandle *skin) | PrimitiveSet |
setStrips(const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setStrips(unsigned int pos, const IndexSet *strips, unsigned int numStrips) | StrippedPrimitiveSet |
setUserData(const void *userData) | Object | [inline]
setVertexAttributeSet(VertexAttributeSetHandle *vash) | PrimitiveSet |
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
TriStrips() | TriStrips |
TriStrips(const StrippedPrimitiveSet &rhs) | TriStrips | [explicit]
TriStrips(const TriStrips &rhs) | TriStrips | [explicit]
validateIncarnation() const | PrimitiveSet | [virtual]
~Drawable(void) | Drawable | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< NodeHandle > | [protected]
~PrimitiveSet() | PrimitiveSet | [virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [virtual]
~TriStrips() | TriStrips | [virtual]
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


tweak_t Struct Reference

The tweak_t structure specifies how a tweakable parameter is stored in a .NBF file. More...

#include <NBF.h>

Collaboration diagram for tweak_t:

[legend]
List of all members.

Public Types

enum {
TYPE_STRUCT = BIT0, TYPE_ARRAY = BIT1, TYPE_FLOAT = BIT2, TYPE_INT = BIT3,
TYPE_BOOL = BIT4, TYPE_STRING = BIT5
}

Public Attributes

str_t name
Specifies the tweakable's name as it appears in the effect source.

uint_t type
Specifies the type of the tweakable (array, float,...).

uint_t numValues
Specifies the number of values stored. For a float4-typed parameter, for example, this is 4.

uint_t numTweaks
In case of an array parameter this specifies the array size. In case of a struct parameter this specifies the number of members.

uint_t tweaks
Specifies the file offset to either the array elements or struct members.

Detailed Description

The tweak_t structure specifies how a tweakable parameter is stored in a .NBF file.

Tweakables need to be considered in conjunction with NBFCgFx objects.

Member Data Documentation

str_t name

Specifies the tweakable's name as it appears in the effect source.

uint_t type

Specifies the type of the tweakable (array, float,...).

uint_t numValues

Specifies the number of values stored. For a float4-typed parameter, for example, this is 4.

uint_t floats

Specifies the file offset to a non-string value. Note that this offset is not a valid offset for string types! Non-string values internally always are stored in terms of floats.

str_t str

Specifies the string value in case of a string parameter.

uint_t numTweaks

In case of an array parameter this specifies the array size. In case of a struct parameter this specifies the number of members.

uint_t tweaks

Specifies the file offset to either the array elements or struct members.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

tweak_t Member List

This is the complete list of members for tweak_t, including all inherited members.
floats | tweak_t
name | tweak_t
numTweaks | tweak_t
numValues | tweak_t
str | tweak_t
tweaks | tweak_t
type | tweak_t
TYPE_ARRAY enum value (defined in tweak_t) | tweak_t
TYPE_BOOL enum value (defined in tweak_t) | tweak_t
TYPE_FLOAT enum value (defined in tweak_t) | tweak_t
TYPE_INT enum value (defined in tweak_t) | tweak_t
TYPE_STRING enum value (defined in tweak_t) | tweak_t
TYPE_STRUCT enum value (defined in tweak_t) | tweak_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


TemplateType2EnumType struct Reference

Type2EnumType Struct Template Reference

Converts a given type into a symbolic constant representing a NVSG type. More...

#include <Types.h>

List of all members.

Public Types

enum { type = NVSG_UNSUPPORTED_TYPE }

Detailed Description

template<typename T>
struct nvsg::Type2EnumType< T >

Converts a given type into a symbolic constant representing a NVSG type.

The documentation for this struct was generated from the following file:
  • Types.h
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


Member List

Type2EnumType Member List

This is the complete list of members for Type2EnumType, including all inherited members.
type enum value (defined in Type2EnumType) Type2EnumType
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


UnifyTraverser Class Reference

OptimizeTraverser that can unify identical objects in a scene. More...

#include <UnifyTraverser.h>

Inheritance diagram for UnifyTraverser:

[legend]
Collaboration diagram for UnifyTraverser:

[legend]
List of all members.

Public Types

enum {
UT_GEONODE = BIT0, UT_GROUP = BIT1, UT_LOD = BIT2, UT_PRIMITIVE_SET = BIT3,
UT_STATE_ATTRIBUTE = BIT4, UT_STATE_PASS = BIT5, UT_STATE_SET = BIT6, UT_STATE_VARIANT = BIT7,
UT_TEXTURE_ATTRIBUTE_ITEM = BIT8, UT_TRAFO_ANIMATION = BIT9, UT_VERTEX_ATTRIBUTE_SET = BIT10, UT_VERTICES = BIT11,
UT_ALL_TARGETS_MASK
}

Public Member Functions

NVSG_API | UnifyTraverser (void)
Default constructor of an UnifyTraverser.

NVSG_API unsigned int | getUnifyTargets () const
Get the bitmask describing the targets to unify.

NVSG_API void | setUnifyTargets (unsigned int mask)
Set the bitmask describing the targets to unify.

NVSG_API float | getEpsilon () const
Get the epsilon used for compares in vertex unification.

NVSG_API void | setEpsilon (float eps)
Set the epsilon used for compares in vertex unification.

Public Attributes

enum nvtraverser::UnifyTraverser:: { ... } | UnifyTarget
Enum to specify the object types to unify.

Protected Member Functions

virtual NVSG_API | ~UnifyTraverser (void)
Protected destructor to prevent instantiation of a UnifyTraverser on stack.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Overload of the doApply method.

virtual NVSG_API void | handleBillboard (nvsg::Billboard *billboard)
Overload of the Billboard method.

virtual NVSG_API void | handleGroup (nvsg::Group *group)
Overload of the Group method.

virtual NVSG_API void | handleLOD (nvsg::LOD *lod)
Overload of the LOD method.

virtual NVSG_API void | handleSwitch (nvsg::Switch *swtch)
Overload of the Switch method.

virtual NVSG_API void | handleTransform (nvsg::Transform *transform)
Overload of the Transform method.

virtual NVSG_API void | handleFlipbookAnimation (nvsg::FlipbookAnimation *anim)
Overload of the handleFlipbookAnimation method.

virtual NVSG_API void | handleAnimatedTransform (nvsg::AnimatedTransform *trafo)
Overload of the handleAnimatedTransform method.

virtual NVSG_API void | handleSkinnedTriangles (nvsg::SkinnedTriangles *triangles)
Overload of the handleSkinnedTriangles method.

virtual NVSG_API void | handleGeoNode (nvsg::GeoNode *gnode)
Overload of the handleGeoNode method.

virtual NVSG_API void | handleLines (nvsg::Lines *lines)
Overload of the handleLines method.

virtual NVSG_API void | handleLineStrips (nvsg::LineStrips *strips)
Overload of the handleLineStrips method.

virtual NVSG_API void | handlePoints (nvsg::Points *points)
Overload of the handlePoints method.

virtual NVSG_API void | handleQuadMeshes (nvsg::QuadMeshes *meshes)
Overload of the handleQuadMeshes method.

virtual NVSG_API void | handleQuads (nvsg::Quads *quads)
Overload of the handleQuads method.

virtual NVSG_API void | handleQuadStrips (nvsg::QuadStrips *strips)
Overload of the handleQuadStrips method.

virtual NVSG_API void | handleStatePass (nvsg::StatePass *pass)
Overload of the handleStatePass method.

virtual NVSG_API void | handleStateSet (nvsg::StateSet *stateSet)
Overload of the handleStateSet method.

virtual NVSG_API void | handleStateVariant (nvsg::StateVariant *variant)
Overload of the handleStateVariant method.

virtual NVSG_API void | handleTextureAttribute (nvsg::TextureAttribute *texAttrib)
Overload of the handleTextureAttribute method.

virtual NVSG_API void | handleTriangles (nvsg::Triangles *triangles)
Overload of the handleTriangles method.

virtual NVSG_API void | handleTriFans (nvsg::TriFans *fans)
Overload of the handleTriFans method.

virtual NVSG_API void | handleTriStrips (nvsg::TriStrips *strips)
Overload of the handleTriStrips method.

virtual NVSG_API void | handleVertexAttributeSet (nvsg::VertexAttributeSet *vas)
Overload of the handleVertexAttributeSet method.

virtual NVSG_API void | handleAnimatedVertexAttributeSet (nvsg::AnimatedVertexAttributeSet *avas)
Overload of the handleAnimatedVertexAttributeSet method.

virtual NVSG_API void | traversePrimitiveSet (nvsg::PrimitiveSet *pset)
Overload of the traversePrimitiveSet method.

Detailed Description

OptimizeTraverser that can unify identical objects in a scene.

Remarks:
The UnifyTraverser can unify GeoNodes, Groups, LODs, PrimitiveSets, StateAttributes, StatePasses, StateSets, StateVariants, TextureAttributeItems, VertexAttributeSet, and vertices. Unifying in this context means, if there are two separate but identical objects in the scene, each reference to one of them is replaced by a reference of the other. That way, after unifying, there will be no separate but identical objects in the scene. For vertices, unification is performed within PrimitiveSets.
The types of objects to unify can be selected by setUnifyTargets. By default, each object type listed above is unified.
The accepted epsilon used in comparing the components of vertices can be set by setEpsilon. By default, epsilon is FLT_EPSILON.
As with every OptimizeTraverser, identical objects with different names can be considered to be equal. This can be set with setIgnoreNames. By default, this is set to true.
After unifying a scene, the UnifyTraverser can be queried if the latest traversal did modify the scene, using getTreeModified.
See also:
OptimizeTraverser

Member Enumeration Documentation

anonymous enum

Enumeration values:
UT_GEONODE | UnifyTarget nvsg::GeoNode: unify identical GeoNode objects into one.
UT_GROUP | UnifyTarget nvsg::Group: unify identical Group objects into one.
UT_LOD | UnifyTarget nvsg::LOD: unify identical LOD objects into one.
UT_PRIMITIVE_SET | UnifyTarget nvsg::PrimitiveSet: unify identical PrimitiveSet objects into one.
UT_STATE_ATTRIBUTE | UnifyTarget nvsg::StateAttribute: unify identical StateAttribute objects into one.
UT_STATE_PASS | UnifyTarget nvsg::StatePass: unify identical StatePass objects into one.
UT_STATE_SET | UnifyTarget nvsg::StateSet: unify identical StateSet objects into one.
UT_STATE_VARIANT | UnifyTarget nvsg::StateVariant: unify identical StateVariant objects into one.
UT_TEXTURE_ATTRIBUTE_ITEM | UnifyTarget nvsg::TextureAttributeItem: unify identical TextureAttributeItem objects into one.
UT_TRAFO_ANIMATION | UnifyTarget nvsg::Animation<nvmath::Trafo>: unify identical Animations on Trafo into one.
UT_VERTEX_ATTRIBUTE_SET | UnifyTarget nvsg::VertexAttributeSet: unify identical VertexAttributeSet objects into one.
UT_VERTICES | UnifyTarget Vertices: unify identical Vertices (with an epsilon) into one.

Constructor & Destructor Documentation

NVSG_API UnifyTraverser ( void )

Default constructor of an UnifyTraverser.

Remarks:
Creates a UnifyTraverser with an epsilon for vertex components comparison of FLT_EPSILON, and the targets to unify set to all.
See also:
setEpsilon, setUnifyTargets

virtual NVSG_API ~UnifyTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a UnifyTraverser on stack.

Member Function Documentation

unsigned int getUnifyTargets ( ) const [inline]

Get the bitmask describing the targets to unify.

Returns:
A bitmask describing the targets to unify.

void setUnifyTargets ( unsigned int mask ) [inline]

Set the bitmask describing the targets to unify.

Parameters:
mask The bitmask describing the targets to unify.

float getEpsilon ( ) const [inline]

Get the epsilon used for compares in vertex unification.

Returns:
The epsilon used on component of a vertex to determine equality.

void setEpsilon ( float eps ) [inline]

Set the epsilon used for compares in vertex unification.

Parameters:
eps The epsilon used on component of a vertex to determine equality.
Note:
The unification of vertices undefined, if eps is not positive.

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Overload of the doApply method.

Remarks:
After scene traversal, temporarily allocated storage is freed again.

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleBillboard ( nvsg::Billboard * billboard ) [protected, virtual]

Overload of the Billboard method.

Parameters:
billboard A pointer to the write-locked Billboard to handle.
Remarks:
After traversal of the Billboard, identical children are unified.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGroup ( nvsg::Group * group ) [protected, virtual]

Overload of the Group method.

Parameters:
group A pointer to the write-locked Group to handle.
Remarks:
After traversal of the Group, identical children are unified.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLOD ( nvsg::LOD * lod ) [protected, virtual]

Overload of the LOD method.

Parameters:
lod A pointer to the write-locked LOD to handle.
Remarks:
After traversal of the LOD as a Group, identical children are unified.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleSwitch ( nvsg::Switch * swtch ) [protected, virtual]

Overload of the Switch method.

Parameters:
swtch A pointer to the write-locked Switch to handle.
Remarks:
After traversal of the Switch as a Group, identical children are unified.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTransform ( nvsg::Transform * transform ) [protected, virtual]

Overload of the Transform method.

Parameters:
transform A pointer to the write-locked Transform to handle.
Remarks:
After traversal of the Transform, identical children are unified.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleFlipbookAnimation ( nvsg::FlipbookAnimation * anim ) [protected, virtual]

Overload of the handleFlipbookAnimation method.

Parameters:
anim A pointer to the write-locked FlipbookAnimation to handle.
Remarks:
For unifying purposes, anim is handled like a Group.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleAnimatedTransform ( nvsg::AnimatedTransform * trafo ) [protected, virtual]

Overload of the handleAnimatedTransform method.

Parameters:
trafo A pointer to the write-locked AnimatedTransform to handle.
Remarks:
If GeoNodes, Groups, or LODs are to be unified, trafo is handled like a Transform. Otherwise trafo is just traversed.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleSkinnedTriangles ( nvsg::SkinnedTriangles * triangles ) [protected, virtual]

Overload of the handleSkinnedTriangles method.

Parameters:
triangles A pointer to the write-locked SkinnedTriangles to handle.
Remarks:
The vertices of a SkinnedTriangles are not unified by this UnifyTraverser. That is, only if no vertices are to be unified, triangles is traversed.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleGeoNode ( nvsg::GeoNode * gnode ) [protected, virtual]

Overload of the handleGeoNode method.

Parameters:
gnode A pointer to the write-locked GeoNode to handle.
Remarks:
After traversing gnode, it's StateSets are unified, if requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLines ( nvsg::Lines * lines ) [protected, virtual]

Overload of the handleLines method.

Parameters:
lines A pointer to the write-locked Lines to handle.
Remarks:
After traversing lines, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleLineStrips ( nvsg::LineStrips * strips ) [protected, virtual]

Overload of the handleLineStrips method.

Parameters:
strips A pointer to the write-locked LineStrips to handle.
Remarks:
After traversing strips, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handlePoints ( nvsg::Points * points ) [protected, virtual]

Overload of the handlePoints method.

Parameters:
points A pointer to the write-locked Points to handle.
Remarks:
After traversing points, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadMeshes ( nvsg::QuadMeshes * meshes ) [protected, virtual]

Overload of the handleQuadMeshes method.

Parameters:
meshes A pointer to the write-locked QuadMeshes to handle.
Remarks:
After traversing meshes, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuads ( nvsg::Quads * quads ) [protected, virtual]

Overload of the handleQuads method.

Parameters:
quads A pointer to the write-locked Quads to handle.
Remarks:
After traversing quads, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleQuadStrips ( nvsg::QuadStrips * strips ) [protected, virtual]

Overload of the handleQuadStrips method.

Parameters:
strips A pointer to the write-locked QuadStrips to handle.
Remarks:
After traversing strips, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleStatePass ( nvsg::StatePass * pass ) [protected, virtual]

Overload of the handleStatePass method.

Parameters:
pass A pointer to the write-locked StatePass to handle.
Remarks:
After traversing pass, it's StateAttributes are unified if unification of StateAttributes is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleStateSet ( nvsg::StateSet * stateSet ) [protected, virtual]

Overload of the handleStateSet method.

Parameters:
stateSet A pointer to the write-locked StateSet to handle.
Remarks:
If the unification of StateVariants, StatePasses, StateAttributes, or TextureAttributeItems is requested, a non-standard traversal of each StateVariant is performed, and then the StateVariants of this StateSet are unified their unification is requested. Otherwise, stateSet is just traversed.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleStateVariant ( nvsg::StateVariant * variant ) [protected, virtual]

Overload of the handleStateVariant method.

Parameters:
variant A pointer to the write-locked StateVariant to handle.
Remarks:
After traversing variant, it's StatePasses are unified if unification of StatePasses is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTextureAttribute ( nvsg::TextureAttribute * texAttrib ) [protected, virtual]

Overload of the handleTextureAttribute method.

Parameters:
texAttrib A pointer to the write-locked TextureAttribute to handle.
Remarks:
After traversing texAttrib, it's TextureAttributeItems are unified if unification of TextureAttributeItems is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriangles ( nvsg::Triangles * triangles ) [protected, virtual]

Overload of the handleTriangles method.

Parameters:
triangles A pointer to the write-locked Triangles to handle.
Remarks:
After traversing triangles, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriFans ( nvsg::TriFans * fans ) [protected, virtual]

Overload of the handleTriFans method.

Parameters:
fans A pointer to the write-locked TriFans to handle.
Remarks:
After traversing fans, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleTriStrips ( nvsg::TriStrips * strips ) [protected, virtual]

Overload of the handleTriStrips method.

Parameters:
strips A pointer to the write-locked TriStrips to handle.
Remarks:
After traversing strips, it is unified if unification of PrimitiveSets is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleVertexAttributeSet ( nvsg::VertexAttributeSet * vas ) [protected, virtual]

Overload of the handleVertexAttributeSet method.

Parameters:
vas A pointer to the write-locked VertexAttributeSet to handle.
Remarks:
After traversing vas, the vertices inside are unified if unification of vertices is requested.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void handleAnimatedVertexAttributeSet ( nvsg::AnimatedVertexAttributeSet * avas ) [protected, virtual]

Overload of the handleAnimatedVertexAttributeSet method.

Parameters:
avas A pointer to the write-locked AnimatedVertexAttributeSet to handle.
Remarks:
The vertices of an AnimatedVertexAttributeSet are not unified by this UnifyTraverser. That is, only if no vertices are to be unified, avas is traversed.

Reimplemented from ExclusiveTraverser.

virtual NVSG_API void traversePrimitiveSet ( nvsg::PrimitiveSet * pset ) [protected, virtual]

Overload of the traversePrimitiveSet method.

Parameters:
pset A pointer to the write-locked PrimitiveSets to handle.
Remarks:
After traversing pset, it's VertexAttributeSets are unified if unification of VertexAttributeSets is requested.

Reimplemented from ExclusiveTraverser.

Member Data Documentation

enum { ... } UnifyTarget

Enum to specify the object types to unify.

The documentation for this class was generated from the following file:
  • UnifyTraverser.h
Generated on Tue Jan 15 10:29:40 2008 for NVSGSDK by NVIDIA


Member List

UnifyTraverser Member List

This is the complete list of members for UnifyTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | UnifyTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getEpsilon() const | UnifyTraverser | [inline]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getTreeModified(void) const | OptimizeTraverser | [inline]
getUnifyTargets() const | UnifyTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | UnifyTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | UnifyTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | UnifyTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | UnifyTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | UnifyTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | UnifyTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | UnifyTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | UnifyTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | UnifyTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | UnifyTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | UnifyTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | UnifyTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | UnifyTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | UnifyTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | UnifyTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | UnifyTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | UnifyTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | UnifyTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | UnifyTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *transform) | UnifyTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | UnifyTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | UnifyTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | UnifyTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | UnifyTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setEpsilon(float eps) | UnifyTraverser | [inline]
setIgnoreNames(bool ignore) | OptimizeTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
setUnifyTargets(unsigned int mask) | UnifyTraverser | [inline]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | UnifyTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
UnifyTarget | UnifyTraverser |
UnifyTraverser(void) | UnifyTraverser |
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
UT_ALL_TARGETS_MASK enum value (defined in UnifyTraverser) | UnifyTraverser |
UT_GEONODE enum value | UnifyTraverser |
UT_GROUP enum value | UnifyTraverser |
UT_LOD enum value | UnifyTraverser |
UT_PRIMITIVE_SET enum value | UnifyTraverser |
UT_STATE_ATTRIBUTE enum value | UnifyTraverser |
UT_STATE_PASS enum value | UnifyTraverser |
UT_STATE_SET enum value | UnifyTraverser |
UT_STATE_VARIANT enum value | UnifyTraverser |
UT_TEXTURE_ATTRIBUTE_ITEM enum value | UnifyTraverser |
UT_TRAFO_ANIMATION enum value | UnifyTraverser |
UT_VERTEX_ATTRIBUTE_SET enum value | UnifyTraverser |
UT_VERTICES enum value | UnifyTraverser |
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
~UnifyTraverser(void) | UnifyTraverser | [protected, virtual]
Generated on Tue Jan 15 10:29:40 2008 for NVSGSDK by NVIDIA


UnlitColorAttribute Class Reference

StateAttribute specifying the color in case there is no lighting. More...

#include <UnlitColorAttribute.h>

Inheritance diagram for UnlitColorAttribute:

[legend]
Collaboration diagram for UnlitColorAttribute:

[legend]
List of all members.

Public Member Functions

NVSG_API | UnlitColorAttribute ()
Default-constructs an UnlitColorAttribute.

NVSG_API | UnlitColorAttribute (const StateAttribute &rhs)
Constructs a UnlitColorAttribute from a StateAttribute.

NVSG_API | UnlitColorAttribute (const UnlitColorAttribute &rhs)
Constructs a UnlitColorAttribute as a copy from another UnlitColorAttribute.

virtual NVSG_API | ~UnlitColorAttribute ()
Destructs a UnlitColorAttribute.

NVSG_API const nvmath::Vec4f & | getColor () const
Get the color.

NVSG_API void | setColor (const nvmath::Vec4f &color)
Set the color.

Detailed Description

StateAttribute specifying the color in case there is no lighting.

Remarks:
The color of an UnlitColorAttribute is used as the color of an object when lighting is off. This can happen, when that object is drawn in wireframe mode. If there is no UnlitColorAttribute associated with a Drawable, the diffuse color of the associated Material is used. If there is no associated Material either, a default color is used.

Constructor & Destructor Documentation

NVSG_API UnlitColorAttribute ( )

Default-constructs an UnlitColorAttribute.

Remarks:
The default-constructed UnlitColorAttribute initially is an opaque light grey (0.9,0.9,0.9,1.0).

NVSG_API UnlitColorAttribute ( const StateAttribute & rhs ) [explicit]

Constructs a UnlitColorAttribute from a StateAttribute.

Parameters:
rhs Source StateAttribute
Remarks:
The UnlitColorAttribute initially is an opaque light grey (0.9,0.9,0.9,1.0).

NVSG_API UnlitColorAttribute ( const UnlitColorAttribute & rhs )

Constructs a UnlitColorAttribute as a copy from another UnlitColorAttribute.

virtual NVSG_API ~UnlitColorAttribute ( ) [virtual]

Destructs a UnlitColorAttribute.

Member Function Documentation

const nvmath::Vec4f & getColor ( ) const [inline]

Get the color.

Returns:
The color of this UnlitColorAttribute.
See also:
setColor

void setColor ( const nvmath::Vec4f & color ) [inline]

Set the color.

Parameters:
color The color for this UnlitColorAttribute.
See also:
getColor

The documentation for this class was generated from the following file:
  • UnlitColorAttribute.h
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


Member List

UnlitColorAttribute Member List

This is the complete list of members for UnlitColorAttribute, including all inherited members.
addOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
enterCS() const | Object | [inline, protected]
getAnnotation() const | Object |
getColor() const | UnlitColorAttribute | [inline]
getDataID() const | Object | [virtual]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNumberOfOwners() const | OwnedObject< StatePassHandle > |
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< StatePassHandle > |
getUserData() const | Object | [inline]
invalidateContainment(unsigned int mask) | StateAttribute | [protected]
invalidateIncarnation() | OwnedObject< StatePassHandle > | [virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isTransparent(void) const | StateAttribute | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in StateAttribute) | StateAttribute | [mutable, protected]
m_objectCode | Object | [protected]
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::OwnedObject< StatePassHandle >::operator=(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnedObject(const OwnedObject< StatePassHandle > &rhs) | OwnedObject< StatePassHandle > | [protected]
OwnerIterator typedef | OwnedObject< StatePassHandle > | [protected]
ownersBegin() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersBegin() | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() const | OwnedObject< StatePassHandle > | [inline, protected]
ownersEnd() | OwnedObject< StatePassHandle > | [inline, protected]
removeOwner(typename StatePassHandle::ObjectType *obj) | OwnedObject< StatePassHandle > | [protected]
setAnnotation(const std::string &anno) | Object |
setColor(const nvmath::Vec4f &color) | UnlitColorAttribute | [inline]
setName(const std::string &name) | Object |
setUserData(const void *userData) | Object | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
UnlitColorAttribute() | UnlitColorAttribute |
UnlitColorAttribute(const StateAttribute &rhs) | UnlitColorAttribute | [explicit]
UnlitColorAttribute(const UnlitColorAttribute &rhs) | UnlitColorAttribute |
validateIncarnation() const | Object | [virtual]
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< StatePassHandle > | [protected]
~StateAttribute(void) | StateAttribute | [virtual]
~UnlitColorAttribute() | UnlitColorAttribute | [virtual]
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


UPIID Class Reference

Unique Plug Interface ID. More...

#include <PlugIn.h>

Collaboration diagram for UPIID:

[legend]
List of all members.

Public Member Functions

UPIID ()
Default constructor.

NVSG_API | UPIID (const char idstr[8], UPITID pitid)
Constructor.

NVSG_API UPIID & | operator= (const UPIID &rhs)
Assignment operator.

const char * | getPlugSpecificIDString () const
Receive specific identifier string.

const UPITID & | getPlugInterfaceType () const
Receive the unique interface type.

Friends

bool | operator< (const UPIID &lhs, const UPIID &rhs)
"Less than" comparison

bool | operator== (const UPIID &lhs, const UPIID &rhs)
Comparison.

bool | operator!= (const UPIID &lhs, const UPIID &rhs)
Comparison.

Detailed Description

Unique Plug Interface ID.

A helper class for assembling unique IDs that identify a certain plug interface. An 8 byte specific identifier string will be concatenated to a UPITID to define a unique plug interface identifier, client code can query for.

Note:
A UPIID will be defined by a plug-in which provides a certain plug interface type.

Constructor & Destructor Documentation

UPIID ( ) [inline]

Default constructor.

Default constructs a UPIID object.

NVSG_API UPIID | ( | const char | idstr[8],
 |  | UPITID | pitid
 | ) |

Constructor.

Constructs a UPIID object from a specific identifier string (8 bytes) and a UPITID which identifies the certain type of the interface a plug-in provides.

Parameters:
idstr | Specific identifier string
pitid | UPITID the plug-in provides

Member Function Documentation

NVSG_API UPIID& operator= ( const UPIID & rhs )

Assignment operator.

Assigning a new UPIID.

Returns:
A reference to this UPIID object.

const char * getPlugSpecificIDString ( ) const [inline]

Receive specific identifier string.

Get hold of the identifier that is specific for a plug interface provided by a certain plug-in. Client code can take this additional information to decide which plug-in best matches the client's requirements concerning a certain plug interface type. The kind of information stored in the specific identifier string and how a certain client can use it, must be documented in detail by the plug-in writer.

For example, plug-ins that provide the nvsg::PITID_SCENE_LOADER or nvsg::PITID_SCENE_SAVER interface type for either loading or saving a NVSG scene, store the specific file extension within the specific identifier string of the UPIID object the plug-in returns, if client code queries for these interface types using the nvutil:queryInterfaceType interface.
Returns:
A constant string holding the specific identifier string.

const UPITID & getPlugInterfaceType ( ) const [inline]

Receive the unique interface type.

This is for a client to verify if the plug interface type stored in this interface ID is the same, it was querying for.

Returns:
The UPITID stored in the UPIID.

Friends And Related Function Documentation

bool operator< | ( | const UPIID & | lhs,
 |  | const UPIID & | rhs
 | ) | [friend]

"Less than" comparison

Compares two UPIID objects. This operator is required e.g. if it is intended to store UPIID objects in ordered containers.

Returns:
true if lhs is less than rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator== | ( | const UPIID & | lhs,
 |  | const UPIID & | rhs
 | ) | [friend]

Comparison.

Tests two UPIID objects on equality.

Returns:
true if lhs is equal to rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator!= | ( | const UPIID & | lhs,
 |  | const UPIID & | rhs
 | ) | [friend]

Comparison.

Tests two UPIID objects on inequality.

Returns:
true if lhs is unequal to rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

The documentation for this class was generated from the following file:
  • PlugIn.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

UPIID Member List

This is the complete list of members for UPIID, including all inherited members.
getPlugInterfaceType() const | UPIID | [inline]
getPlugSpecificIDString() const | UPIID | [inline]
operator!=(const UPIID &lhs, const UPIID &rhs) | UPIID | [friend]
operator<(const UPIID &lhs, const UPIID &rhs) | UPIID | [friend]
operator=(const UPIID &rhs) | UPIID |
operator==(const UPIID &lhs, const UPIID &rhs) | UPIID | [friend]
UPIID() | UPIID | [inline]
UPIID(const char idstr[8], UPITID pitid) | UPIID |
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


UPITID Class Reference

Unique Plug Interface Type ID. More...

#include <PlugIn.h>

List of all members.

Public Member Functions

UPITID ()
Default constructor.

NVSG_API | UPITID (unsigned short pit, const char verStr[16])
Constructor.

NVSG_API | UPITID (const UPITID &rhs)
Copy constructor.

Friends

bool | operator< (const UPITID &lhs, const UPITID &rhs)
"Less than" comparison

bool | operator== (const UPITID &lhs, const UPITID &rhs)
Comparison.

bool | operator!= (const UPITID &lhs, const UPITID &rhs)
Comparison.

Detailed Description

Unique Plug Interface Type ID.

A helper class for assembling unique IDs that identify a certain plug interface type. A short numeric interface type ID and a 16 byte version string are concatenated to define a unique plug interface type identifier.

Note:
A UPITID must be defined by a client which wants to use a certain plug interface type provided by a plug-in.

Constructor & Destructor Documentation

UPITID ( ) [inline]

Default constructor.

Default constructs a UPITID object.

NVSG_API UPITID | ( | unsigned short | pit,
 |  | const char | verStr[16]
 | ) |

Constructor.

Constructs a UPITID object from a plug interface type ID and a version string.

Parameters:
pit | Identifies a certain plug interface type
verStr | A 16 byte version string to maintain version safty

NVSG_API UPITID ( const UPITID & rhs )

Copy constructor.

Constructs a UPITID object from another UPITID object.

Friends And Related Function Documentation

bool operator< | ( | const UPITID & | lhs,
 |  | const UPITID & | rhs
 | ) | [friend]

"Less than" comparison

Compares two UPITID objects. This operator is required e.g. if it is intended to store UPITID objects in ordered containers.

Returns:
true if lhs is less than rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator== | ( | const UPITID & | lhs,
 |  | const UPITID & | rhs
 | ) | [friend]

Comparison.

Tests two UPITID objects on equality.

Returns:
true if lhs is equal to rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator!= | ( | const UPITID & | lhs,
 |  | const UPITID & | rhs
 | ) | [friend]

Comparison.

Tests two UPITID objects on inequality.

Returns:
true if lhs is unequal to rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

The documentation for this class was generated from the following file:
  • PlugIn.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

UPITID Member List

This is the complete list of members for UPITID, including all inherited members.
operator!=(const UPITID &lhs, const UPITID &rhs) | UPITID | [friend]
operator<(const UPITID &lhs, const UPITID &rhs) | UPITID | [friend]
operator==(const UPITID &lhs, const UPITID &rhs) | UPITID | [friend]
UPITID() | UPITID | [inline]
UPITID(unsigned short pit, const char verStr[16]) | UPITID |
UPITID(const UPITID &rhs) | UPITID |
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


TemplateValidated class Reference

Validated Class Template Reference

The Validated class adds a validation state to some data. More...

#include <Validated.h>

Collaboration diagram for Validated:

[legend]
List of all members.

Public Member Functions

Validated (void)
Default constructor.

Validated (const T &t)
Constructor with default value.

bool | isValid (void) const
Ask if the validated data currently is valid.

void | invalidate (void)
Invalidate the data.

void | validate (void)
Accept the current value as valid.

const T & | get (void) const
Get the data.

void | set (const T &t)
Set the data.

Detailed Description

template<typename T>
class nvutil::Validated< T >

The Validated class adds a validation state to some data.

Constructor & Destructor Documentation

Validated ( void ) [inline]

Default constructor.

Validated ( const T & t ) [inline]

Constructor with default value.

Member Function Documentation

bool isValid ( void ) const [inline]

Ask if the validated data currently is valid.

Returns:
true, if the data is valid, otherwise false.

void invalidate ( void ) [inline]

Invalidate the data.

void validate ( void ) [inline]

Accept the current value as valid.

const T & get ( void ) const [inline]

Get the data.

It is assumed that the data is valid. If it's invalid, the returned data is not defined.

Returns:
the current data

void set ( const T & t ) [inline]

Set the data.

Setting the data also validates it.

The documentation for this class was generated from the following file:
  • Validated.h
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


Member List

Validated Member List

This is the complete list of members for Validated, including all inherited members.
get(void) const | Validated | [inline]
invalidate(void) | Validated | [inline]
isValid(void) const | Validated | [inline]
set(const T &t) | Validated | [inline]
validate(void) | Validated | [inline]
Validated(void) | Validated | [inline]
Validated(const T &t) | Validated | [inline]
Generated on Tue Jan 15 10:29:49 2008 for NVSGSDK by NVIDIA


VariantIterator Class Reference

Helper class used for iterating the StateVariant objects in a StateSet. More...

#include <StateSet.h>

List of all members.

Public Member Functions

bool | operator!= (VariantIterator it) const
Test two VariantIterator objects for inequality.

bool | operator== (VariantIterator it) const
Test two VariantIterator objects for equality.

Detailed Description

Helper class used for iterating the StateVariant objects in a StateSet.

Namespace: nvsg
Remarks:
A VariantIterator is used to iterate over all StateVariant objects of a StateSet.
Example
To iterate over all StateVariant objects in a StateSet ss, do something similar to the following:
  StateSet * ss;
  for ( VariantIterator vi = ss->getFirstVariantIterator()
      ; vi != ss->getLastVariantIterator()
      ; vi = ss->getNextVariantIterator( vi ) )
  {
    VariantKey vk = ss->getVariantKey( vi );
    NVSG_ASSERT( vk != INVALID_VARIANT_KEY );
    const nvsg::StateVariant * sv = p->getVariant( vk );
    // ...
  }
See also:

Member Function Documentation

bool operator!= ( VariantIterator it ) const [inline]

Test two VariantIterator objects for inequality.

Parameters:
it The VariantIterator to test with.
Returns:
true, if this and it are not equal, otherwise false.

bool operator== ( VariantIterator it ) const [inline]

Test two VariantIterator objects for equality.

Parameters:
it The VariantIterator to test with.
Returns:
true, if this and it are equal, otherwise false.

The documentation for this class was generated from the following file:
  • StateSet.h
Generated on Tue Jan 15 10:29:18 2008 for NVSGSDK by NVIDIA


Member List

VariantIterator Member List

This is the complete list of members for VariantIterator, including all inherited members.
operator!=(VariantIterator it) const | VariantIterator | [inline]
operator==(VariantIterator it) const | VariantIterator | [inline]
Generated on Tue Jan 15 10:29:18 2008 for NVSGSDK by NVIDIA


TemplateVecnt class Reference

Vecnt Class Template Reference

Vector class of fixed size and type. More...

#include <Vecnt.h>

Inheritance diagram for Vecnt:

[legend]
Collaboration diagram for Vecnt:

[legend]
List of all members.

Public Member Functions

Vecnt ()
Default constructor.

template<unsigned int m, typename S> | Vecnt (const Vecnt< m, S > &rhs)
Copy constructor from a vector of possibly different size and type.

template<typename S, typename R> | Vecnt (const Vecnt< n-1, S > &rhs, R last)
Copy constructor from a vector with one less value than this, and an explicit last value.

Vecnt (T x, T y)
Constructor for a two-element vector.

Vecnt (T x, T y, T z)
Constructor for a three-element vector.

Vecnt (T x, T y, T z, T w)
Constructor for a four-element vector.

const T * | getPtr () const
Get a pointer to the constant values of this vector.

T | normalize ()
Normalize this vector and get it's previous length.

template<typename S> T & | operator[] (S i)
Access operator to the values of a vector.

template<typename S> const T & | operator[] (S i) const
Constant access operator to the values of a vector.

template<typename S> Vecnt< n, T > & | operator= (const Vecnt< n, S > &rhs)
Vector assignment operator with a vector of possibly different type.

template<typename S> Vecnt< n, T > & | operator+= (const Vecnt< n, S > &rhs)
Vector addition and assignment operator with a vector of possibly different type.

template<typename S> Vecnt< n, T > & | operator-= (const Vecnt< n, S > &rhs)
Vector subtraction and assignment operator with a vector of possibly different type.

template<typename S> Vecnt< n, T > & | operator *= (S s)
Scalar multiplication and assignment operator with a scalar of possibly different type.

template<typename S> Vecnt< n, T > & | operator/= (S s)
Scalar division and assignment operator with a scalar of possibly different type.

void | orthonormalize (const Vecnt< n, T > &v)
Orthonormalize this with respect to the vector v.

Detailed Description

template<unsigned int n, typename T>
class nvmath::Vecnt< n, T >

Vector class of fixed size and type.

Remarks:
This class is templated by size and type. It holds n values of type T. There are typedefs for the most common usage with 2, 3, and 4 values of type float and double: Vec2f, Vec2d, Vec3f, Vec3d, Vec4f, Vec4d.

Constructor & Destructor Documentation

Vecnt ( ) [inline]

Default constructor.

Remarks:
For performance reasons, no initialization is performed.

Vecnt ( const Vecnt< m, S > & rhs ) [inline, explicit]

Copy constructor from a vector of possibly different size and type.

Parameters:
rhs A vector with m values of type S.
Remarks:
The minimum k of n and m is determined. The first k values of type S from rhs are converted to type T and assigned as the first k values of this. If k is less than n, the n - k last values of this are not initialized.

Vecnt | ( | const Vecnt< n-1, S > & | rhs,
 |  | R | last
 | ) | [inline]

Copy constructor from a vector with one less value than this, and an explicit last value.

Parameters:
rhs | A vector with m values of type S, where m has to be one less than n.
last | A single value of type R, that will be set as the last value of this.
Remarks:
This constructor contains a compile-time assertion, to make sure that m is one less than n. The values of rhs of type S are converted to type T and assigned as the first values of this. The value last of type R also is converted to type T and assigned as the last value of this.
Example:
    Vec3f v3f(0.0f,0.0f,0.0f);
    Vec4f v4f(v3f,1.0f);

Vecnt | ( | T | x,
 |  | T | y
 | ) | [inline]

Constructor for a two-element vector.

Parameters:
x | First element of the vector.
y | Second element of the vector.
Remarks:
This constructor can only be used with two-element vectors.
Example:
    Vec2f         v2f( 1.0f, 2.0f );
    Vecnt<2,int>  v2i( 0, 1 );

Vecnt | ( | T | x,
 |  | T | y,
 |  | T | z
 | ) | [inline]

Constructor for a three-element vector.

Parameters:
x | First element of the vector.
y | Second element of the vector.
z | Third element of the vector.
Remarks:
This constructor contains a compile-time assertion, to make sure it is used for three-element vectors, like Vec3f, only.
Example:
    Vec3f         v3f( 1.0f, 2.0f, 3.0f );
    Vecnt<3,int>  v3i( 0, 1, 2 );

Vecnt | ( | T | x,
 |  | T | y,
 |  | T | z,
 |  | T | w
 | ) | [inline]

Constructor for a four-element vector.

Parameters:
x | First element of the vector.
y | Second element of the vector.
z | Third element of the vector.
w | Fourth element of the vector.
Remarks:
This constructor contains a compile-time assertion, to make sure it is used for four-element vectors, like Vec4f, only.
Example:
    Vec4f         v4f( 1.0f, 2.0f, 3.0f, 4.0f );
    Vecnt<4,int>  v4i( 0, 1, 2, 3 );

Member Function Documentation

const T * getPtr ( ) const [inline]

Get a pointer to the constant values of this vector.

Returns:
A pointer to the constant values of this vector.
Remarks:
It is assured, that the values of a vector are contiguous.
Example:
    GLColor3fv( p->getDiffuseColor().getPtr() );

T normalize ( ) [inline]

Normalize this vector and get it's previous length.

Returns:
The length of the vector before the normalization.

T & operator[] ( S i ) [inline]

Access operator to the values of a vector.

Parameters:
i The index of the value to access.
Returns:
A reference to the value at position i in this vector.
Remarks:
The index i has to be less than the size of the vector, given by the template argument n.
Note:
The behavior is undefined if \ i is greater or equal to n.

const T & operator[] ( S i ) const [inline]

Constant access operator to the values of a vector.

Parameters:
i The index of the value to access.
Returns:
A constant reference to the value at position i in this vector.
Remarks:
The index i has to be less than the size of the vector, given by the template argument n.
Note:
The behavior is undefined if \ i is greater or equal to n.

Vecnt< n, T > & operator= ( const Vecnt< n, S > & rhs ) [inline]

Vector assignment operator with a vector of possibly different type.

Parameters:
rhs A constant reference to the vector to assign to this.
Returns:
A reference to this.
Remarks:
The values of rhs are component-wise assigned to the values of this.

Vecnt< n, T > & operator+= ( const Vecnt< n, S > & rhs ) [inline]

Vector addition and assignment operator with a vector of possibly different type.

Parameters:
rhs A constant reference to the vector to add to this.
Returns:
A reference to this.
Remarks:
The values of rhs are component-wise added to the values of this.

Vecnt< n, T > & operator-= ( const Vecnt< n, S > & rhs ) [inline]

Vector subtraction and assignment operator with a vector of possibly different type.

Parameters:
rhs A constant reference to the vector to subtract from this.
Returns:
A reference to this.
Remarks:
The values of rhs are component-wise subtracted from the values of this.

Vecnt< n, T > & operator *= ( S s ) [inline]

Scalar multiplication and assignment operator with a scalar of possibly different type.

Parameters:
s A scalar to multiply this with.
Returns:
A reference to this.
Remarks:
The values of this are component-wise multiplied with s.

Vecnt< n, T > & operator/= ( S s ) [inline]

Scalar division and assignment operator with a scalar of possibly different type.

Parameters:
s A scalar to divide this by.
Returns:
A reference to this.
Remarks:
The values of this are component-wise divided by s.
Note:
The behavior is undefined if s is less than the type-dependent epsilon.

void orthonormalize ( const Vecnt< n, T > & v ) [inline]

Orthonormalize this with respect to the vector v.

Parameters:
v A constant reference to the vector to orthonormalize this to.
Remarks:
Subtracts the orthogonal projection of this on v from this and normalizes the it, resulting in a normalized vector that is orthogonal to v.

The documentation for this class was generated from the following file:
  • Vecnt.h
Generated on Tue Jan 15 10:28:57 2008 for NVSGSDK by NVIDIA


Member List

Vecnt Member List

This is the complete list of members for Vecnt, including all inherited members.
getPtr() const | Vecnt | [inline]
normalize() | Vecnt | [inline]
operator *=(S s) | Vecnt | [inline]
operator+=(const Vecnt< n, S > &rhs) | Vecnt | [inline]
operator-=(const Vecnt< n, S > &rhs) | Vecnt | [inline]
operator/=(S s) | Vecnt | [inline]
operator=(const Vecnt< n, S > &rhs) | Vecnt | [inline]
operator[](S i) | Vecnt | [inline]
operator[](S i) const | Vecnt | [inline]
orthonormalize(const Vecnt< n, T > &v) | Vecnt | [inline]
Vecnt() | Vecnt | [inline]
Vecnt(const Vecnt< m, S > &rhs) | Vecnt | [inline, explicit]
Vecnt(const Vecnt< n-1, S > &rhs, R last) | Vecnt | [inline]
Vecnt(T x, T y) | Vecnt | [inline]
Vecnt(T x, T y, T z) | Vecnt | [inline]
Vecnt(T x, T y, T z, T w) | Vecnt | [inline]
Generated on Tue Jan 15 10:28:57 2008 for NVSGSDK by NVIDIA


vertexAttrib_t Struct Reference

The vertexAttrib_t structure specifies how vertex attributes are stored in a .NBF file. More...

#include <NBF.h>

List of all members.

Public Attributes

uint_t size
Specifies the number of coordinates per vertex.

uint_t type
Symbolic constant indicating the data type of each coordinate.

uint_t numVData
Specifies the number of vertex data stored at offset vdata.

uint_t vdata
Specifies the file offset to the raw vertex data.

Detailed Description

The vertexAttrib_t structure specifies how vertex attributes are stored in a .NBF file.

Objects of type vertexAttrib_t alway are considered in conjunction with NBFVertexAttributeSet objects.

Member Data Documentation

uint_t size

Specifies the number of coordinates per vertex.

uint_t type

Symbolic constant indicating the data type of each coordinate.

uint_t numVData

Specifies the number of vertex data stored at offset vdata.

uint_t vdata

Specifies the file offset to the raw vertex data.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

vertexAttrib_t Member List

This is the complete list of members for vertexAttrib_t, including all inherited members.
numVData | vertexAttrib_t
size | vertexAttrib_t
type | vertexAttrib_t
vdata | vertexAttrib_t
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


VertexAttribute Class Reference

Class to hold the data of one vertex attribute. More...

#include <VertexAttribute.h>

List of all members.

Public Types

typedef unsigned char | mem_t
typedef mem_t * | memptr_t

Public Member Functions

NVSG_API | VertexAttribute ()
Default constructor for an empty VertexAttribute.

NVSG_API | VertexAttribute (const VertexAttribute &rhs)
Copy Constructor.

NVSG_API | ~VertexAttribute ()
Destructor of a VertexAttribute.

NVSG_API void | swapData (VertexAttribute &rhs)
Exchanges the data of two VertexAttributes.

NVSG_API void | setData (unsigned int size, unsigned int type, const void *data, unsigned int count)
Copies data into this VerexAttribute.

NVSG_API void | setData (unsigned int pos, unsigned int size, unsigned int type, const void *data, unsigned int count)
Overwrites data in this VertexAttribute.

NVSG_API const void * | getData () const
Get a constant pointer to the vertex data of this VertexAttribute.

NVSG_API void * | getData ()
Get a pointer to the vertex data of this VertexAttribute.

NVSG_API void | removeData ()
Remove the vertex data assigned to this VertexAttribute.

NVSG_API unsigned int | getVertexDataCount () const
Get the number of vertex data elements in this VertexAttribute.

NVSG_API unsigned int | getVertexDataSize () const
Get the size of one vertex data element in this VertexAttribute.

NVSG_API unsigned int | getVertexDataType () const
Get the type identifier of the coordinates of the vertex data elements.

NVSG_API unsigned int | getVertexDataBytes () const
Get the size of one vertex data element in bytes.

NVSG_API VertexAttribute & | operator= (const VertexAttribute &rhs)
Assignment operator.

Detailed Description

Class to hold the data of one vertex attribute.

Remarks:
A VertexAttribute holds VertexDataCount elements, each one with VertexDataSize components or coordinates, each one in turn of type VertexDataType. For a set of normals for example, VertexDataSize is three and the VertexDataType is NVSG_FLOAT.
See also:
VertexAttributeSet

Constructor & Destructor Documentation

NVSG_API VertexAttribute ( )

Default constructor for an empty VertexAttribute.

NVSG_API VertexAttribute ( const VertexAttribute & rhs )

Copy Constructor.

Parameters:
rhs VertexAttribute to copy from.

NVSG_API ~VertexAttribute ( )

Destructor of a VertexAttribute.

Member Function Documentation

NVSG_API void swapData ( VertexAttribute & rhs )

Exchanges the data of two VertexAttributes.

Parameters:
rhs A VertexAttribute whose data is to be exchanged with this VertexAttribute.
Remarks:
You should always prefer it over an assignment if you no longer need the assigned VertexAttribute rhs. It offers much better efficiency because it swaps only the internal data of the two VertexAttributes and is guaranteed to have only constant complexity, instead of the linear complexity of an assignment.

NVSG_API void setData | ( | unsigned int | size,
 |  | unsigned int | type,
 |  | const void * | data,
 |  | unsigned int | count
 | ) |

Copies data into this VerexAttribute.

Parameters:
size | Specifies the number of coordinates per vertex; must be 1, 2, 3, or 4.
type | Specifies the data type of each coordinate in the input data array. In general, sympbolic constants NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted.
data | Specifies the start address of the input data array.
count | Specifies the number of vertex data to copy.
Remarks:
This function copies data from the specified location and according to the indicated data format. Data that previously was specified will be released prior to copy the new data.
See also:
getData, removeData, getVertexDataCount, getVertexDataSize, getVertexDataType, getVertexDataBytes

NVSG_API void setData | ( | unsigned int | pos,
 |  | unsigned int | size,
 |  | unsigned int | type,
 |  | const void * | data,
 |  | unsigned int | count
 | ) |

Overwrites data in this VertexAttribute.

Parameters:
pos | Marks the position of the first vertex inside this VertexAttribute, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of vertex data.
size | Specifies the number of coordinates per vertex; must be 1, 2, 3, or 4.
type | Specifies the data type of each coordinate in the input data array. In general, symbolic constants NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted.
data | Specifies the start address of the input data array.
count | Specifies the number of vertex data to copy.
Remarks:
This function overload re-specifies previously copied vertex data starting at the indicated position. If the magic value ~0 is specified for pos, the input vertex data will be appended to the previously copied vertex data.
See also:
getData, removeData, getVertexDataCount, getVertexDataSize, getVertexDataType, getVertexDataBytes

const void * getData ( ) const [inline]

Get a constant pointer to the vertex data of this VertexAttribute.

Returns:
The functions returns a type-less pointer to the vertex data of this VertexAttribute. If no vertex data was specified before, the function returns NULL.
Remarks:
The function returns a type-less pointer to the stored vertex data. To access the vertex data from this pointer it requires the determination of additional vertex data traits: Use getVertexDataType to determine the per-coordinate type for each vertex in the vertex array, getVertexDataSize retrieves the number of coordinates per vertex, and getVertexDataCount returns the number of vertices in the vertex array.
See also:
setData, removeData, getVertexDataCount, getVertexDataSize, getVertexDataType, getVertexDataBytes

void * getData ( ) [inline]

Get a pointer to the vertex data of this VertexAttribute.

Returns:
The functions returns a type-less pointer to the vertex data of this VertexAttribute. If no vertex data was specified before, the function returns NULL.
Remarks:
The function returns a type-less pointer to the stored vertex data. To access the vertex data from this pointer it requires the determination of additional vertex data traits: Use getVertexDataType to determine the per-coordinate type for each vertex in the vertex array, getVertexDataSize retrieves the number of coordinates per vertex, and getVertexDataCount returns the number of vertices in the vertex array.
See also:
setData, removeData, getVertexDataCount, getVertexDataSize, getVertexDataType, getVertexDataBytes

NVSG_API void removeData ( )

Remove the vertex data assigned to this VertexAttribute.

Remarks:
The function releases the vertex data previously specified by setData.
See also:
setData, getData

unsigned int getVertexDataCount ( ) const [inline]

Get the number of vertex data elements in this VertexAttribute.

See also:
setData, getVertexDataSize, getVertexDataType, getVertexDataBytes

unsigned int getVertexDataSize ( ) const [inline]

Get the size of one vertex data element in this VertexAttribute.

Returns:
The function returns the number of coordinates per vertex data element. This can be 1, 2, 3, or 4. If no vertex data was specified before, the function returns 0.
See also:
setData, getVertexDataCount, getVertexDataType, getVertexDataBytes

unsigned int getVertexDataType ( ) const [inline]

Get the type identifier of the coordinates of the vertex data elements.

Returns:
The function returns a symbolic constant indicating the type of each coordinate of the vertex data elements. If no vertex data was specified, the function returns NVSG_UNSUPPORTED_TYPE.
Remarks:
The function returns the type specifier that was used with a corresponding call to setData. Use getVertexDataSize to query the number of coordinates for each vertex data. You can use the nvsg::sizeOfType convenient function to determine the size in bytes of the type returned by this function.
See also:
setData, getVertexDataCount, getVertexDataSize, getVertexDataBytes, nvsg::sizeOfType

unsigned int getVertexDataBytes ( ) const [inline]

Get the size of one vertex data element in bytes.

Returns:
The function returns the size of a vertex data element in bytes.
Remarks:
This is simply the cached result of getVertexDataSize * sizeOfType(getVertexDataType).
See also:
setData, getVertexDataCount, getVertexDataSize, getVertexDataType, nvsg::sizeOfType

NVSG_API VertexAttribute& operator= ( const VertexAttribute & rhs )

Assignment operator.

Parameters:
rhs The VertexAttribute to assign this with.
Returns:
A reference to this.
Remarks:
The complete data of rhs is copied over to this.

The documentation for this class was generated from the following file:
  • VertexAttribute.h
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


Member List

VertexAttribute Member List

This is the complete list of members for VertexAttribute, including all inherited members.
getData() const | VertexAttribute | [inline]
getData() | VertexAttribute | [inline]
getVertexDataBytes() const | VertexAttribute | [inline]
getVertexDataCount() const | VertexAttribute | [inline]
getVertexDataSize() const | VertexAttribute | [inline]
getVertexDataType() const | VertexAttribute | [inline]
mem_t typedef (defined in VertexAttribute) | VertexAttribute |
memptr_t typedef (defined in VertexAttribute) | VertexAttribute |
operator=(const VertexAttribute &rhs) | VertexAttribute |
removeData() | VertexAttribute |
setData(unsigned int size, unsigned int type, const void *data, unsigned int count) | VertexAttribute |
setData(unsigned int pos, unsigned int size, unsigned int type, const void *data, unsigned int count) | VertexAttribute |
swapData(VertexAttribute &rhs) | VertexAttribute |
VertexAttribute() | VertexAttribute |
VertexAttribute(const VertexAttribute &rhs) | VertexAttribute |
~VertexAttribute() | VertexAttribute |
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


VertexAttributeSet Class Reference

Provides an interface to deal with vertex attribute data. More...

#include <VertexAttributeSet.h>

Inheritance diagram for VertexAttributeSet:

[legend]
Collaboration diagram for VertexAttributeSet:

[legend]
List of all members.

Public Types

enum {
NVSG_POSITION = 0, NVSG_VERTEX_WEIGHT, NVSG_NORMAL, NVSG_COLOR,
NVSG_SECONDARY_COLOR, NVSG_FOG_COORD, NVSG_UNUSED_1, NVSG_UNUSED_2,
NVSG_TEXCOORD0, NVSG_TEXCOORD1, NVSG_TEXCOORD2, NVSG_TEXCOORD3,
NVSG_TEXCOORD4, NVSG_TEXCOORD5, NVSG_TEXCOORD6, NVSG_TEXCOORD7,
NVSG_ATTR0, NVSG_ATTR1, NVSG_ATTR2, NVSG_ATTR3,
NVSG_ATTR4, NVSG_ATTR5, NVSG_ATTR6, NVSG_ATTR7,
NVSG_ATTR8, NVSG_ATTR9, NVSG_ATTR10, NVSG_ATTR11,
NVSG_ATTR12, NVSG_ATTR13, NVSG_ATTR14, NVSG_ATTR15,
NVSG_VERTEX_ATTRIB_COUNT = 16
}

Public Member Functions

NVSG_API | VertexAttributeSet ()
Default-constructs an empty VertexAttributeSet.

NVSG_API | VertexAttributeSet (const VertexAttributeSet &rhs)
Copy Constructor.

virtual NVSG_API | ~VertexAttributeSet (void)
Destructs a VertexAttributeSet.

virtual NVSG_API bool | isDataShared (void) const
Returns whether the data of this object is shared.

virtual NVSG_API DataID | getDataID (void) const
Returns a 64-bit integer value, which uniquely identifies the object data.

virtual NVSG_API void | swapVertexData (unsigned int attrib, VertexAttribute &rhs)
Exchanges vertex data of two vertex attributes.

virtual NVSG_API void | setVertexData (unsigned int attrib, unsigned int size, unsigned int type, const void *data, unsigned int count)
Sets data for the specified vertex attribute.

virtual NVSG_API void | setVertexData (unsigned int attrib, unsigned int pos, unsigned int size, unsigned int type, const void *data, unsigned int count)
Overwrites data for the specified vertex attribute starting at the indicated position.

virtual NVSG_API void | setVertexData (unsigned int attrib, const unsigned int *to, const unsigned int *from, unsigned int size, unsigned int type, const void *data, unsigned int count)
Overwrites data referenced to by an index array.

virtual NVSG_API void | removeVertexData (unsigned int attrib)
Removes vertex data assigned to the indicated vertex attribute.

virtual NVSG_API const void * | getVertexData (unsigned int attrib) const
Retrieves the vertex data for the indicated vertex attribute.

virtual NVSG_API unsigned int | getSizeOfVertexData (unsigned int attrib) const
Returns the number of coordinates per vertex.

virtual NVSG_API unsigned int | getTypeOfVertexData (unsigned int attrib) const
Returns the type identifier of each coordinate.

virtual NVSG_API unsigned int | getNumberOfVertexData (unsigned int attrib) const
Returns the size of the vertex array stored for the indicated vertex attribute.

NVSG_API void | setEnabled (unsigned int attrib, bool enable)
Specifies the enable state for the indicated vertex attribute.

NVSG_API bool | isEnabled (unsigned int attrib) const
Retrieves the enable state for the indicated vertex attribute.

NVSG_API void | setNormalizeEnabled (unsigned int attrib, bool enable)
Specifies the normalize-enable state for the indicated vertex attribute.

NVSG_API bool | isNormalizeEnabled (unsigned int attrib) const
Retrieves the normalize-enable state for the indicated vertex attribute.

NVSG_API void | setVertices (const nvmath::Vec3f *vertices, unsigned int count)
Sets position data for this VertexAttributeSet.

NVSG_API void | setVertices (unsigned int pos, const nvmath::Vec3f *vertices, unsigned int count)
Overwrites position data for this VertexAttributeSet starting at the indicated position.

NVSG_API const nvmath::Vec3f * | getVertices () const
Retrieves position data from the VertexAttributeSet.

NVSG_API unsigned int | getNumberOfVertices () const
Returns the size of the position array.

NVSG_API void | setNormals (const nvmath::Vec3f *normals, unsigned int count)
Sets normals for this VertexAttributeSet.

NVSG_API void | setNormals (unsigned int pos, const nvmath::Vec3f *normals, unsigned int count)
Overwrites normals for this VertexAttributeSet starting at the indicated position.

NVSG_API const nvmath::Vec3f * | getNormals () const
Retrieves normals from the VertexAttributeSet.

NVSG_API unsigned int | getNumberOfNormals () const
Returns the size of the normal array.

template<unsigned int N, typename T> void | setColors (const nvmath::Vecnt< N, T > *colors, unsigned int count)
Sets vertex colors for this VertexAttributeSet.

template<unsigned int N, typename T> void | setColors (unsigned int pos, const nvmath::Vecnt< N, T > *colors, unsigned int count)
Overwrites colors for this VertexAttributeSet starting at the indicated position.

NVSG_API const void * | getColors () const
Retrieves colors from the VertexAttributeSet.

NVSG_API unsigned int | getNumberOfColors () const
Returns the size of the color array.

NVSG_API unsigned int | getSizeOfColors () const
Returns the number of components per color.

NVSG_API unsigned int | getTypeOfColors () const
Returns the type of each color component.

template<typename T> void | setSecondaryColors (const nvmath::Vecnt< 3, T > *colors, unsigned int count)
Sets secondary colors for this VertexAttributeSet.

template<typename T> void | setSecondaryColors (unsigned int pos, const nvmath::Vecnt< 3, T > *colors, unsigned int count)
Overwrites colors for this VertexAttributeSet starting at the indicated position.

NVSG_API const void * | getSecondaryColors () const
Retrieves secondary colors from the VertexAttributeSet.

NVSG_API unsigned int | getNumberOfSecondaryColors () const
Returns the size of the secondary color array.

NVSG_API unsigned int | getTypeOfSecondaryColors () const
Returns the type of each secondary color component.

template<typename T> void | setFogCoords (const T *coords, unsigned int count)
Sets fog coordinates for this VertexAttributeSet.

template<typename T> void | setFogCoords (unsigned int pos, T *coords, unsigned int count)
Overwrites fog coordinates starting at the indicated position.

NVSG_API const void * | getFogCoords () const
Retrieves fog coordinates from the VertexAttributeSet.

NVSG_API unsigned int | getNumberOfFogCoords () const
Returns the size of the fog coordinate array.

NVSG_API unsigned int | getTypeOfFogCoords () const
Returns the type of the fog coordinates.

template<unsigned int N, typename T> void | setTexCoords (unsigned int unit, const nvmath::Vecnt< N, T > *coords, unsigned int count)
Sets a texture coordinate array.

template<unsigned int N, typename T> void | setTexCoords (unsigned int unit, unsigned int pos, const nvmath::Vecnt< N, T > *coords, unsigned int count)
Overwrites texture coordinates starting at the indicated position.

NVSG_API const void * | getTexCoords (unsigned int unit) const
Retrieves texture coordinates set for the indicated texture unit.

NVSG_API unsigned int | getNumberOfTexCoords (unsigned int unit) const
Returns the size of the texture coordinate array.

NVSG_API unsigned int | getSizeOfTexCoords (unsigned int unit) const
Returns the number of coordinates per texture coordinate array element.

NVSG_API unsigned int | getTypeOfTexCoords (unsigned int unit) const
Returns the type of each texture coordinate.

NVSG_API VertexAttributeSet & | operator= (const VertexAttributeSet &rhs)
Assignment operator.

virtual NVSG_API bool | isCompatible (const VertexAttributeSet *p) const
Test for compatibility with an other VertexAttributeSet.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other VertexAttributeSet.

virtual NVSG_API bool | containsAnimation () const
Interface to determine if an Object contains an Animation.

Protected Member Functions

NVSG_API void | releaseCachedData ()
Release the cached data and all it's owners.

NVSG_API void | invalidateBoundingVolumes ()
Invalidate the bounding volumes of all it's owners.

Related Functions

(Note that these are not member functions.)

NVSG_API void | generateTexCoords (VertexAttributeSet *vas, TextureCoordType tct, const nvmath::Sphere3f &sphere, unsigned int tu=0)

Detailed Description

Provides an interface to deal with vertex attribute data.

VertexAttributeSet supports generic and conventional vertex attributes. Conventional vertex attributes are required to support fixed function vertex processing, whereas generic vertex attributes provide a more 'generic' per-vertex computation through vertex programs. Generic attributes do not support fixed function vertex processing! Conventional vertex attributes also support per-vertex computation in a vertex program, but not as general as generic vertex attributes do. For example, the conventional NORMAL vertex attribute only allows for 3-component values to pass down the vertex pipeline. Other conventional vertex attributes have similar restrictions. Generic attributes do not have this restriction.

Constructor & Destructor Documentation

NVSG_API VertexAttributeSet ( )

Default-constructs an empty VertexAttributeSet.

NVSG_API VertexAttributeSet ( const VertexAttributeSet & rhs )

Copy Constructor.

virtual NVSG_API ~VertexAttributeSet ( void ) [virtual]

Destructs a VertexAttributeSet.

Member Function Documentation

virtual NVSG_API bool isDataShared ( void ) const [virtual]

Returns whether the data of this object is shared.

Returns:
true if the object data is shared, false otherwise.

Reimplemented from Object.

virtual NVSG_API DataID getDataID ( void ) const [virtual]

Returns a 64-bit integer value, which uniquely identifies the object data.

Returns:
A DataID, that is - a 64-bit integer value, which uniquely identifies the Object data.

Reimplemented from Object.

virtual NVSG_API void swapVertexData | ( | unsigned int | attrib,
 |  | VertexAttribute & | rhs
 | ) | [virtual]

Exchanges vertex data of two vertex attributes.

Parameters:
attrib | Indicates the vertex attribute whose data is to be exchanged with those of the VertexAttribute rhs. NVSG_POSITION, NVSG_NORMAL, NVSG_COLOR, NVSG_SECONDARY_COLOR, NVSG_FOG_COORD, NVSG_TEXCOORD0 - NVSG_TEXCOORD7, and NVSG_ATTR0 - NVSG_ATTR15 are allowed identifier.
rhs | The VertexAttribute whose data is to be exchanged with those of the vertex attribute indicated by attrib.
Remarks:
This function provides an efficient way to exchange data between two vertex attributes. It has a constant complexity, that is - it is independent of the amount of vertex data hold by the two vertex attributes.

The function does not change the enable state of the vertex attribute indicated by attrib. If rhs specifies an empty (e.g. default constructed) VertexAttribute, the vertex attribute identified by attrib will be empty after this call. In that particular case, having the attribute still enabled for rendering, results in unexpected behavior while rendering.
See also:
setVertexData, setEnabled

virtual NVSG_API void setVertexData | ( | unsigned int | attrib,
 |  | unsigned int | size,
 |  | unsigned int | type,
 |  | const void * | data,
 |  | unsigned int | count
 | ) | [virtual]

Sets data for the specified vertex attribute.

Parameters:
attrib | Index to identify the vertex attribute. NVSG_POSITION, NVSG_NORMAL, NVSG_COLOR, NVSG_SECONDARY_COLOR, NVSG_FOG_COORD, NVSG_TEXCOORD0 - NVSG_TEXCOORD7, and NVSG_ATTR0 - NVSG_ATTR15 are allowed indices.
size | Specifies the number of coordinates per vertex; must be 1, 2, 3, or 4.
type | Specifies the data type of each coordinate in the input data array. In general, sympbolic constants NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted.
data | Specifies the start address of the input data array.
count | Specifies the number of vertex data to copy.
Remarks:
This function can be used to specify vertex data for generic vertex attributes NVSG_ATTR0 - NVSG_ATTR15, as well as for conventinal vertex attributes like NVSG_POSITION, NVSG_NORMAL, NVSG_COLOR, etc.. Conventional and generic vertex attributes are aliased, where pairs of conventional and generic attributes are sharing the same storage.

setVertexData copies data from the specified location and according to the indicated data format. Data that previously was specified for the indicated vertex attribute, or it's respective aliased attribute, will be released prior to copy the new data.

Conventional vertex attributes are required to support fixed-function vertex processing, whereas generic vertex attributes provide a more 'generic' per-vertex computation through vertex programs. Generic attributes do not support fixed-function vertex processing! Conventional vertex attributes also support per-vertex computation in a vertex program, but not as general as generic vertex attributes do. Some conventional vertex attributes do have a certain restrictions regarding the number of coordinates per vertex, and the data type of coordinates, as listed in the folowing table:

Attribute | Size | Type
NVSG_POSITION | 3 | NVSG_FLOAT
NVSG_NORMAL | 3 | NVSG_FLOAT
NVSG_COLOR | 3, 4 | NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, NVSG_DOUBLE
NVSG_SECONDARY_COLOR | 3 | NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, NVSG_DOUBLE
NVSG_FOG_COORD | 1 | NVSG_FLOAT, NVSG_DOUBLE
NVSG_TEXCOORD[0-7] | 1, 2, 3, 4 | NVSG_SHORT, NVSG_INT, NVSG_FLOAT, NVSG_DOUBLE

The data copied is not automatically enabled for rendering! Enabling the copied data for rendering requires an additional call to setEnabled.
See also:
setEnabled

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API void setVertexData | ( | unsigned int | attrib,
 |  | unsigned int | pos,
 |  | unsigned int | size,
 |  | unsigned int | type,
 |  | const void * | data,
 |  | unsigned int | count
 | ) | [virtual]

Overwrites data for the specified vertex attribute starting at the indicated position.

Parameters:
attrib | Index to identify the vertex attribute. NVSG_POSITION, NVSG_NORMAL, NVSG_COLOR, NVSG_SECONDARY_COLOR, NVSG_FOG_COORD, NVSG_TEXCOORD0 - NVSG_TEXCOORD7, and NVSG_ATTR0 - NVSG_ATTR15 are allowed indices.
pos | Marks the position of the first vertex inside the already specified array of vertex data, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of vertex data.
size | Specifies the number of coordinates per vertex; must be 1, 2, 3, or 4.
type | Specifies the data type of each coordinate in the input data array. In general, sympbolic constants NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted.
data | Specifies the start address of the input data array.
count | Specifies the number of vertex data to copy.
Remarks:
This setVertexData overload re-specifies previously copied vertex data starting at the indicated position. If the magic value ~0 is specified for pos, the input vertex data will be appended to the previously copied vertex data.

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API void setVertexData | ( | unsigned int | attrib,
 |  | const unsigned int * | to,
 |  | const unsigned int * | from,
 |  | unsigned int | size,
 |  | unsigned int | type,
 |  | const void * | data,
 |  | unsigned int | count
 | ) | [virtual]

Overwrites data referenced to by an index array.

Parameters:
attrib | Index to identify the vertex attribute. NVSG_POSITION, NVSG_NORMAL, NVSG_COLOR, NVSG_SECONDARY_COLOR, NVSG_FOG_COORD, NVSG_TEXCOORD0 - NVSG_TEXCOORD7, and NVSG_ATTR0 - NVSG_ATTR15 are allowed indices.
to | Specifies the start address of the index array, that will be taken to reference the respective vertex data to be re-specified. If NULL is passed here, the input vertex data will be appended to the array of vertex data that previously was specified.
from | Specifies the start address of the index array, that will be taken to reference the input vertex data to overwrite the previously specified vertex data.
size | Specifies the number of coordinates per vertex; must be 1, 2, 3, or 4.
type | Specifies the data type of each coordinate in the input data array. In general, sympbolic constants NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted.
data | Specifies the start address of the input data array.
count | Specifies the number of vertex data to copy.
Remarks:
This setVertexData overload copies count vertex data from the vertex data array pointed to by data. Vertex data that previously was specified for the indicated vertex attribute, or it's respective aliased attribute, will be released prior to copy the new data. The input vertex data will not be copied as an contiguous range, but by referencing the input vertex data through the index array specified by from. The destination vertex data, in the same way, will be accessed through the index array pointed to by to. The following pseudo code illustrates how the copying proceeds:
      for ( unsigned int i = 0; i < count; ++i )
      {
        destination[to[i]] = source[from[i]];
      }

If a NULL pointer is passed through to, the input vertex data will be appended to the vertex data that was copied prior to this call.

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API void removeVertexData ( unsigned int attrib ) [virtual]

Removes vertex data assigned to the indicated vertex attribute.

Parameters:
attrib Specifies the vertex attribute for which to remove previously copied vertex data.
Remarks:
The function releases the vertex data that previously was specified for the vertex attribute indicated by attrib.
Note:
The function does not reset the enable state for the indicated vertex attribute! If client code intends to permanently remove vertex data for the indicated vertex attribute, the vertex attribute must no longer be enabled! This can be achieved through an explicit call to VertexAttributeSet::setEnabled with false as second argument. Leaving the vertex attribute enabled results in unexpected behavior while rendering.
See also:
setEnable

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API const void* getVertexData ( unsigned int attrib ) const [virtual]

Retrieves the vertex data for the indicated vertex attribute.

Parameters:
attrib Specifies the vertex attribute from which to get the vertex data.
Returns:
The function returns a type-less pointer to the vertex data that was assigned to the vertex attribute indicated by attrib prior to this call. If for this vertex attribute no vertex data was specified before, the function returns NULL.
Remarks:
The function returns a type-less pointer to the stored vertex array. To access the vertex data from this pointer it requires the determination of additional vertex data traits: Use getTypeOfVertexData to determine the per-coordinate type for each vertex in the vertex array, getSizeOfVertexData retrieves the number of coordinates per vertex, and getNumberOfVertexData returns the number of vertices in the vertex array.

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API unsigned int getSizeOfVertexData ( unsigned int attrib ) const [virtual]

Returns the number of coordinates per vertex.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns the number of coordinates per vertex stored for the indicated attribute. This number can be 1, 2, 3, or 4. If no vertex data was specified for this vertex attribute before, the function returns 0.

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API unsigned int getTypeOfVertexData ( unsigned int attrib ) const [virtual]

Returns the type identifier of each coordinate.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns a symbolic constant indicating the type of each coordinate in the vertex array stored for the specified vertex attribute. If no vertex data was specified for this vertex attribute before, the function returns NVSG_UNSUPPORTED_TYPE.
Remarks:
The function returns the per-coordinate type specifier that was used with a corresponding call to setVertexData. Use getSizeOfVertexData to query the number of coordinates for each vertex stored. You can use the nvsg::sizeOfType convenient function to determine the size in bytes of the type returned by this function.
See also:
setVertexData

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API unsigned int getNumberOfVertexData ( unsigned int attrib ) const [virtual]

Returns the size of the vertex array stored for the indicated vertex attribute.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns the number of vertices stored for the indicated vertex attribute.

Reimplemented in AnimatedVertexAttributeSet.

void setEnabled | ( | unsigned int | attrib,
 |  | bool | enable
 | ) | [inline]

Specifies the enable state for the indicated vertex attribute.

Parameters:
attrib | Indicates the vertex attribute for which to specify the enable state.
enable | Appoints the enable state for the indicated vertex attribute.
Remarks:
Vertex data that were specified for the indicated vertex attribute will not automatically be enabled for rendering. Use this function to appoint the enable state for the indicated vertex attribute. If true is passed as second argument, the corresponding vertex array will be enabled for rendering. If false is passed instead, the vertex array will be explicitly disabled for rendering.
See also:
isEnabled

bool isEnabled ( unsigned int attrib ) const [inline]

Retrieves the enable state for the indicated vertex attribute.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns true, if the indicated vertex attribute is enabled for rendering. Otherwise the function returns false.

void setNormalizeEnabled | ( | unsigned int | attrib,
 |  | bool | enable
 | ) | [inline]

Specifies the normalize-enable state for the indicated vertex attribute.

Parameters:
attrib | Indicates the vertex attribute for which to specify the normalize-enable state.
enable | Appoints the normalize-enable state for the indicated vertex attribute.
Remarks:
This function is meaningful only for generic vertex attributes, that is - NVSG_ATTR0 - NVSG_ATTR15. This function can be used to indicate that fixed-point generic vertex attribute array components should be converted to [-1,1] or [0,1] ranges, for signed and unsigned types resp.. If you pass true as second argument, normalization will be implicitly enabled for the vertex data of the indicated vertex attribute. The normalize request will be forwarded to the renderer. The conversion will not be performed on client-site data!

Normalize initially is disabled.

bool isNormalizeEnabled ( unsigned int attrib ) const [inline]

Retrieves the normalize-enable state for the indicated vertex attribute.

Parameters:
attrib Indicates the vertex attribute to query.
Returns:
The function returns true, if normalize conversion is enabled for the indicated vertex attribute. Otherwise, the function returns false.

void setVertices | ( | const nvmath::Vec3f * | vertices,
 |  | unsigned int | count
 | ) | [inline]

Sets position data for this VertexAttributeSet.

Parameters:
vertices | Specifies the array of input positions.
count | indicates the number of vertices to copy.
Remarks:
Use this function to specify position data for this VertexAttributeSet. A single position is required to have three coordinates of type float. Positions that previously were specified for this VertexAttributeSet will be released prior to copying the new positions.

The vertices initially are enable for rendering if specified using this function. Alternatively, you can use setVertexData with NVSG_POSITION as first argument to specify positions, but this would require an explicit enable through setEnabled.
See also:
setVertexData, setEnabled

void setVertices | ( | unsigned int | pos,
 |  | const nvmath::Vec3f * | vertices,
 |  | unsigned int | count
 | ) | [inline]

Overwrites position data for this VertexAttributeSet starting at the indicated position.

Parameters:
pos | Marks the zero-based index of the first vertex inside the already specified array of positions, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of position data.
vertices | Specifies the array of input positions.
count | indicates the number of vertices to copy.
Remarks:
Use this setVertices overload to overwrite or to append position data. A single position is required to have three coordinates of type float.
See also:
setVertexData

const nvmath::Vec3f * getVertices ( ) const [inline]

Retrieves position data from the VertexAttributeSet.

Returns:
The function returns the address of the first position stored in the array.

unsigned int getNumberOfVertices ( ) const [inline]

Returns the size of the position array.

Returns:
The function returns the number of positions stored for this VertexAttributeSet.

void setNormals | ( | const nvmath::Vec3f * | normals,
 |  | unsigned int | count
 | ) | [inline]

Sets normals for this VertexAttributeSet.

Parameters:
normals | Specifies the normal array.
count | Indicates the size of the input normal array.
Remarks:
Use this function to specify normals for this VertexAttributeArray. Normals that previously were specified for this VertexAttributeSet will be released prior to copying the new normals.

The normals initially are enable for rendering if specified using this function. Alternatively, you can use setVertexData with NVSG_NORMAL as first argument to specify normals, but this would require an explicit enable through setEnabled.
See also:
setVertexData, setEnabled

void setNormals | ( | unsigned int | pos,
 |  | const nvmath::Vec3f * | normals,
 |  | unsigned int | count
 | ) | [inline]

Overwrites normals for this VertexAttributeSet starting at the indicated position.

Parameters:
pos | Marks the zero-based index of the first vertex inside the already specified array of normals, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of normals.
normals | Specifies the normal array.
count | Indicates the size of the input normal array.
Remarks:
Use this setNormals overload to overwrite or to append normal data.
See also:
setVertexData

const nvmath::Vec3f * getNormals ( ) const [inline]

Retrieves normals from the VertexAttributeSet.

Returns:
The function returns the address of the first normal stored in the array.

unsigned int getNumberOfNormals ( ) const [inline]

Returns the size of the normal array.

Returns:
The function returns the number of normals stored for this VertexAttributeSet.

void setColors | ( | const nvmath::Vecnt< N, T > * | colors,
 |  | unsigned int | count
 | ) | [inline]

Sets vertex colors for this VertexAttributeSet.

Parameters:
colors | Specifies the input color array.
count | Indicates the size of the input color array.
Remarks:
Use this function to specify colors for this VertexAttributeSet. Colors can be specified to have N=3, and N=4 components of type T=char, T=unsigned char, T=short, T=unsigned short, T=int, T=unsigned int, T=float, and T=double. Colors that previously were specified for this VertexAttributeSet will be released prior to copying the new colors.

The colors initially are enable for rendering if specified using this function. Alternatively, you can use setVertexData with NVSG_COLOR as first argument to specify vertex colors, but this would require an explicit enable through setEnabled.
See also:
setVertexData, setEnabled

void setColors | ( | unsigned int | pos,
 |  | const nvmath::Vecnt< N, T > * | colors,
 |  | unsigned int | count
 | ) | [inline]

Overwrites colors for this VertexAttributeSet starting at the indicated position.

Parameters:
pos | Marks the zero-based index of the first color inside the already specified color array, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of colors.
colors | Specifies the input color array.
count | Indicates the size of the input color array.
Remarks:
Use this function to overwrite or append colors for this VertexAttributeSet. Colors can be specified to have N=3, and N=4 components of type T=char, T=unsigned char, T=short, T=unsigned short, T=int, T=unsigned int, T=float, and T=double. Specifying a different number of color components (N), or a different type (T) than specified with a previous setColors call results in undefined behavior!

const void * getColors ( ) const [inline]

Retrieves colors from the VertexAttributeSet.

Returns:
The function returns the address of the first color stored in the array.

unsigned int getNumberOfColors ( ) const [inline]

Returns the size of the color array.

Returns:
The function returns the number of colors stored for this VertexAttributeSet.

unsigned int getSizeOfColors ( ) const [inline]

Returns the number of components per color.

Returns:
The function returns the number of components per color as specified with a previous call to setColors.

unsigned int getTypeOfColors ( ) const [inline]

Returns the type of each color component.

Returns:
The function returns a symbolic constant representing the type of each component of the currently stored colors.

void setSecondaryColors | ( | const nvmath::Vecnt< 3, T > * | colors,
 |  | unsigned int | count
 | ) | [inline]

Sets secondary colors for this VertexAttributeSet.

Parameters:
colors | Specifies the input color array.
count | Indicates the size of the input color array.
Remarks:
Use this function to specify secondary colors for this VertexAttributeSet. Secondary colors can be specified as three-component colors, of type T=char, T=unsigned char, T=short, T=unsigned short, T=int, T=unsigned int, T=float, and T=double. Secondary colors that previously were specified for this VertexAttributeSet will be released prior to copying the new colors.

The secondary colors initially are enable for rendering if specified using this function. Alternatively, you can use setVertexData with NVSG_SECONDARY_COLOR as first argument to specify secondary colors, but this would require an explicit enable through setEnabled.
See also:
setVertexData, setEnabled

void setSecondaryColors | ( | unsigned int | pos,
 |  | const nvmath::Vecnt< 3, T > * | colors,
 |  | unsigned int | count
 | ) | [inline]

Overwrites colors for this VertexAttributeSet starting at the indicated position.

Parameters:
pos | Marks the zero-based index of the first color inside the already specified color array, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of colors.
colors | Specifies the input color array.
count | Indicates the size of the input color array.
Remarks:
Use this function to overwrite or append secondary colors for this VertexAttributeSet. Secondary colors can be specified as three-component colors, of type T=char, T=unsigned char, T=short, T=unsigned short, T=int, T=unsigned int, T=float, and T=double. Specifying a different type (T) than specified with a previous setSecondaryColors call results in undefined behavior!

const void * getSecondaryColors ( ) const [inline]

Retrieves secondary colors from the VertexAttributeSet.

Returns:
The function returns the address of the first secondary color stored in the array.

unsigned int getNumberOfSecondaryColors ( ) const [inline]

Returns the size of the secondary color array.

Returns:
The function returns the number of secondary colors stored for this VertexAttributeSet.

unsigned int getTypeOfSecondaryColors ( ) const [inline]

Returns the type of each secondary color component.

Returns:
The function returns a symbolic constant representing the type of each component of the currently stored secondary colors.

void setFogCoords | ( | const T * | coords,
 |  | unsigned int | count
 | ) | [inline]

Sets fog coordinates for this VertexAttributeSet.

Parameters:
coords | Specifies the input coordinate array.
count | Indicates the size of the input coordinate array.
Remarks:
Use this function to specify fog coordinates for this VertexAttributeSet. Fog coordinates can be specified as single-component coordinates, of type T=float, and T=double. Fog coordinates that previously were specified for this VertexAttributeSet will be released prior to copying the new coordinates.

The fog coordinates initially are enable for rendering if specified using this function. Alternatively, you can use setVertexData with NVSG_FOG_COORD as first argument to specify fog coordinates, but this would require an explicit enable through setEnabled.
See also:
setVertexData, setEnabled

void setFogCoords | ( | unsigned int | pos,
 |  | T * | coords,
 |  | unsigned int | count
 | ) | [inline]

Overwrites fog coordinates starting at the indicated position.

Parameters:
pos | Marks the zero-based index of the first coordinate inside the already specified fog coordinate array, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of fog coordinates.
coords | Specifies the input coordinate array.
count | Indicates the size of the input coordinate array.
Remarks:
Use this function to overwrite or append fog coordinates. Fog coordinates can be specified as single-component coordinates, of type T=float, and T=double. Specifying a different type (T) than specified with a previous setFogCoords call results in undefined behavior!

const void * getFogCoords ( ) const [inline]

Retrieves fog coordinates from the VertexAttributeSet.

Returns:
The function returns the address of the first coordinate stored in the array.

unsigned int getNumberOfFogCoords ( ) const [inline]

Returns the size of the fog coordinate array.

Returns:
The function returns the number of fog coordinates stored for this VertexAttributeSet.

unsigned int getTypeOfFogCoords ( ) const [inline]

Returns the type of the fog coordinates.

Returns:
The function returns a symbolic constant representing the type of the currently stored fog coordinates.

void setTexCoords | ( | unsigned int | unit,
 |  | const nvmath::Vecnt< N, T > * | coords,
 |  | unsigned int | count
 | ) | [inline]

Sets a texture coordinate array.

Parameters:
unit | Specifies the texture unit for which to specify the texture coordinate array.
coords | Specifies the input coordinate array.
count | Indicates the size of the input coordinate array.
Remarks:
Use this function to specify a texture coordinate array for the indicated texture unit. An array element can be specified to have N=1, N=2, N=3, and N=4 coordinates of type T=short, T=int, T=float, or T=double. Texture coordinates that previously were specified for the indicated texture unit will be released prior to copying the new texture coordinates.

The texture coordinates initially are enable for rendering if specified using this function. Alternatively, you can use setVertexData with NVSG_TEXCOORD0+unit as first argument to specify texture coordinates, but this would require an explicit enable through setEnabled.
See also:
setVertexData, setEnabled

void setTexCoords | ( | unsigned int | unit,
 |  | unsigned int | pos,
 |  | const nvmath::Vecnt< N, T > * | coords,
 |  | unsigned int | count
 | ) | [inline]

Overwrites texture coordinates starting at the indicated position.

Parameters:
unit | Specifies the texture unit for which to specify the texture coordinates.
pos | Marks the zero-based index of the first coordinate inside the already specified texture coordinate array, where overwriting should start. If the magic value ~0 is specified, the input data will be appended to the array of texture coordinates.
coords | Specifies the input coordinate array.
count | Indicates the size of the input coordinate array.
Remarks:
Use this function to overwrite or append texture coordinates for the indicated texture unit. Texture coordinates can be specified to have N=1, N=2, N=3, and N=4 components of type T=short, T=int, T=float, and T=double. Specifying a different number of components (N), or a different type (T) than specified with a previous setTexCoords call results in undefined behavior!

const void * getTexCoords ( unsigned int unit ) const [inline]

Retrieves texture coordinates set for the indicated texture unit.

Parameters:
unit Specifies the texture unit to query.
Returns:
The function returns the address of the first coordinate stored in the array.

unsigned int getNumberOfTexCoords ( unsigned int unit ) const [inline]

Returns the size of the texture coordinate array.

Parameters:
unit Specifies the texture unit to query.
Returns:
The function returns the number of texture coordinate array elements stored for the indicated texture unit.

unsigned int getSizeOfTexCoords ( unsigned int unit ) const [inline]

Returns the number of coordinates per texture coordinate array element.

Parameters:
unit Specifies the texture unit to query.
Returns:
The function returns the number of coordinates per texture coordinate array element.

unsigned int getTypeOfTexCoords ( unsigned int unit ) const [inline]

Returns the type of each texture coordinate.

Parameters:
unit Specifies the texture unit to query.
Returns:
The function returns a symbolic constant representing the type of each coordinate in an element of the texture coordinate array currently assigned to the indicated texture unit.

NVSG_API VertexAttributeSet& operator= ( const VertexAttributeSet & rhs )

Assignment operator.

Performs a deep copy.

virtual NVSG_API bool isCompatible ( const VertexAttributeSet * p ) const [virtual]

Test for compatibility with an other VertexAttributeSet.

Parameters:
p A pointer to the constant VertexAttributeSet to test for compatibility with.
Returns:
true if the SkinnedVertexAttributeSet p is compatible with this, otherwise false.
Remarks:
A VertexAttributeSet is compatible with an other, if they have the same object code, and each VertexAttribute is of the same size and type, with the same flags.
See also:
getObjectCode, getSizeOfVertexData, getTypeOfVertexData, isEnabled, isNormalizedEnabled

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other VertexAttributeSet.

Returns:
true if the VertexAttributeSet p is equivalent to this VertexAttributeSet.
Parameters:
p | VertexAttributeSet to test for equivalence with
ignoreNames | are the names to be ignored?
deepCompare | deep compare?

Reimplemented from Object.

Reimplemented in AnimatedVertexAttributeSet.

virtual NVSG_API bool containsAnimation ( ) const [virtual]

Interface to determine if an Object contains an Animation.

Returns:
c\ false, because a VertexAttributeSet never contains an Animation.

Reimplemented in AnimatedVertexAttributeSet.

NVSG_API void releaseCachedData ( ) [protected]

Release the cached data and all it's owners.

NVSG_API void invalidateBoundingVolumes ( ) [protected]

Invalidate the bounding volumes of all it's owners.

Remarks:
This is called on re-specifying POSITION/ATTR0 data.

Friends And Related Function Documentation

NVSG_API void generateTexCoords | ( | VertexAttributeSet * | vas,
 |  | TextureCoordType | tct,
 |  | const nvmath::Sphere3f & | sphere,
 |  | unsigned int | tu = 0
 | ) | [related]

Generate texture coordinates into a texture unit. Calculates either spherical, cylindrical, or planar two-dimensional texture coordinates into texture unit tu. The sphere can be either the bounding sphere of this PrimitiveSet to calculate local texture coordinates or some other for non-local texture coordinates.

Parameters:
vas | pointer to the VertexAttributeSet to use
tct | type of texture coordinates to generate
sphere | bounding sphere to map coordinates to
tu | texture unit to generate the coordinates in

The documentation for this class was generated from the following file:
  • VertexAttributeSet.h
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


Member List

VertexAttributeSet Member List

This is the complete list of members for VertexAttributeSet, including all inherited members.
addOwner(typename PrimitiveSetHandle::ObjectType *obj) | OwnedObject< PrimitiveSetHandle > | [protected]
ConstOwnerIterator typedef | OwnedObject< PrimitiveSetHandle > | [protected]
containsAnimation() const | VertexAttributeSet | [virtual]
enterCS() const | Object | [inline, protected]
generateTexCoords(VertexAttributeSet *vas, TextureCoordType tct, const nvmath::Sphere3f &sphere, unsigned int tu=0) | VertexAttributeSet | [related]
getAnnotation() const | Object |
getColors() const | VertexAttributeSet | [inline]
getDataID(void) const | VertexAttributeSet | [virtual]
getFogCoords() const | VertexAttributeSet | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getName() const | Object |
getNormals() const | VertexAttributeSet | [inline]
getNumberOfColors() const | VertexAttributeSet | [inline]
getNumberOfFogCoords() const | VertexAttributeSet | [inline]
getNumberOfNormals() const | VertexAttributeSet | [inline]
getNumberOfOwners() const | OwnedObject< PrimitiveSetHandle > |
getNumberOfSecondaryColors() const | VertexAttributeSet | [inline]
getNumberOfTexCoords(unsigned int unit) const | VertexAttributeSet | [inline]
getNumberOfVertexData(unsigned int attrib) const | VertexAttributeSet | [virtual]
getNumberOfVertices() const | VertexAttributeSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(unsigned int index) const | OwnedObject< PrimitiveSetHandle > |
getSecondaryColors() const | VertexAttributeSet | [inline]
getSizeOfColors() const | VertexAttributeSet | [inline]
getSizeOfTexCoords(unsigned int unit) const | VertexAttributeSet | [inline]
getSizeOfVertexData(unsigned int attrib) const | VertexAttributeSet | [virtual]
getTexCoords(unsigned int unit) const | VertexAttributeSet | [inline]
getTypeOfColors() const | VertexAttributeSet | [inline]
getTypeOfFogCoords() const | VertexAttributeSet | [inline]
getTypeOfSecondaryColors() const | VertexAttributeSet | [inline]
getTypeOfTexCoords(unsigned int unit) const | VertexAttributeSet | [inline]
getTypeOfVertexData(unsigned int attrib) const | VertexAttributeSet | [virtual]
getUserData() const | Object | [inline]
getVertexData(unsigned int attrib) const | VertexAttributeSet | [virtual]
getVertices() const | VertexAttributeSet | [inline]
invalidateBoundingVolumes() | VertexAttributeSet | [protected]
invalidateIncarnation() | OwnedObject< PrimitiveSetHandle > | [virtual]
isCompatible(const VertexAttributeSet *p) const | VertexAttributeSet | [virtual]
isDataShared(void) const | VertexAttributeSet | [virtual]
isEnabled(unsigned int attrib) const | VertexAttributeSet | [inline]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | VertexAttributeSet | [virtual]
isNormalizeEnabled(unsigned int attrib) const | VertexAttributeSet | [inline]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_objectCode | Object | [protected]
NVSG_ATTR0 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR1 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR10 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR11 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR12 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR13 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR14 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR15 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR2 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR3 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR4 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR5 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR6 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR7 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR8 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_ATTR9 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_COLOR enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_FOG_COORD enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_NORMAL enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_POSITION enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_SECONDARY_COLOR enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD0 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD1 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD2 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD3 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD4 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD5 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD6 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_TEXCOORD7 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_UNUSED_1 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_UNUSED_2 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_VERTEX_ATTRIB_COUNT enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NVSG_VERTEX_WEIGHT enum value (defined in VertexAttributeSet) | VertexAttributeSet |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const VertexAttributeSet &rhs) | VertexAttributeSet |
nvsg::OwnedObject< PrimitiveSetHandle >::operator=(const OwnedObject< PrimitiveSetHandle > &rhs) | OwnedObject< PrimitiveSetHandle > |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
OwnedObject() | OwnedObject< PrimitiveSetHandle > | [protected]
OwnedObject(const Object &rhs) | OwnedObject< PrimitiveSetHandle > | [protected]
OwnedObject(const OwnedObject< PrimitiveSetHandle > &rhs) | OwnedObject< PrimitiveSetHandle > | [protected]
OwnerIterator typedef | OwnedObject< PrimitiveSetHandle > | [protected]
ownersBegin() const | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersBegin() | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersEnd() const | OwnedObject< PrimitiveSetHandle > | [inline, protected]
ownersEnd() | OwnedObject< PrimitiveSetHandle > | [inline, protected]
releaseCachedData() | VertexAttributeSet | [protected]
removeOwner(typename PrimitiveSetHandle::ObjectType *obj) | OwnedObject< PrimitiveSetHandle > | [protected]
removeVertexData(unsigned int attrib) | VertexAttributeSet | [virtual]
setAnnotation(const std::string &anno) | Object |
setColors(const nvmath::Vecnt< N, T > *colors, unsigned int count) | VertexAttributeSet | [inline]
setColors(unsigned int pos, const nvmath::Vecnt< N, T > *colors, unsigned int count) | VertexAttributeSet | [inline]
setEnabled(unsigned int attrib, bool enable) | VertexAttributeSet | [inline]
setFogCoords(const T *coords, unsigned int count) | VertexAttributeSet | [inline]
setFogCoords(unsigned int pos, T *coords, unsigned int count) | VertexAttributeSet | [inline]
setName(const std::string &name) | Object |
setNormalizeEnabled(unsigned int attrib, bool enable) | VertexAttributeSet | [inline]
setNormals(const nvmath::Vec3f *normals, unsigned int count) | VertexAttributeSet | [inline]
setNormals(unsigned int pos, const nvmath::Vec3f *normals, unsigned int count) | VertexAttributeSet | [inline]
setSecondaryColors(const nvmath::Vecnt< 3, T > *colors, unsigned int count) | VertexAttributeSet | [inline]
setSecondaryColors(unsigned int pos, const nvmath::Vecnt< 3, T > *colors, unsigned int count) | VertexAttributeSet | [inline]
setTexCoords(unsigned int unit, const nvmath::Vecnt< N, T > *coords, unsigned int count) | VertexAttributeSet | [inline]
setTexCoords(unsigned int unit, unsigned int pos, const nvmath::Vecnt< N, T > *coords, unsigned int count) | VertexAttributeSet | [inline]
setUserData(const void *userData) | Object | [inline]
setVertexData(unsigned int attrib, unsigned int size, unsigned int type, const void *data, unsigned int count) | VertexAttributeSet | [virtual]
setVertexData(unsigned int attrib, unsigned int pos, unsigned int size, unsigned int type, const void *data, unsigned int count) | VertexAttributeSet | [virtual]
setVertexData(unsigned int attrib, const unsigned int *to, const unsigned int *from, unsigned int size, unsigned int type, const void *data, unsigned int count) | VertexAttributeSet | [virtual]
setVertices(const nvmath::Vec3f *vertices, unsigned int count) | VertexAttributeSet | [inline]
setVertices(unsigned int pos, const nvmath::Vec3f *vertices, unsigned int count) | VertexAttributeSet | [inline]
swapVertexData(unsigned int attrib, VertexAttribute &rhs) | VertexAttributeSet | [virtual]
validateIncarnation() const | Object | [virtual]
VertexAttributeSet() | VertexAttributeSet |
VertexAttributeSet(const VertexAttributeSet &rhs) | VertexAttributeSet |
~Object() | Object | [virtual]
~OwnedObject() | OwnedObject< PrimitiveSetHandle > | [protected]
~VertexAttributeSet(void) | VertexAttributeSet | [virtual]
Generated on Tue Jan 15 10:29:23 2008 for NVSGSDK by NVIDIA


VertexUnifyTraverser Class Reference

Traverser that can unifies vertices. More...

#include <VertexUnifyTraverser.h>

Inheritance diagram for VertexUnifyTraverser:

[legend]
Collaboration diagram for VertexUnifyTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | VertexUnifyTraverser (void)
Constructor.

NVSG_API void | setEpsilon (float epsilon)
Set the epsilon to use to distinguish vertex values.

Protected Member Functions

virtual NVSG_API | ~VertexUnifyTraverser (void)
Protected destructor to prevent instantiation of a VertexUnifyTraverser on stack.

virtual NVSG_API void | doApply (nvsg::NodeHandle *root)
Initiate traversal of the scene with a view state.

void | handleVertexAttributeSet (nvsg::VertexAttributeSet *p)
Unify all VertexAttributeSets.

void | handleAnimatedQuads (nvsg::AnimatedQuads *p)
Explicitly nop on Animated and Skinned Primitives.

void | handleAnimatedTriangles (nvsg::AnimatedTriangles *triangles)
void | handleSkinnedTriangles (nvsg::SkinnedTriangles *triangles)
Handler function for a SkinnedTriangles.

Detailed Description

Traverser that can unifies vertices.

Currently, this VertexUnifyTraverser supports Lines, LineStrips, Points, Quads, QuadStrips, Triangles, TriFans, and TriStrips.

Constructor & Destructor Documentation

NVSG_API VertexUnifyTraverser ( void )

Constructor.

virtual NVSG_API ~VertexUnifyTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a VertexUnifyTraverser on stack.

Member Function Documentation

void setEpsilon ( float epsilon ) [inline]

Set the epsilon to use to distinguish vertex values.

This epsilon multiplied by the size of the scene gives the tolerance for detecting equal vertices.

Parameters:
epsilon Epsilon to use

virtual NVSG_API void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Initiate traversal of the scene with a view state.

Calculates the tolerance for the scene and calls the Traverser::doApply().

Reimplemented from OptimizeTraverser.

void handleVertexAttributeSet ( nvsg::VertexAttributeSet * p ) [protected, virtual]

Unify all VertexAttributeSets.

Reimplemented from ExclusiveTraverser.

void handleAnimatedQuads ( nvsg::AnimatedQuads * p ) [protected]

Explicitly nop on Animated and Skinned Primitives.

void handleSkinnedTriangles ( nvsg::SkinnedTriangles * triangles ) [protected, virtual]

Handler function for a SkinnedTriangles.

Parameters:
triangles A pointer to the write-locked Triangles being traversed.
Remarks:
This function is called from the framework whenever a SkinnedTriangles is encountered on traversal. The SkinnedTriangles triangles is already write-locked.
The base implementation first traverses each TrafoAnimation of each bone of each skin, and then calls traversePrimitiveSet().
Note:
When this function is overloaded by a traverser derived from ExclusiveTraverser, it is recommended to always call the base class implementation in order to properly continue traversal.
See also:
traversePrimitiveSet

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • VertexUnifyTraverser.h
Generated on Tue Jan 15 10:29:40 2008 for NVSGSDK by NVIDIA


Member List

VertexUnifyTraverser Member List

This is the complete list of members for VertexUnifyTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | VertexUnifyTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedQuads(nvsg::AnimatedQuads *p) | VertexUnifyTraverser | [protected]
handleAnimatedTransform(nvsg::AnimatedTransform *trafo) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTriangles(nvsg::AnimatedTriangles *triangles) (defined in VertexUnifyTraverser) | VertexUnifyTraverser | [protected]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *billboard) | ExclusiveTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | ExclusiveTraverser | [protected, virtual]
handleGroup(nvsg::Group *group) | ExclusiveTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | VertexUnifyTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *trafo) | ExclusiveTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *p) | VertexUnifyTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setEpsilon(float epsilon) | VertexUnifyTraverser | [inline]
setIgnoreNames(bool ignore) | OptimizeTraverser | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
VertexUnifyTraverser(void) | VertexUnifyTraverser |
wasTraversalInterrupted() | Traverser | [inline]
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
~VertexUnifyTraverser(void) | VertexUnifyTraverser | [protected, virtual]
Generated on Tue Jan 15 10:29:40 2008 for NVSGSDK by NVIDIA


ViewState Class Reference

The ViewState class encapsulates the view-specific states. More...

#include <ViewState.h>

Collaboration diagram for ViewState:

[legend]
List of all members.

Public Types

enum | JitterCombineTechnique { JCT_NONE, JCT_CROSS_PRODUCT, JCT_HIGHER_PASS }

Public Member Functions

NVSG_API | ViewState ()
Default-constructs a ViewState.

NVSG_API | ViewState (const ViewState &rhs)
Copy-constructs a ViewState from another ViewState.

virtual NVSG_API | ~ViewState ()
Destructs a ViewState.

NVSG_API bool | isAnimating () const
Test if there is currently an animation running.

NVSG_API void | setAnimating (bool animating)
Set the animation state of this view.

NVSG_API bool | advanceAnimation (unsigned int tick, int delta=1)
Advance the animation to the next tick, using the specified step size.

NVSG_API unsigned int | getCurrentTick () const
Get the current tick to use for animations.

NVSG_API int | getCurrentDelta () const
Get the current delta to use for animations.

NVSG_API void | setCamera (CameraHandle *camera)
Sets the Camera for this view.

NVSG_API CameraHandle * | getCamera () const
Returns the current Camera.

NVSG_API bool | isJitter () const
Test if the view is in jitter mode.

NVSG_API unsigned int | getNumberOfJitters () const
Get the number of jitters set for this view.

NVSG_API void | setFSAAJitters (const std::vector< nvmath::Vec2f > &fsaaJitters)
Set the FSAA jitter information for this view.

NVSG_API void | setDoFJitters (const std::vector< nvmath::Vec2f > &dofJitters)
Set the DoF jitter information for this view.

NVSG_API void | setJittersCombineMethod (JitterCombineTechnique method)
Set the choice to combine the FSAA and DoF jitters information into a combined one.

NVSG_API const std::vector<
nvmath::Vec2f > * 		getFSAAJitters () const
Retrieve the current jitter values for Full Scene Anti Aliasing(FSAA).

NVSG_API const std::vector<
nvmath::Vec2f > * 		getDoFJitters () const
Retrieve the current jitter values for Depth-Of-Field(DoF).

NVSG_API const unsigned int | getNumberOfFSAAJitters () const
Get the number of FSAA Jitter values.

NVSG_API const unsigned int | getNumberOfDoFJitters () const
Get the number of DoF Jitter values.

NVSG_API JitterCombineTechnique | getJittersCombineMethod () const
Get the current choice of method to combine both FSAA and DoF jitters.

NVSG_API const std::vector<
std::pair< nvmath::Vec2f,
nvmath::Vec2f > > & 		getJitters (std::vector< std::pair< nvmath::Vec2f, nvmath::Vec2f > > &inout) const
Retrieve resulting jitter values after combining FSAA and DoF jitters.

NVSG_API float | getTargetDistance () const
Get the distance to the target point.

NVSG_API void | setTargetDistance (float dist)
Set the distance to the target point.

NVSG_API bool | isStereo () const
Test if the view is in stereo mode.

NVSG_API void | setStereo (bool state)
Turn stereo rendering on and off.

NVSG_API void | toggleStereo ()
Toggle stereo rendering on and off.

NVSG_API bool | isStereoAutomaticEyeDistanceAdjustment () const
Test on automatic eye distance calculation.

NVSG_API void | setStereoAutomaticEyeDistanceAdjustment (bool state)
Enable/Disable automatic eye distance adjustment.

NVSG_API float | getStereoAutomaticEyeDistanceFactor () const
Get the automatic eye distance adjustment factor.

NVSG_API void | setStereoAutomaticEyeDistanceFactor (float factor)
Set the automatic eye distance adjustment factor.

NVSG_API float | getStereoEyeDistance () const
Get the eye distance for stereo rendering.

NVSG_API void | setStereoEyeDistance (float distance)
Set the eye distance for stereo rendering.

NVSG_API void | stereoReverseEyes ()
Reverse the left and the right eye for stereo rendering.

NVSG_API bool | isStereoReversedEyes () const
Test on reversed eyes in stereo rendering.

NVSG_API void | setLODRangeScale (float factor)
Set the LOD range scale factor.

NVSG_API float | getLODRangeScale () const
Get the LOD range scale factor Get the LOD range scale factor.

NVSG_API void | clearCullTree ()
Clear the current cull-data tree.

NVSG_API const CullData * | getCullTree () const
Get the root of the cull-data tree.

NVSG_API void | setCullTree (const CullData *cullTree)
set an existing cull-data tree as the current cull-data tree.

NVSG_API MapListHandle * | getMapList () const
Returns the current MapList.

NVSG_API void | setMapList (MapListHandle *ml)
Sets the MapList.

NVSG_API void | setViewportSize (unsigned int width, unsigned int height)
Set the size of the viewport in pixels.

NVSG_API unsigned int | getViewportWidth () const
Get the width of the viewport in pixels.

NVSG_API unsigned int | getViewportHeight () const
Get the height of the viewport in pixels.

NVSG_API const nvutil::Incarnation & | getIncarnation () const
Returns the actual incarnation count of this ViewState.

NVSG_API const nvutil::Incarnation & | getCullTreeIncarnation () const

Detailed Description

The ViewState class encapsulates the view-specific states.

Namespace: nvsg
Remarks:
The ViewState encapsulates the view-specific information into one object. The ViewState defines how the user looks at the scene. It contains the camera and specific viewing settings like stereo or jitter view, does the bookkeeping of animation information, and it contains the actual cull information for this specific view into the scene.

nvui::RenderArea, nvsg::ViewState and nvsg::Scene are the three major components that need to come together to produce a rendered image. The scene contains basically the tree, the ViewState defines how to look at the tree, and the RenderArea connects the the other two and provides a place and tools (traverser) to render the final image.
Example
The following pseudo code shows how to set up this triple for Rendering:
  [...]
  // setup the Scene
  pScene = Scene::create();
  pScene->addRef();
  Scene * pNCScene = beginEdit(m_pScene);
   pNCScene->setRootNode(pRoot);
  endEdit(pNCScene);

  // setup the ViewState
  pViewState = ViewState::create();
  pViewState->addRef();

  ViewState * pNCViewState = beginEdit(pViewState);
    pNCViewState->setCamera(PerspectiveCamera::create());
  endEdit(pNCViewState);

  // bring RenderArea, Scene and ViewState together
  pRA = setupRenderArea();
  pRA->setSceneData( pScene, pViewState );
  [...]
See also:
nvui::RenderArea, Scene

Member Enumeration Documentation

enum JitterCombineTechnique

Enumeration values:
JCT_NONE | do not combine
JCT_CROSS_PRODUCT | take the set cross product of FSAA and DoF to form the resulting jitters
JCT_HIGHER_PASS | take the higher number of passes among FSAA and DoF, to be the size of resulting jitters.

Constructor & Destructor Documentation

NVSG_API ViewState ( )

Default-constructs a ViewState.

Remarks:
After instantiation, the ViewState has the following properties:
  • no animation running
  • no camera defined
  • no jitter
  • no stereo
  • no LOD range scaling
  • no cull information

NVSG_API ViewState ( const ViewState & rhs )

Copy-constructs a ViewState from another ViewState.

Parameters:
rhs Source ViewState.

virtual NVSG_API ~ViewState ( ) [virtual]

Destructs a ViewState.

Member Function Documentation

bool isAnimating ( ) const [inline]

Test if there is currently an animation running.

Returns:
The return value of this function is true when an animation is currently running.
Remarks:
This function can be used to determine the animation state of the view.
See also:
setAnimating

void setAnimating ( bool animating ) [inline]

Set the animation state of this view.

Parameters:
animating Parse in true to enable animation, otherwise false.
Remarks:
This function controls the animation state of the view. Animation can be turned on and off.
Example
The following sample code shows how to turn on/off the animation.
  [...]
  if (!pViewState->isAnimating())
  {
    ViewState * ncViewState = beginEdit(viewState);
      viewState->setAnimating(true);
    endEdit(ncViewState);

    m_animationManip = new AnimationManipulator;
    m_animationManip->setRenderArea(m_pRA);

    // Could be NULL, if there is no camera animation
    m_animationManip->setCameraAnimation(GetDocument()->getScene()->getCameraAnimation());
  }
  else
  {
    ViewState * ncViewState = beginEdit(viewState);
      ncViewState->setAnimating(false);
    endEdit(ncViewState);

    if (m_animationManip)
    {
      delete m_animationManip;
      m_animationManip = NULL;
    }
  }
  [...]
See also:
nvui::AnimationManipulator, isAnimating

NVSG_API bool advanceAnimation | ( | unsigned int | tick,
 |  | int | delta = 1
 | ) |

Advance the animation to the next tick, using the specified step size.

Parameters:
tick | The tick for the next animation step.
delta | The number of steps to go from the previous tick.
Returns:
true, if animations currently are running, otherwise false.
Remarks:
A ViewState feeds the tick and delta into the scene used.
See also:
getCurrentTick, getCurrentDelta

unsigned int getCurrentTick ( ) const [inline]

Get the current tick to use for animations.

Returns:
The current tick to feed into a scene for animation purposes.
Remarks:
Each running Animation advances, when the current tick is different from its previous tick.
See also:
advanceAnimation, getCurrentDelta

int getCurrentDelta ( ) const [inline]

Get the current delta to use for animations.

Returns:
The current delta specifying the number of steps on a changing tick.
Remarks:
Each running Animation advances by this delta steps per animation tick.
See also:
advanceAnimation, getCurrentTick

void setCamera ( CameraHandle * camera ) [inline]

Sets the Camera for this view.

Parameters:
camera Pointer to a CameraHandle specifying the Camera to set.
Remarks:
The given camera is used for the rendering.
See also:
getCamera

CameraHandle * getCamera ( ) const [inline]

Returns the current Camera.

Returns:
A pointer to a CameraHandle specifying the Camera which is used in this view. If there is no Camera associated with this view, the function returns NULL.
See also:
setCamera

bool isJitter ( ) const [inline]

Test if the view is in jitter mode.

Returns:
The function returns true when the view is in jitter mode.
Remarks:
Jitter mode means that the current camera is used for several passes for rendering but with a slightly changed (jittered) camera projection and/or camera position. This mode can be used for software full-screen antialiasing and/or a depth-of-field effect.
See also:
setFSAAJitters, setDoFJitters, getJitters, getNumberOfFSAAJitters, getNumberOfDoFJitters

NVSG_API unsigned int getNumberOfJitters ( ) const

Get the number of jitters set for this view.

Returns:
Number of jitter passes and jitter information.
Remarks:
The number of jitters corresponds to the number of passes. So every jitter is one pass during the rendering of the final image.
See also:
isJitter, setFSAAJitters, setDoFJitters, getJitters

NVSG_API void setFSAAJitters ( const std::vector< nvmath::Vec2f > & fsaaJitters )

Set the FSAA jitter information for this view.

Parameters:
fsaaJitters Vector of two-dimensional displacement vectors.
Remarks:
These jitter values are used to perform software full-screen anti aliasing The first displacement vector represents the number of pixels the projection is jittered in the x- and y- direction in screen space. This results in some full scene anti-aliasing effect. The number of rendering passes is either equal to the number of jitters (if only one of FSAA and DoF is enabled) or is calculated by using the user's choice of JittersCombineMethod.

NVSG_API void setDoFJitters ( const std::vector< nvmath::Vec2f > & dofJitters )

Set the DoF jitter information for this view.

Parameters:
dofJitters Vector of two-dimensional displacement vectors.
Remarks:
These jitter values are used to perform Depth of Field jittering. The displacement vector represents the number of world units the camera is jittered. To make them relative to the scene, they are multiplied by half of a percent of the focus distance. This results in some depth-of-field effect. The number of rendering passes is either equal to the number of jitters (if only one of FSAA and DoF is enabled) or is calculated by using the user's choice of JittersCombineMethod.

void setJittersCombineMethod ( JitterCombineTechnique method ) [inline]

Set the choice to combine the FSAA and DoF jitters information into a combined one.

Parameters:
method Set this parameter out of the following options JCT_NONE: equivalent to setting no combine technique at all. JCT_CROSS_PRODUCT: Take the cross product of two jitters, e.g., total no. of jitters = numFSAAJitters * numDoFJitters JCT_HIGHER_PASS: Take the number of jitters which is greater among FSAA and DoF, e.g. if 2xFSAA and 3xDoF then total no. of jitters = 3 Addtional jitters are set to zero valued pair.

const std::vector< nvmath::Vec2f > * getFSAAJitters ( ) const [inline]

Retrieve the current jitter values for Full Scene Anti Aliasing(FSAA).

Returns:
A reference to the constant vector of jitter values.
Remarks:
This function can be used to retrieve the currently used offsets for the FSAA jittering. The application should call ViewState::getNumberOfFSAAJitters to determine the size of the array containing the FSAA jitter values.
See also:
setFSAAJitters, setDoFJitters, getNumberOfFSAAJitters, isJitter, setJittersCombineMethod

const std::vector< nvmath::Vec2f > * getDoFJitters ( ) const [inline]

Retrieve the current jitter values for Depth-Of-Field(DoF).

Returns:
A reference to the constant vector of jitter values.
Remarks:
This function can be used to retrieve the currently used offsets for the DoF jittering. The application should call ViewState::getNumberOfDoFJitters to determine the size of the array containing the DoF jitter values.
See also:
setDoFJitters, getNumberOfDoFJitters, isJitter

const unsigned int getNumberOfFSAAJitters ( ) const [inline]

Get the number of FSAA Jitter values.

Returns:
Number of FSAA jitter values

const unsigned int getNumberOfDoFJitters ( ) const [inline]

Get the number of DoF Jitter values.

Returns:
A reference to number of DoF jitter values

ViewState::JitterCombineTechnique getJittersCombineMethod ( ) const [inline]

Get the current choice of method to combine both FSAA and DoF jitters.

Returns:
Returns value JCT_CROSS_PRODUCT or JCT_HIGHER_PASS. If only one of FSAA and DoF is enabled, the return value would be JCT_NONE

NVSG_API const std::vector<std::pair < nvmath::Vec2f,nvmath::Vec2f> >& getJitters ( std::vector< std::pair< nvmath::Vec2f, nvmath::Vec2f > > & inout ) const

Retrieve resulting jitter values after combining FSAA and DoF jitters.

Parameters:
inout A vector of pair of Vec2f values, which holds the resulting(combined) jitters after the function returns.
Returns:
A reference to a constant vector of pair of jitter values. Each pair containing Vec2f values from FSAA and DoF jitters
Remarks:
This function is used to query resulting jitters
See also:
getNumberOfJitters, isJitter

float getTargetDistance ( ) const [inline]

Get the distance to the target point.

Returns:
The distance from the current view point to the target point.
Remarks:
The target point is used as the reference point for rotations of the camera.
See also:
setTargetDistance

void setTargetDistance ( float dist ) [inline]

Set the distance to the target point.

Parameters:
dist distance between the view point (camera position) and the target point.
Remarks:
The target point is used as the reference point for rotations of the camera.
See also:
getTargetDistance

bool isStereo ( ) const [inline]

Test if the view is in stereo mode.

Returns:
This function returns true when the view is rendered in stereo.
See also:
setStereo

void setStereo ( bool state ) [inline]

Turn stereo rendering on and off.

Parameters:
state To turn stereo on the application must pass in true. False turns stereo rendering off.
Remarks:
This function controls whether stereoscopic rendering is turned on or off.
See also:
isStereo, toggleStereo

void toggleStereo ( ) [inline]

Toggle stereo rendering on and off.

Remarks:
Use this method to toggle between stereoscopic and non-stereoscopic rendering.
See also:
isStereo, setStereo

bool isStereoAutomaticEyeDistanceAdjustment ( ) const [inline]

Test on automatic eye distance calculation.

Returns:
This function returns true when the distance is automatically calculated.
Remarks:
This function can be used to test if the automatic eye distance calculation for stereo is turned on. The automatic eye distance is calculated by multiplying the adjustment factor by the focus distance of the camera.
See also:
setStereoAutomaticEyeDistanceAdjustment, getStereoAutomaticEyeDistanceFactor, setStereoAutomaticEyeDistanceFactor

void setStereoAutomaticEyeDistanceAdjustment ( bool state ) [inline]

Enable/Disable automatic eye distance adjustment.

Parameters:
state Pass in true to enable automatic eye distance calculation.
Remarks:
The automatic eye distance is calculated by multiplying the adjustment factor by the focus distance of the camera.
See also:
isStereoAutomaticEyeDistanceAdjustment, getStereoAutomaticEyeDistanceFactor, setStereoAutomaticEyeDistanceFactor

float getStereoAutomaticEyeDistanceFactor ( ) const [inline]

Get the automatic eye distance adjustment factor.

Returns:
This function returns the eye distance adjustment factor.
Remarks:
The automatic eye distance is calculated by multiplying the adjustment factor by the focus distance of the camera.
Example
See also:
setStereoAutomaticEyeDistanceAdjustment, getStereoAutomaticEyeDistanceFactor, setStereoAutomaticEyeDistanceFactor

void setStereoAutomaticEyeDistanceFactor ( float factor ) [inline]

Set the automatic eye distance adjustment factor.

Parameters:
factor Distance factor.
Remarks:
The automatic eye distance is calculated by multiplying the adjustment factor by the focus distance of the camera.
The default value is 0.03 (3%). This value represents the following setup:
A person with an eye distance of about six cm sitting in front of the monitor, where the monitor is about one meter away. This setup leads to very natural stereo impression.
See also:
isStereoAutomaticEyeDistanceAdjustment, getStereoAutomaticEyeDistanceFactor, setStereoAutomaticEyeDistanceFactor

float getStereoEyeDistance ( ) const [inline]

Get the eye distance for stereo rendering.

Returns:
This function returns the eye distance. If the camera of this ViewState is not valid, the behavior is undefined.
Remarks:
The eye distance can be automatically calculated or manually set by the application. Make sure that a valid camera is defined when asking for the eye distance since the the automatic eye distance calculation is based on the focus distance of the camera of this ViewState.
See also:
setStereoEyeDistance, isStereoAutomaticEyeDistanceAdjustment, isStereoAutomaticEyeDistanceAdjustment, getStereoAutomaticEyeDistanceFactor, setStereoAutomaticEyeDistanceFactor

void setStereoEyeDistance ( float distance ) [inline]

Set the eye distance for stereo rendering.

Parameters:
distance Distance between the left and the right eye.
Remarks:
This function manually sets the eye distance for stereo rendering.
See also:
setStereoEyeDistance, isStereoAutomaticEyeDistanceAdjustment, isStereoAutomaticEyeDistanceAdjustment, getStereoAutomaticEyeDistanceFactor, setStereoAutomaticEyeDistanceFactor

void stereoReverseEyes ( ) [inline]

Reverse the left and the right eye for stereo rendering.

Remarks:
You will see the image for the left eye on the right eye and vice versa.
See also:
isStereoReversedEyes

bool isStereoReversedEyes ( ) const [inline]

Test on reversed eyes in stereo rendering.

Returns:
This function returns true when the left and the right eye are reversed.
Remarks:
If the eyes are reversed you will see the image for the left eye on the right eye and vice versa.
See also:
stereoReverseEyes

void setLODRangeScale ( float factor ) [inline]

Set the LOD range scale factor.

Parameters:
factor The factor to scale the LOD scale ranges. The default value is 1.f, so the unscaled ranges are used.
Remarks:
This function sets a scaling factor for LOD ranges of the LOD nodes in the tree.
The scale factor can be used to globally scale the ranges without changing the LOD node ranges directly. This can be used, for example, for scenes that were initially created for viewing on small monitors. You can use this scaling to fine-tune these scenes for large projection walls by scaling the LOD levels to switch later to a lower resolution representation.
See also:
LOD::getLODToUse, getLODRangeScale

float getLODRangeScale ( ) const [inline]

Get the LOD range scale factor Get the LOD range scale factor.

Returns:
The LOD range scale factor for all the LOD nodes in the tree. By default this factor is 1.f, so unscaled ranges of the LOD node will be used.
Remarks:
The scale factor can be used to globally scale the ranges without changing the LOD node ranges directly. This can be used, for example, for scenes that were initially created for viewing on small monitors. You can use this scaling to fine-tune these scenes for large projection walls by scaling the LOD levels to switch later to a lower resolution representation.
See also:
LOD::getLODToUse, setLODRangeScale

NVSG_API void clearCullTree ( )

Clear the current cull-data tree.

Remarks:
This function simply clears the cull tree, which means that all the culling information is reset.
One scene graph can be used in different views, so every ViewState contains a special cull tree corresponding to the view.
See also:
getCullTree

const CullData * getCullTree ( ) const [inline]

Get the root of the cull-data tree.

Returns:
A pointer to the constant cull-data tree.
Remarks:
This function can be used to retrieve the current cull-data tree. One scene graph can be used in different views, so every ViewState contains a special cull tree corresponding to the view.
Each CullData corresponds to one object in a scene tree, so the cull-data tree is a somewhat simplified representation of the original scene-graph.
See also:
CullData, setCullTree

NVSG_API void setCullTree ( const CullData * cullTree )

set an existing cull-data tree as the current cull-data tree.

Parameters:
cullTree Pointer to a constant cull-data tree.
Remarks:
Replace the existing cull-data tree with the given one. This function takes care of cleaning up the old cull-data tree before the new one will be assigned. This function can be used when a special cull traverser generated a cull-data tree that needs to be set at once.
See also:
CullData, getCullTree

MapListHandle * getMapList ( ) const [inline]

Returns the current MapList.

Returns:
A pointer to a MapListHandle specifying the MapList.
Remarks:
This function retrieves the current MapList.
A MapList contains two-dimensional maps that can be used to render, for example, overlays for Menus or textual information on top of the scene.
Example
See the MapListViewer tutorial on how to use this functionality.
See also:
MapList, MapObject, setMapList

void setMapList ( MapListHandle * ml ) [inline]

Sets the MapList.

Returns:
A pointer to a MapListHandle specifying the MapList to set.
Remarks:
This function assigns a MapList.
A MapList contains two-dimensional maps that can be used to render, for example, overlays for Menus or textual information on top of the scene.
Example
See the MapListViewer tutorial on how to use this functionality.
See also:
MapList, MapObject, getMapList

NVSG_API void setViewportSize | ( | unsigned int | width,
 |  | unsigned int | height
 | ) |

Set the size of the viewport in pixels.

Parameters:
width | The width of the viewport in pixels.
height | The height of the viewport in pixels.
See also:
getViewportWidth, getViewportHeight

unsigned int getViewportWidth ( ) const [inline]

Get the width of the viewport in pixels.

Returns:
The width of the viewport in pixels.
See also:
setViewportSize, getViewportHeight

unsigned int getViewportHeight ( ) const [inline]

Get the height of the viewport in pixels.

Returns:
The height of the viewport in pixels.
See also:
setViewportSize, getViewportWidth

const nvutil::Incarnation & getIncarnation ( ) const [inline]

Returns the actual incarnation count of this ViewState.

Returns:
The function returns the actual incarnation count of this ViewState.
The returned incarnation count usually is used to test it against a related incarnation count maintained by some client to detect if changes have been made to the ViewState.

The documentation for this class was generated from the following file:
  • ViewState.h
Generated on Tue Jan 15 10:29:24 2008 for NVSGSDK by NVIDIA


Member List

ViewState Member List

This is the complete list of members for ViewState, including all inherited members.
advanceAnimation(unsigned int tick, int delta=1) | ViewState |
clearCullTree() | ViewState |
getCamera() const | ViewState | [inline]
getCullTree() const | ViewState | [inline]
getCullTreeIncarnation() const (defined in ViewState) | ViewState | [inline]
getCurrentDelta() const | ViewState | [inline]
getCurrentTick() const | ViewState | [inline]
getDoFJitters() const | ViewState | [inline]
getFSAAJitters() const | ViewState | [inline]
getIncarnation() const | ViewState | [inline]
getJitters(std::vector< std::pair< nvmath::Vec2f, nvmath::Vec2f > > &inout) const | ViewState |
getJittersCombineMethod() const | ViewState | [inline]
getLODRangeScale() const | ViewState | [inline]
getMapList() const | ViewState | [inline]
getNumberOfDoFJitters() const | ViewState | [inline]
getNumberOfFSAAJitters() const | ViewState | [inline]
getNumberOfJitters() const | ViewState |
getStereoAutomaticEyeDistanceFactor() const | ViewState | [inline]
getStereoEyeDistance() const | ViewState | [inline]
getTargetDistance() const | ViewState | [inline]
getViewportHeight() const | ViewState | [inline]
getViewportWidth() const | ViewState | [inline]
isAnimating() const | ViewState | [inline]
isJitter() const | ViewState | [inline]
isStereo() const | ViewState | [inline]
isStereoAutomaticEyeDistanceAdjustment() const | ViewState | [inline]
isStereoReversedEyes() const | ViewState | [inline]
JCT_CROSS_PRODUCT enum value | ViewState |
JCT_HIGHER_PASS enum value | ViewState |
JCT_NONE enum value | ViewState |
JitterCombineTechnique enum name | ViewState |
setAnimating(bool animating) | ViewState | [inline]
setCamera(CameraHandle *camera) | ViewState | [inline]
setCullTree(const CullData *cullTree) | ViewState |
setDoFJitters(const std::vector< nvmath::Vec2f > &dofJitters) | ViewState |
setFSAAJitters(const std::vector< nvmath::Vec2f > &fsaaJitters) | ViewState |
setJittersCombineMethod(JitterCombineTechnique method) | ViewState | [inline]
setLODRangeScale(float factor) | ViewState | [inline]
setMapList(MapListHandle *ml) | ViewState | [inline]
setStereo(bool state) | ViewState | [inline]
setStereoAutomaticEyeDistanceAdjustment(bool state) | ViewState | [inline]
setStereoAutomaticEyeDistanceFactor(float factor) | ViewState | [inline]
setStereoEyeDistance(float distance) | ViewState | [inline]
setTargetDistance(float dist) | ViewState | [inline]
setViewportSize(unsigned int width, unsigned int height) | ViewState |
stereoReverseEyes() | ViewState | [inline]
toggleStereo() | ViewState | [inline]
ViewState() | ViewState |
ViewState(const ViewState &rhs) | ViewState |
~ViewState() | ViewState | [virtual]
Generated on Tue Jan 15 10:29:24 2008 for NVSGSDK by NVIDIA


VNVector Class Reference

A helper class for use in animation. More...

#include <VNVector.h>

List of all members.

Public Member Functions

bool | operator== (const VNVector &v) const
Equality operator.

bool | operator!= (const VNVector &v) const

Public Attributes

std::vector< nvmath::Vec3f > | normals
vector of normals

std::vector< nvmath::Vec3f > | vertices
vector of vertices

Detailed Description

A helper class for use in animation.

Namespace: nvsg
Remarks:
A VNVector holds a vector of vertices and normals. It is used to produce animations on vertices/normals.
See also:
AnimatedTriangles, AnimatedQuads

Member Function Documentation

bool operator== ( const VNVector & v ) const [inline]

Equality operator.

Returns:
true if the all vertices and normals of the this are equal to the corresponding vertices and normals of v, otherwise false

Member Data Documentation

std::vector<nvmath::Vec3f> normals

vector of normals

std::vector<nvmath::Vec3f> vertices

vector of vertices

The documentation for this class was generated from the following file:
  • VNVector.h
Generated on Tue Jan 15 10:29:24 2008 for NVSGSDK by NVIDIA


Member List

VNVector Member List

This is the complete list of members for VNVector, including all inherited members.
normals | VNVector |
operator!=(const VNVector &v) const (defined in VNVector) | VNVector | [inline]
operator==(const VNVector &v) const | VNVector | [inline]
vertices | VNVector |
Generated on Tue Jan 15 10:29:24 2008 for NVSGSDK by NVIDIA


VolLoader Class Reference

A Texture Loader for Volume datasets of type *.dat.raw. More...

#include <VolLoader.h>

Inheritance diagram for VolLoader:

[legend]
Collaboration diagram for VolLoader:

[legend]
List of all members.

Public Member Functions

VolLoader ()
Default constructor.

FileInfo | getFileInfo () const
Get the FileInfo of the last file loaded.

void | deleteThis ()
Realization of the pure virtual interface function of a PlugIn.

Protected Member Functions

virtual | ~VolLoader ()
Protected virtual destructor.

bool | onLoad (const std::string &filename, nvsg::TextureImage *texImg, const std::vector< std::string > &searchPaths)
Pure virtual interface called on loading a TextureImage file.

nvsg::TextureImageHandle * createTextureImageHandle ()
Virtual function to create a TextureImageHandle.

Friends

bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

Detailed Description

A Texture Loader for Volume datasets of type *.dat.raw.

/*

Constructor & Destructor Documentation

VolLoader ( )

Default constructor.

virtual ~VolLoader ( ) [protected, virtual]

Protected virtual destructor.

Member Function Documentation

VolLoader::FileInfo getFileInfo ( ) const [inline]

Get the FileInfo of the last file loaded.

Returns:
The FileInfo of the last file loaded.
See also:
FileInfo

void deleteThis ( ) [virtual]

Realization of the pure virtual interface function of a PlugIn.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

bool onLoad | ( | const std::string & | filename,
 |  | nvsg::TextureImage * | texImg,
 |  | const std::vector< std::string > & | searchPaths
 | ) | [protected, virtual]

Pure virtual interface called on loading a TextureImage file.

Parameters:
filename | The name of the texture file to load.
texImg | A pointer to the TextureImage to load the data into.
searchPaths | A set of search paths used for files referenced within the texture file.
Returns:
true, if the TextureImage was successfully loaded, otherwise false.
Remarks:
Loads a TextureImage from the file specified by filename. The PlugIn must create the image(s) in the OpenGL compatible orientation, that has its image origin in the lower left. TextureImage offers mirrorX() and mirrorY() routines that a Loader PlugIn can use to achieve this orientation.
See also:
load, reload

Implements TextureLoader.

nvsg::TextureImageHandle* createTextureImageHandle ( ) [protected, virtual]

Virtual function to create a TextureImageHandle.

Returns:
A pointer to a created TextureImageHandle.
Remarks:
This function is called in load. The default implementation just creates a TextureImageHandle. A class derived from TextureLoader can decide to overwrite this function to create an object that is derived from TextureImageHandle.
See also:
VolLoader

Reimplemented from TextureLoader.

Friends And Related Function Documentation

bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) | [friend]

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a OBJSAVER. If the PlugIn ID piid equals PIID_NVSG_SCENE_SAVER, a OBJSAVER is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

The documentation for this class was generated from the following file:
  • VolLoader.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

VolLoader Member List

This is the complete list of members for VolLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
createTextureImageHandle() | VolLoader | [protected, virtual]
deleteThis() | VolLoader | [virtual]
getFileInfo() const | VolLoader | [inline]
getPlugInterface(const nvutil::UPIID &piid, nvutil::PlugIn *&pi) | VolLoader | [friend]
load(const std::string &filename, const std::vector< std::string > &searchPaths=std::vector< std::string >(), const unsigned int &creationFlags=0) | TextureLoader |
onLoad(const std::string &filename, nvsg::TextureImage *texImg, const std::vector< std::string > &searchPaths) | VolLoader | [protected, virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
reload(TextureImageHandle *tih, const std::vector< std::string > &searchPaths=std::vector< std::string >()) | TextureLoader |
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
VolLoader() | VolLoader |
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~TextureLoader() | TextureLoader | [protected, virtual]
~VolLoader() | VolLoader | [protected, virtual]
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


VolLoader::FileInfo Struct Reference

Helper structure to hold information for a VolumeTexture file. More...

#include <VolLoader.h>

Collaboration diagram for VolLoader::FileInfo:

[legend]
List of all members.

Public Attributes

std::string | m_filename
The name of the VolumeTexture file.

int | m_overlapSize
Number of overlapping voxels.

int | resolution [3]
Resolution of the VolumeTexture file.

nvmath::Vec3f m_sliceThickness
Thicknesses of the cuboids.

nvsg::Image::PixelDataType m_type
Type of the pixel data.

nvsg::Image::PixelFormat m_format
Format of the pixel data.

Detailed Description

Helper structure to hold information for a VolumeTexture file.

See also:
getFileInfo

Member Data Documentation

std::string m_filename

The name of the VolumeTexture file.

int m_overlapSize

Number of overlapping voxels.

int resolution[3]

Resolution of the VolumeTexture file.

nvmath::Vec3f m_sliceThickness

Thicknesses of the cuboids.

nvsg::Image::PixelDataType m_type

Type of the pixel data.

nvsg::Image::PixelFormat m_format

Format of the pixel data.

The documentation for this struct was generated from the following file:
  • VolLoader.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

VolLoader::FileInfo Member List

This is the complete list of members for VolLoader::FileInfo, including all inherited members.
m_filename | VolLoader::FileInfo
m_format | VolLoader::FileInfo
m_overlapSize | VolLoader::FileInfo
m_sliceThickness | VolLoader::FileInfo
m_type | VolLoader::FileInfo
resolution | VolLoader::FileInfo
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


VolSaver Class Reference

TextureSaver plug-in for saving volume textures in the .raw/.dat format. More...

#include <VolSaver.h>

Inheritance diagram for VolSaver:

[legend]
Collaboration diagram for VolSaver:

[legend]
List of all members.

Public Member Functions

VolSaver ()
Default constructor.

void | deleteThis ()
Realization of the pure virtual interface function of a PlugIn.

bool | save (nvsg::TextureImageHandle *image, const std::string &fileName)
Save a volume texture in .raw/.dat format.

Protected Member Functions

virtual | ~VolSaver ()
Protected virtual destructor.

Friends

bool | getPlugInterface (const nvutil::UPIID &piid, nvutil::PlugIn *&pi)
Get the PlugIn interface for this scene loader.

Detailed Description

TextureSaver plug-in for saving volume textures in the .raw/.dat format.

Remarks:
This file format is used for our volume rendering system.
See also:
VolLoader

Constructor & Destructor Documentation

VolSaver ( )

Default constructor.

virtual ~VolSaver ( ) [protected, virtual]

Protected virtual destructor.

Member Function Documentation

void deleteThis ( ) [inline, virtual]

Realization of the pure virtual interface function of a PlugIn.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

bool save | ( | nvsg::TextureImageHandle * | image,
 |  | const std::string & | fileName
 | ) | [virtual]

Save a volume texture in .raw/.dat format.

Parameters:
image | A pointer to the VolumeTextureHandle to save.
fileName | The name of the file to save to.
Returns:
true, if the saving operation was completed successfully.
Remarks:
Although the interface of this function needs a TextureImageHandle, it has to be a VolumeTextureHandle. Otherwise the behavior is undefined.

Implements TextureSaver.

Friends And Related Function Documentation

bool getPlugInterface | ( | const nvutil::UPIID & | piid,
 |  | nvutil::PlugIn *& | pi
 | ) | [friend]

Get the PlugIn interface for this scene loader.

Every PlugIn has to resolve this function. It is used to get a pointer to a PlugIn class, in this case a OBJSAVER. If the PlugIn ID piid equals PIID_NVSG_SCENE_SAVER, a OBJSAVER is created and returned in pi.

Returns:
true, if the requested PlugIn could be created, otherwise false
Parameters:
piid | PlugIn ID to create an Interface for
pi | reference to a PlugIn pointer

The documentation for this class was generated from the following file:
  • VolSaver.h
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


Member List

VolSaver Member List

This is the complete list of members for VolSaver, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis() | VolSaver | [inline, virtual]
getPlugInterface(const nvutil::UPIID &piid, nvutil::PlugIn *&pi) | VolSaver | [friend]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(nvsg::TextureImageHandle *image, const std::string &fileName) | VolSaver | [virtual]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
VolSaver() | VolSaver |
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~TextureSaver() | TextureSaver | [protected, virtual]
~VolSaver() | VolSaver | [protected, virtual]
Generated on Tue Jan 15 10:28:46 2008 for NVSGSDK by NVIDIA


VolumeBrick Class Reference

Class to represent one brick of a volume. More...

#include <VolumeBrick.h>

Collaboration diagram for VolumeBrick:

[legend]
List of all members.

Public Member Functions

NVSG_API | VolumeBrick ()
Default constructor of a VolumeBrick.

virtual NVSG_API | ~VolumeBrick ()
Destructor of a VolumeBrick.

NVSG_API QuadsHandle * | getBrickBox () const
Get the geometric representation of this VolumeBrick.

NVSG_API TextureImageHandle * | getBrickData () const
Get the TextureImage representing the volume data inside that VolumeBrick.

NVSG_API TriFansHandle * | getFrontPlane () const
Get the geometric representation of the front plane.

NVSG_API StateVariantHandle * | getStateVariant () const
Get the visual appearance of the VolumeBrick.

NVSG_API bool | isLeaf () const
Determine if this VolumeBrick contains further sub bricks.

NVSG_API VolumeBrickHandle * | operator[] (unsigned int index) const
Get one sub brick of this VolumeBrick.

NVSG_API void | setData (const std::string &brickName, const nvmath::Vec3f &volumeSize, const nvmath::Vec3f &brickPosition, const nvmath::Vec3f &brickSize)
Set all the data of the VolumeBrick.

NVSG_API void | setFrontClipPlane (const nvmath::Plane3f &plane)
Set the front clip plane.

NVSG_API void | setMasterShader (CgFxHandle *shader)
Set the master shader for this VolumeBrick.

Detailed Description

Class to represent one brick of a volume.

Namespace: nvsg
Remarks:
A VolumeBrick is part of a VolumeNode. Each VolumeNode holds one single VolumeBrick, that represents the complete volume in the lowest available resolution. Each VolumeBrick in turn can hold up to eight sub bricks, each one again a VolumeBrick. Each of those VolumeBricks holds one octel of the surrounding VolumeBrick, now in a resolution twice as high. If the VolumeBrick holds no sub bricks, it represents that part of the complete volume in the highest available resolution. If the VolumeBrick holds only some sub bricks, the sub bricks not hold are plain empty space in the complete volume.
See also:
VolumeNode

Constructor & Destructor Documentation

NVSG_API VolumeBrick ( )

Default constructor of a VolumeBrick.

virtual NVSG_API ~VolumeBrick ( ) [virtual]

Destructor of a VolumeBrick.

Member Function Documentation

QuadsHandle * getBrickBox ( ) const [inline]

Get the geometric representation of this VolumeBrick.

Returns:
A pointer to the QuadsHandle describing a box containing the volume dataset.
Remarks:
The geometric representation of a VolumeBrick is a box. It's position and size is completely determines by the represented volume texture.
See also:
getFrontPlane

NVSG_API TextureImageHandle* getBrickData ( ) const

Get the TextureImage representing the volume data inside that VolumeBrick.

Returns:
A pointer to the TextureImageHandle holding the volume data.
Remarks:
Each VolumeBrick holds a TextureImage representing the volume data. That TextureImage is either a down-sampled version of that part of the complete volume that is represented by that VolumeBrick. In that case, the VolumeBrick does have at least one sub brick. Or that TextureImage is just that part of the complete volume with the exact same resolution as the complete volume, that is represented by that VolumeBrick. In that case, it is a "leaf" in the octree of VolumeBricks and holds no more sub bricks.

TriFansHandle * getFrontPlane ( ) const [inline]

Get the geometric representation of the front plane.

Returns:
A pointer to a TriFansHandle if the front clip plane cuts the brick box, or NULL.
Remarks:
When the front clipping plane of the view frustum clips the brick box, no fragments would be generated in that area. Therefore, a geometric representation of that area is created as a TriFans, slightly inside the view frustum. That TriFans can be used to create fragments inside of the VolumeBrick. If this function returns NULL, there is no front plane, because the front clip plane does not intersect the brick box.
See also:
getBrickBox, setFrontClipPlane

NVSG_API StateVariantHandle* getStateVariant ( ) const

Get the visual appearance of the VolumeBrick.

Returns:
A pointer to a StateVariantHandle, describing the visual appearance of the brick.
Remarks:
Each VolumeBrick holds a StateVariant that in turn holds a CgFx, that describes the volume and the rendering of this brick.

bool isLeaf ( ) const [inline]

Determine if this VolumeBrick contains further sub bricks.

Returns:
false, if this VolumeBrick contains further sub bricks, otherwise true.
Remarks:
A VolumeBrick is called a "leaf", if it does not hold any sub bricks, i.e. the volume texture it holds is in the highest resolution available for that part of the volume.

VolumeBrickHandle * operator[] ( unsigned int index ) const [inline]

Get one sub brick of this VolumeBrick.

Parameters:
index The index of the sub brick to get.
Returns:
A pointer to the VolumeBrick representing the sub volume determined by index, or NULL, if there is none.
Remarks:
The brickIndex is between 0 and 7, where 0 is the lower left back, and 7 is the upper right front. The tree bits used in brickIndex determine the sub brick to be lower or upper (bit 0), right or left (bit 1), and back and front (bit 2).
Note:
The behavior is undefined if index is larger than seven.
See also:
getSubBrickPosition

NVSG_API void setData | ( | const std::string & | brickName,
 |  | const nvmath::Vec3f & | volumeSize,
 |  | const nvmath::Vec3f & | brickPosition,
 |  | const nvmath::Vec3f & | brickSize
 | ) |

Set all the data of the VolumeBrick.

Parameters:
brickName | The name of the texture file containing the volume data for this brick.
volumeSize | The size of the complete volume texture.
brickPosition | The position of this brick in the complete volume.
brickSize | The size of the brick.
Remarks:
The brickName is used to create the file names of the sub bricks by appending an index between 0 and 7 for each possible sub brick. If a file with that name exists, it is used to create and set the corresponding sub brick.

NVSG_API void setFrontClipPlane ( const nvmath::Plane3f & plane )

Set the front clip plane.

Parameters:
plane The definition of a plane, representing the front clip plane.
Remarks:
If the geometric representation of this VolumeBrick intersects the clip plane plane, a TriFans representing that intersection is created, and the clip plane of each sub brick is determined recursively. If otherwise plane does not intersect the geometric representation of this VolumeBrick, any previously determined clip plane representation is removed, and recursively in each sub brick.
See also:
getFrontPlane

NVSG_API void setMasterShader ( CgFxHandle * shader )

Set the master shader for this VolumeBrick.

Parameters:
shader A pointer to the master shader to use.
Remarks:
A VolumeNode holds a CgFx that defines the visual appearance of the volume. That shader is used as the master shader for the active VolumeBricks. Each VolumeBrick creates a clone out of the master shader, and adjusts some parameters, as size, position, and texture file. The shader of the VolumeNode is called "master shader" here, because every change in that shader is automatically carried into the clones held by the VolumeBricks.

The documentation for this class was generated from the following file:
  • VolumeBrick.h
Generated on Tue Jan 15 10:29:24 2008 for NVSGSDK by NVIDIA


Member List

VolumeBrick Member List

This is the complete list of members for VolumeBrick, including all inherited members.
getBrickBox() const | VolumeBrick | [inline]
getBrickData() const | VolumeBrick |
getFrontPlane() const | VolumeBrick | [inline]
getStateVariant() const | VolumeBrick |
isLeaf() const | VolumeBrick | [inline]
operator[](unsigned int index) const | VolumeBrick | [inline]
setData(const std::string &brickName, const nvmath::Vec3f &volumeSize, const nvmath::Vec3f &brickPosition, const nvmath::Vec3f &brickSize) | VolumeBrick |
setFrontClipPlane(const nvmath::Plane3f &plane) | VolumeBrick |
setMasterShader(CgFxHandle *shader) | VolumeBrick |
VolumeBrick() | VolumeBrick |
~VolumeBrick() | VolumeBrick | [virtual]
Generated on Tue Jan 15 10:29:24 2008 for NVSGSDK by NVIDIA


VolumeNode Class Reference

Class to hold a volume. More...

#include <VolumeNode.h>

Inheritance diagram for VolumeNode:

[legend]
Collaboration diagram for VolumeNode:

[legend]
List of all members.

Public Member Functions

NVSG_API | VolumeNode ()
Default constructor of a VolumeNode.

NVSG_API | VolumeNode (const Node &rhs)
Partial copy constructor of a VolumeNode.

NVSG_API | VolumeNode (const VolumeNode &rhs)
Copy constructor of a VolumeNode.

virtual NVSG_API | ~VolumeNode ()
Destructor of a VolumeNode.

NVSG_API void | determineActiveBricks (nvsg::CameraHandle *cameraHandle, const nvmath::Mat44f &modelToView, float maxScalingFactor)
Create the active list of VolumeBricks for subsequent operations.

NVSG_API const std::set< nvsg::VolumeBrickHandle * > & | getActiveBricks () const
Get the currently active list of VolumeBricks.

NVSG_API CgFxHandle * | getShader () const
Get the shader that does the volume rendering.

NVSG_API void | setShader (CgFxHandle *shader)
Set the shader that does the volume rendering.

NVSG_API void | effectChanged (void) const
Inform the VolumeNode that the underlying effect of the shader was modified.

NVSG_API const std::string & | getVolumeTextureName () const
Get the name of the volume texture data set.

NVSG_API const std::string & | getTopBrickTextureName () const
Get the name of the top level brick texture data set.

NVSG_API void | setFileNames (const std::string &volumeTextureName, const std::string &topBrickTextureName, const std::vector< std::string > &searchPaths)
Set the names of the volume data set and the top level brick data set.

NVSG_API VolumeBrickHandle * | getTopLevelBrick () const
Get the handle to the top level brick.

NVSG_API const unsigned int * | getVolumeTextureSize () const
Get the size of the volume data.

NVSG_API const unsigned int * | getBrickTextureSize () const
Get the size of a brick data set.

NVSG_API const nvmath::Vec3f & | getBricksOverallSize () const
Get the overall size of the bricks.

NVSG_API const nvmath::Plane3f & | getFrontClipPlane () const
Get a TriFansHandle representing the front clipping plane of the VolumeNode.

NVSG_API void | setFrontClipPlane (const nvmath::Plane3f &plane)
Create a TriFansHandle representing the clip plane.

NVSG_API float | getVoxelLimitFraction () const
Get the voxel limit fraction.

NVSG_API void | setVoxelLimitFraction (float vlf)
Set the voxel limit fraction.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other VolumeNode.

NVSG_API VolumeNode & | operator= (const VolumeNode &rhs)
Assignment operator.

virtual NVSG_API bool | validateIncarnation () const
Validate the nvutil::Incarnation.

Protected Member Functions

virtual NVSG_API nvmath::Box3f | calculateBoundingBox () const
Interface to calculate the bounding sphere of this VolumeNode.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this VolumeNode.

virtual NVSG_API bool | determineTransparencyContainment () const
Determine the transparency containment state.

virtual NVSG_API bool | determineCgFxContainment () const
Overrides Node::determineCgFxContainment.

virtual NVSG_API bool | determineVolumeNodeContainment () const
Overrides Node::determineVolumeNodeContainment.

virtual NVSG_API bool | isActive (const nvsg::VolumeBrick *vb, const nvmath::Sphere3f &bs, const nvsg::Camera *camera)
Determine if a VolumeBrick is active.

Detailed Description

Class to hold a volume.

Namespace: nvsg
Remarks:
A VolumeNode in a scene graph is always a leaf node. It holds the data for one volume and the associated CgFx shader that does the rendering.
See also:
CgFx

Constructor & Destructor Documentation

NVSG_API VolumeNode ( )

Default constructor of a VolumeNode.

NVSG_API VolumeNode ( const Node & rhs ) [explicit]

Partial copy constructor of a VolumeNode.

Parameters:
rhs Node to construct the VolumeNode from.
Remarks:
This is kind of a partial copy constructor only copying the Node part from the source object.

NVSG_API VolumeNode ( const VolumeNode & rhs )

Copy constructor of a VolumeNode.

virtual NVSG_API ~VolumeNode ( ) [virtual]

Destructor of a VolumeNode.

Member Function Documentation

NVSG_API void determineActiveBricks | ( | nvsg::CameraHandle * | cameraHandle,
 |  | const nvmath::Mat44f & | modelToView,
 |  | float | maxScalingFactor
 | ) |

Create the active list of VolumeBricks for subsequent operations.

Parameters:
cameraHandle | A pointer to the Camera to use for selection.
modelToView | A reference to the constant model to view matrix.
maxScalingFactor | The maximal scaling factor used in the model to view matrix.
Remarks:
This function selects some VolumeBricks as active for subsequent operations. A VolumeBrick is considered to be active, if it is a leaf (i.e. does not consist of subbricks), or isActive returns true.
Example: The AppTraverser determines the active bricks as follows:
    p->determineActiveBricks( m_lockedViewState->getCamera()
                            , m_transformStack.getModelToView()
                            , maxElement( m_currentScaling.top() ) );
See also:
getActiveBricks, isActive

const std::set< nvsg::VolumeBrickHandle * > & getActiveBricks ( ) const [inline]

Get the currently active list of VolumeBricks.

Returns:
A reference to the constant list of currently active VolumeBricks.
Remarks:
The active list of VolumeBricks is created by a call to determineActiveBricks.
Example:
    const set<VolumeBrickHandle*> & activeBricks = p->getActiveBricks();
    for ( set<VolumeBrickHandle*>::const_iterator it=activeBricks.begin(); it!=activeBricks.end(); ++it )
    {
      // ... work on *it
    }
See also:
determineActiveBricks

CgFxHandle * getShader ( ) const [inline]

Get the shader that does the volume rendering.

Returns:
A pointer to the CgFxHandle that does the volume rendering.
Remarks:
This sampler has to have a sampler with the texture parameter named "volume" in order to do the correct shading. On rendering, this sampler is fed with the TextureImageHandle representing the volume data to render. Note also that the user must call VolumeNode::effectChanged method, if the underlying effect is modified in any way. This includes tweakable updates change of sampler texture, change in technique, etc.
See also:
setShader, effectChanged

NVSG_API void setShader ( CgFxHandle * shader )

Set the shader that does the volume rendering.

Parameters:
shader A pointer to the CgFxHandle that has to do the volume rendering.
Remarks:
This sampler has to have a sampler with the texture parameter named "volume" in order to do the correct shading. On rendering, this sampler is fed with the TextureImageHandle representing the volume data to render.
See also:
getShader, setVolumeData

NVSG_API void effectChanged ( void ) const

Inform the VolumeNode that the underlying effect of the shader was modified.

Remarks:
The user must call VolumeNode::effectChanged method if the underlying effect is modified in any way. This includes tweakable updates change of sampler texture, change in technique, etc. The behavior is undefined if a this method is called if the shader is not set.
See also:
setShader, effectChanged

const std::string & getVolumeTextureName ( ) const [inline]

Get the name of the volume texture data set.

Returns:
A reference to the constant name of the volume texture data set.
See also:
getTopBrickTextureName, setFileNames

const std::string & getTopBrickTextureName ( ) const [inline]

Get the name of the top level brick texture data set.

Returns:
A reference to the constant name of the top level brick texture data set.
Remarks:
The top level brick texture data set is a texture data set representing the complete volume texture data set at a lower resolution. There should be other brick texture data sets at the same place representing the volume texture data set at better resolutions. If for example is the name of the top level brick texture data set, there can be eight files ..., each representing one octel of the complete texture data set, each one with the same resolution as . Next, there can be files ..., each representing one octel of , and so on for each of the octel texture data set files. The final level, then, holds the same texture data as the original volume texture data set, but divided in a number of brick files.
See also:
getVolumeTextureName, setFileNames

NVSG_API void setFileNames | ( | const std::string & | volumeTextureName,
 |  | const std::string & | topBrickTextureName,
 |  | const std::vector< std::string > & | searchPaths
 | ) |

Set the names of the volume data set and the top level brick data set.

Parameters:
volumeTextureName | The name of the volume texture data set.
topBrickTextureName | The name of the top level brick texture data set.
searchPaths | A vector of paths, where to search for the files
Remarks:
The top level brick texture data set is a texture data set representing the complete volume texture data set at a lower resolution. There should be other brick data sets at the same place representing the volume texture data set at better resolutions. If for example is the name of the top level brick texture data set, there can be eight files ..., each representing one octel of the complete data set, each one with the same resolution as . Next, there can be files ..., each representing one octel of , and so on for each of the octel texture data set files. The final level, then, holds the same texture data as the original volume texture data set, but divided into a number of brick texture files.
See also:
getVolumeTextureName, getTopBrickTextureName

VolumeBrickHandle * getTopLevelBrick ( ) const [inline]

Get the handle to the top level brick.

Returns:
A pointer to the top level VolumeBrick.
Remarks:
A VolumeNode holds an octree of VolumeBricks, that represent the volume data set in a bricked form.
See also:
getBrickTextureSize, getBricksOverallSize, getTopBrickTextureName, setFileNames

const unsigned int * getVolumeTextureSize ( ) const [inline]

Get the size of the volume data.

Returns:
The size of the volume data represented by a 3D texture.
Remarks:
The volume size is the size of the 3D texture with width in the first component of the returned array of integers, height in the second, and depth in the third.
See also:
getBrickTextureSize, getBricksOverallSize

NVSG_API const unsigned int* getBrickTextureSize ( ) const

Get the size of a brick data set.

Returns:
The size of a brick data set.
Remarks:
Each brick has the same size, and it is the number of voxels in the three directions.
See also:
getBricksOverallSize, getVolumeTextureSize

const nvmath::Vec3f & getBricksOverallSize ( ) const [inline]

Get the overall size of the bricks.

Returns:
The overall size of the bricks
Remarks:
The overall size of the bricks might be larger than the volume size, because the bricks might contain empty space to align their sizes to powers of two. The brick overall size is the size represented by the bricks.
See also:
getBrickTextureSize, getVolumeTextureSize

const nvmath::Plane3f & getFrontClipPlane ( ) const [inline]

Get a TriFansHandle representing the front clipping plane of the VolumeNode.

Returns:
A pointer to the TriFansHandle representing the front clipping plane of the VolumeNode, or NULL if there is none.
Remarks:
If there is a front clipping plane set for this VolumeNode, there is an internally created TriFansHandle returned.
See also:
setFrontClipPlane

NVSG_API void setFrontClipPlane ( const nvmath::Plane3f & plane )

Create a TriFansHandle representing the clip plane.

Parameters:
plane A nvmath::Plane3f that describes the clip plane.
Remarks:
If the nvmath::Plane3f plane intersects the box of this VolumeNode, a TriFansHandle representing the intersection is created. This TriFansHandle is used to generate fragments in front of the clip plane.
See also:
getFrontPlane

float getVoxelLimitFraction ( ) const [inline]

Get the voxel limit fraction.

Returns:
The voxel limit fraction.
Remarks:
The voxel limit fraction is the maximal fraction of the window a single voxel should span. This is used in determining if a VolumeBrick that has sub-bricks (i.e. is not a leaf in the octree of VolumeBricks) should be used for rendering, or if it's sub-bricks are to be tested for usage. If the approximated size of a voxel in the focus plane, divided by the smaller of the window size in x or y, is less than this voxel limit fraction, the VolumeBrick is used, otherwise, it's sub-bricks are tested for usage.
See also:
setVoxelLimitFraction, isActive

void setVoxelLimitFraction ( float vlf ) [inline]

Set the voxel limit fraction.

Parameters:
vlf The voxel limit fraction.
Remarks:
The voxel limit fraction is the maximal fraction of the window a single voxel should span. This is used in determining if a VolumeBrick that has sub-bricks (i.e. is not a leaf in the octree of VolumeBricks) should be used for rendering, or if it's sub-bricks are to be tested for usage. If the approximated size of a voxel in the focus plane, divided by the smaller of the window size in x or y, is less than this voxel limit fraction, the VolumeBrick is used, otherwise, it's sub-bricks are tested for usage.
See also:
getVoxelLimitFraction, isActive

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other VolumeNode.

Parameters:
p | A reference to the constant VolumeNode to test for equivalence with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
deepCompare | Optional parameter to perform a deep comparison; default is false.
Returns:
true if the VolumeNode p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Node, and they have the same number of StateSet objects with the same number of Drawable objects assigned, they are each tested for equivalence. If deepCompare is false, they are considered to be equivalent if they are the same pointers. Otherwise a full equivalence test is performed.
Note:
The behavior is undefined if p is not a VolumeNode nor derived from one.
See also:
Node

Reimplemented from Object.

NVSG_API VolumeNode& operator= ( const VolumeNode & rhs )

Assignment operator.

Parameters:
rhs A reference to the constant VolumeNode to copy from
Returns:
A reference to the assigned VolumeNode
Remarks:
The assignment operator calls the assignment operator of Node and copies from rhs.
See also:
Node

virtual NVSG_API bool validateIncarnation ( ) const [virtual]

Validate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this VolumeNode is requested but marked as invalid. Then it is validated and the nvutil::Incarnation of ... is requested to continue the validation down the tree hierarchy.
See also:
Node, nvutil::Incarnation, invalidateIncarnation

Reimplemented from Node.

virtual NVSG_API nvmath::Box3f calculateBoundingBox ( ) const [protected, virtual]

Interface to calculate the bounding sphere of this VolumeNode.

Returns:
The Function returns the axis-aligned bounding box of this VolumeNode.
Remarks:
This function is called by the framework to determine the actual bounding box of this VolumeNode.
See also:
getBoundingSphere, invalidateBoundingVolumes

Implements Node.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this VolumeNode.

Returns:
A nvmath::Sphere3f that contains the complete VolumeNode.
Remarks:
This function is called by the framework to determine a sphere that completely contains the VolumeNode.
See also:
getBoundingSphere, invalidateBoundingVolumes

Implements Node.

virtual NVSG_API bool determineTransparencyContainment ( ) const [protected, virtual]

Determine the transparency containment state.

Returns:
true, if this VolumeNode holds any transparent data, otherwise false.
Remarks:
This function is called by the framework to determine the transparency containment state of a Node when the transparency containment cache is marked as invalid.
See also:
Node, containsTransparentGeometry, isTransparent

Implements Node.

virtual NVSG_API bool determineCgFxContainment ( ) const [protected, virtual]

Overrides Node::determineCgFxContainment.

Returns:
The function returns true if a valid shader was assigned before, otherwise false.

Reimplemented from Node.

virtual NVSG_API bool determineVolumeNodeContainment ( ) const [protected, virtual]

Overrides Node::determineVolumeNodeContainment.

Returns:
The function always returns true.

Reimplemented from Node.

virtual NVSG_API bool isActive | ( | const nvsg::VolumeBrick * | vb,
 |  | const nvmath::Sphere3f & | bs,
 |  | const nvsg::Camera * | camera
 | ) | [protected, virtual]

Determine if a VolumeBrick is active.

Parameters:
vb | A pointer to the read-locked VolumeBrick that is tested for being active.
bs | A constant reference to the correctly transformed and resized bounding sphere of the VolumeBrick vb.
camera | A pointer to the read-locked Camera to use.
Returns:
true, if the VolumeBrick vb is active, otherwise false.
Remarks:
This function is called during determineActiveBricks for each VolumeBrick, that is not a leaf (has at least one sub-VolumeBrick). If true is returned, the VolumeBrick vb is considered to be active, and none of it's sub-VolumeBricks. Otherwise, all of it's sub-VolumeBricks are tested to be active.
See also:
determineActiveBricks

The documentation for this class was generated from the following file:
  • VolumeNode.h
Generated on Tue Jan 15 10:29:24 2008 for NVSGSDK by NVIDIA


Member List

VolumeNode Member List

This is the complete list of members for VolumeNode, including all inherited members.
addAsParentTo(NodeHandle *child) | Node | [protected]
addHints(unsigned short hints) | Node | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingBox() const | VolumeNode | [protected, virtual]
calculateBoundingSphere() const | VolumeNode | [protected, virtual]
containsAnimation() const | Node |
containsCgFx() const | Node |
containsHints(unsigned short hints) const | Node |
containsLight() const | Node |
containsLOD() const | Node |
containsTransparentGeometry() const | Node |
containsVolumeNode() const | Node |
determineActiveBricks(nvsg::CameraHandle *cameraHandle, const nvmath::Mat44f &modelToView, float maxScalingFactor) | VolumeNode |
determineAnimationContainment() const | Node | [protected, virtual]
determineCgFxContainment() const | VolumeNode | [protected, virtual]
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineLightContainment() const | Node | [protected, virtual]
determineLODContainment() const | Node | [protected, virtual]
determineTransparencyContainment() const | VolumeNode | [protected, virtual]
determineVolumeNodeContainment() const | VolumeNode | [protected, virtual]
effectChanged(void) const | VolumeNode |
enterCS() const | Object | [inline, protected]
getActiveBricks() const | VolumeNode | [inline]
getAnnotation() const | Object |
getBoundingBox() const | Node |
getBoundingSphere() const | Node |
getBricksOverallSize() const | VolumeNode | [inline]
getBrickTextureSize() const | VolumeNode |
getContainmentFlags() const | Node | [inline]
getContainmentValidFlags() const | Node | [inline]
getDataID() const | Object | [virtual]
getFrontClipPlane() const | VolumeNode | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getHintsContainment(unsigned short hints) const | Node |
getIncarnation() const | Object |
getName() const | Object |
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(unsigned int index) const | Node | [inline]
getShader() const | VolumeNode | [inline]
getTopBrickTextureName() const | VolumeNode | [inline]
getTopLevelBrick() const | VolumeNode | [inline]
getUserData() const | Object | [inline]
getVolumeTextureName() const | VolumeNode | [inline]
getVolumeTextureSize() const | VolumeNode | [inline]
getVoxelLimitFraction() const | VolumeNode | [inline]
invalidateAnimationContainment() | Node | [inline]
invalidateBoundingVolumes() | Node |
invalidateCgFxContainment() | Node | [inline]
invalidateContainment(unsigned int mask) | Node |
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [virtual]
invalidateLightContainment() | Node | [inline]
invalidateLODContainment() | Node | [inline]
invalidateTransparencyContainment() | Node | [inline]
invalidateVolumeNodeContainment() | Node | [inline]
isActive(const nvsg::VolumeBrick *vb, const nvmath::Sphere3f &bs, const nvsg::Camera *camera) | VolumeNode | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | VolumeNode | [virtual]
leaveCS() const (defined in Object) | Object | [inline, protected]
m_flags (defined in Node) | Node | [mutable, protected]
m_objectCode | Object | [protected]
NF_BOUNDING_BOX_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_SPHERE_VALID enum value (defined in Node) | Node | [protected]
NF_BOUNDING_VOLUMES_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION enum value (defined in Node) | Node | [protected]
NF_CONTAINS_ANIMATION_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX enum value (defined in Node) | Node | [protected]
NF_CONTAINS_CGFX_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LIGHT_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD enum value (defined in Node) | Node | [protected]
NF_CONTAINS_LOD_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY enum value (defined in Node) | Node | [protected]
NF_CONTAINS_TRANSPARENCY_VALID enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VALID_MASK enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE enum value (defined in Node) | Node | [protected]
NF_CONTAINS_VOLUME_NODE_VALID enum value (defined in Node) | Node | [protected]
NH_CULL_ALWAYS enum value | Node |
NH_CULL_MASK enum value | Node |
NH_CULL_NEVER enum value | Node |
NH_CUSTOM_BITS enum value | Node |
NH_MODIFY_FREQUENCY_HIGH enum value | Node |
NH_MODIFY_FREQUENCY_LOW enum value | Node |
NH_MODIFY_FREQUENCY_MASK enum value | Node |
NH_NO_SHADOW_CASTER enum value | Node |
NH_NO_SHADOW_RECEIVER enum value | Node |
NH_OVERLAY enum value | Node |
NH_RESERVED_BITS enum value | Node |
Node() | Node |
Node(const Node &rhs) | Node |
NodeHints enum name | Node |
Object() | Object |
Object(const Object &rhs) | Object |
operator=(const VolumeNode &rhs) | VolumeNode |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
removeAsParentFrom(NodeHandle *child) | Node | [protected]
removeHints(unsigned short hints) | Node | [inline]
setAnnotation(const std::string &anno) | Object |
setFileNames(const std::string &volumeTextureName, const std::string &topBrickTextureName, const std::vector< std::string > &searchPaths) | VolumeNode |
setFrontClipPlane(const nvmath::Plane3f &plane) | VolumeNode |
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setShader(CgFxHandle *shader) | VolumeNode |
setUserData(const void *userData) | Object | [inline]
setVoxelLimitFraction(float vlf) | VolumeNode | [inline]
validateIncarnation() const | VolumeNode | [virtual]
VolumeNode() | VolumeNode |
VolumeNode(const Node &rhs) | VolumeNode | [explicit]
VolumeNode(const VolumeNode &rhs) | VolumeNode |
~Node() | Node | [virtual]
~Object() | Object | [virtual]
~VolumeNode() | VolumeNode | [virtual]
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


VolumeTexture Class Reference

A class representing a VolumeTexture. More...

#include <VolumeTexture.h>

Inheritance diagram for VolumeTexture:

[legend]
Collaboration diagram for VolumeTexture:

[legend]
List of all members.

Public Member Functions

NVSG_API | VolumeTexture ()
Default constructor.

virtual NVSG_API | ~VolumeTexture ()
Virtual destructor of a VolumeTexture.

NVSG_API unsigned int | getOverlapSize () const
Get the size of the overlap in voxels.

NVSG_API nvmath::Vec3f | getSliceThickness () const
Get the slice thickness of this VolumeNode.

NVSG_API void | setOverlapSize (unsigned int overlap)
Set the size of the overlap in voxels.

NVSG_API void | setSliceThickness (const nvmath::Vec3f &thickness)
Set the slice thickness of this VolumeNode.

Detailed Description

A class representing a VolumeTexture.

Remarks:
A VolumeTexture is a TextureImage with some additional informations, like slice thickness.
See also:
TextureImage

Constructor & Destructor Documentation

NVSG_API VolumeTexture ( )

Default constructor.

Remarks:
After the TextureImage default constructor returned, the slice thickness is initialized to one, for each direction.

virtual NVSG_API ~VolumeTexture ( ) [virtual]

Virtual destructor of a VolumeTexture.

Member Function Documentation

unsigned int getOverlapSize ( ) const [inline]

Get the size of the overlap in voxels.

Returns:
The size of the overlap in voxels.
See also:
setOverlapSize

nvmath::Vec3f getSliceThickness ( ) const [inline]

Get the slice thickness of this VolumeNode.

Returns:
A Vec3f representing the slice thicknesses in the x-, y-, and z-direction.
Remarks:
Some volume textures have voxels that are not cubes, but cuboids. The slice thickness is used to scale them accordingly.
See also:
setSliceThickness

void setOverlapSize ( unsigned int overlap ) [inline]

Set the size of the overlap in voxels.

Parameters:
overlap The size of the overlap in voxels.
See also:
getOverlapSize

void setSliceThickness ( const nvmath::Vec3f & thickness ) [inline]

Set the slice thickness of this VolumeNode.

Parameters:
thickness A Vec3f representing the slice thicknesses in the x-, y-, and z-direction.
Remarks:
Some volume textures have voxels that are not cubes, but cuboids. The slice thickness is used to scale them accordingly.
See also:
getSliceThickness

The documentation for this class was generated from the following file:
  • VolumeTexture.h
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


Member List

VolumeTexture Member List

This is the complete list of members for VolumeTexture, including all inherited members.
addImage(unsigned int width, unsigned int height, unsigned int depth, Image::PixelFormat format, Image::PixelDataType type) | TextureImage |
convert2DToCubeMap() | TextureImage |
convertPixelFormat(Image::PixelFormat newFormat) | TextureImage |
createFromFile(const std::string &filename, const std::vector< std::string > &searchPaths, unsigned int creationFlags=0) | TextureImage | [static]
createImage(unsigned int width, unsigned int height, unsigned int depth, Image::PixelFormat format, Image::PixelDataType type, const void *pixels, const std::vector< const void * > &mipmaps=std::vector< const void * >()) | TextureImage |
createMipmaps() | TextureImage |
decrementMipmapUseCount() | TextureImage |
demandUpload() | TextureImage | [inline]
F_IMAGE_STREAM enum value | TextureImage |
F_NO_IMAGE_CREATION enum value | TextureImage |
F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD enum value | TextureImage |
F_SCALE_FILTER_BELL enum value | TextureImage |
F_SCALE_FILTER_BOX enum value | TextureImage |
F_SCALE_FILTER_BSPLINE enum value | TextureImage |
F_SCALE_FILTER_LANCZOS3 enum value | TextureImage |
F_SCALE_FILTER_MASK enum value (defined in TextureImage) | TextureImage |
F_SCALE_FILTER_TRIANGLE enum value | TextureImage |
F_SCALE_POT_ABOVE enum value | TextureImage |
F_SCALE_POT_BELOW enum value | TextureImage |
F_SCALE_POT_MASK enum value (defined in TextureImage) | TextureImage |
F_SCALE_POT_NEAREST enum value | TextureImage |
finishUpload() | TextureImage |
getBytesPerPixel(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getBytesPerPlane(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getBytesPerScanLine(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getCreationFlags() const | TextureImage | [inline]
getDepth(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getFileName() const | TextureImage | [inline]
getFormat(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getHeight(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getMipmapUseCount() const | TextureImage | [inline]
getNumberOfBytes(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getNumberOfImages() const | TextureImage | [inline]
getNumberOfMipmaps(unsigned int image=0) const | TextureImage | [inline]
getOverlapSize() const | VolumeTexture | [inline]
getPixels(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getSliceThickness() const | VolumeTexture | [inline]
getSubImagePixels(unsigned int image, unsigned int mipmap, unsigned int x_offset, unsigned int y_offset, unsigned int z_offset, unsigned int width, unsigned int height, unsigned int depth, void *subPixels) const | TextureImage |
getTextureGPUFormat(void) const | TextureImage | [inline]
getTotalNumberOfBytes() const | TextureImage | [inline]
getType(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
getUnpackAlignment() const | TextureImage | [inline]
getWidth(unsigned int image=0, unsigned int mipmap=0) const | TextureImage | [inline]
incrementMipmapUseCount() | TextureImage |
is1D() const | TextureImage | [inline]
is1DArray() const | TextureImage | [inline]
is2D() const | TextureImage | [inline]
is2DArray() const | TextureImage | [inline]
is3D() const | TextureImage | [inline]
isCompressed() const | TextureImage |
isCubeMap() const | TextureImage | [inline]
isFixedPoint() const | TextureImage |
isFloatingPoint() const | TextureImage |
isImageStream() const | TextureImage | [inline]
isUploadDemanded() const | TextureImage | [inline]
mirrorX(unsigned int image) | TextureImage |
mirrorY(unsigned int image) | TextureImage |
operator=(const TextureImage &rhs) | TextureImage |
releaseImagePixels() | TextureImage |
reloadImagePixels() | TextureImage |
scale(unsigned int image, unsigned int width, unsigned int height=1, unsigned int depth=1) | TextureImage |
scaleToPowerOfTwo(unsigned int sizeLimit) | TextureImage |
setCreationFlags(unsigned int flags) | TextureImage |
setImageData(unsigned int image, const void *pixels, const std::vector< const void * > &mipmaps=std::vector< const void * >()) | TextureImage |
setOverlapSize(unsigned int overlap) | VolumeTexture | [inline]
setSliceThickness(const nvmath::Vec3f &thickness) | VolumeTexture | [inline]
setSubImagePixels(unsigned int image, unsigned int mipmap, unsigned int x_offset, unsigned int y_offset, unsigned int z_offset, unsigned int width, unsigned int height, unsigned int depth, const void *subPixels) | TextureImage |
setTextureGPUFormat(TextureGPUFormat fmt) | TextureImage | [inline]
TextureGPUFormat enum name | TextureImage |
TextureImage() | TextureImage |
TextureImage(const TextureImage &) | TextureImage |
TGF_ALPHA16 enum value (defined in TextureImage) | TextureImage |
TGF_ALPHA8 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_FIXED enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_LUMINANCE enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_LUMINANCE_ALPHA enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_LUMINANCE_ALPHA_LATC enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_LUMINANCE_LATC enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RED_RGTC enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RG_RGTC enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGB enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGB_DXT1 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGB_DXT3 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGB_DXT5 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGBA enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_RGBA_DXT1 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGB enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGB_DXT1 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGB_DXT3 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGB_DXT5 enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGBA enum value (defined in TextureImage) | TextureImage |
TGF_COMPRESSED_SRGBA_DXT1 enum value (defined in TextureImage) | TextureImage |
TGF_DEFAULT enum value (defined in TextureImage) | TextureImage |
TGF_DEPTH16 enum value (defined in TextureImage) | TextureImage |
TGF_DEPTH24 enum value (defined in TextureImage) | TextureImage |
TGF_DEPTH24_STENCIL8 enum value (defined in TextureImage) | TextureImage |
TGF_DEPTH32 enum value (defined in TextureImage) | TextureImage |
TGF_FIXED enum value (defined in TextureImage) | TextureImage |
TGF_FIXED10 enum value (defined in TextureImage) | TextureImage |
TGF_FIXED16 enum value (defined in TextureImage) | TextureImage |
TGF_FIXED8 enum value (defined in TextureImage) | TextureImage |
TGF_FLOAT enum value (defined in TextureImage) | TextureImage |
TGF_FLOAT16 enum value (defined in TextureImage) | TextureImage |
TGF_FLOAT32 enum value (defined in TextureImage) | TextureImage |
TGF_INTEGER enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE16 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE16_ALPHA16 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE16F enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE32F enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE8 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE8_ALPHA8 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA16F enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA32F enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_ALPHA_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_LUMINANCE_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_NONLINEAR enum value (defined in TextureImage) | TextureImage |
TGF_RGB10 enum value (defined in TextureImage) | TextureImage |
TGF_RGB10_A2 enum value (defined in TextureImage) | TextureImage |
TGF_RGB16 enum value (defined in TextureImage) | TextureImage |
TGF_RGB16F enum value (defined in TextureImage) | TextureImage |
TGF_RGB32F enum value (defined in TextureImage) | TextureImage |
TGF_RGB8 enum value (defined in TextureImage) | TextureImage |
TGF_RGB_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_RGB_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_RGB_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA16 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA16F enum value (defined in TextureImage) | TextureImage |
TGF_RGBA32F enum value (defined in TextureImage) | TextureImage |
TGF_RGBA8 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_RGBA_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_ALPHA16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_ALPHA8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_COMPRESSED_LUMINANCE_ALPHA_LATC enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_COMPRESSED_LUMINANCE_LATC enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_COMPRESSED_RED_RGTC enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_COMPRESSED_RG_RGTC enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE16_ALPHA16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE8_ALPHA8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_ALPHA_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_ALPHA_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_ALPHA_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_LUMINANCE_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGB8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGB_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGB_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGB_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGBA8 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGBA_INTEGER16 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGBA_INTEGER32 enum value (defined in TextureImage) | TextureImage |
TGF_SIGNED_RGBA_INTEGER8 enum value (defined in TextureImage) | TextureImage |
TGF_SRGB enum value (defined in TextureImage) | TextureImage |
TGF_SRGBA enum value (defined in TextureImage) | TextureImage |
TGF_UNSIGNED_FLOAT_PACKED enum value (defined in TextureImage) | TextureImage |
TGF_UNSIGNED_FLOAT_SHARED_EXPONENT enum value (defined in TextureImage) | TextureImage |
VolumeTexture() | VolumeTexture |
~TextureImage() | TextureImage | [virtual]
~VolumeTexture() | VolumeTexture | [virtual]
Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


WalkCameraManipulator Class Reference

Simulate a walk-through camera-mouse interaction. More...

#include <WalkCameraManipulator.h>

Inheritance diagram for WalkCameraManipulator:

[legend]
Collaboration diagram for WalkCameraManipulator:

[legend]
List of all members.

Public Types

enum {
_NO_BTN_KEY = 0x0000, _LEFT_MOUSE_BTN = 0x0001, _MIDDLE_MOUSE_BTN = 0x0002, _CONTROL_KEY = 0x0004,
_W_KEY = 0x0008, _S_KEY = 0x0010
}
Keys for walking. More...

Public Member Functions

NVSG_API | WalkCameraManipulator (UINT screenSizeX=1280, UINT screenSizeY=1024)
Constructor .

NVSG_API | ~WalkCameraManipulator ()
Default destructor.

virtual NVSG_API bool | updateFrame ()
Apply changes for the next frame.

virtual NVSG_API bool | isActive ()
Give feedback of the activeness of the Manipulator.

virtual NVSG_API bool | isWalk ()
Test if the Manipulator is in walk mode.

virtual NVSG_API bool | isWalkForward ()
Test if the Manipulator is in walk forward mode.

virtual NVSG_API bool | isWalkBackward ()
Test if the Manipulator is in walk backward mode.

virtual NVSG_API bool | isTranslate ()
Test if the Manipulator is in translate mode.

virtual NVSG_API bool | isTilt ()
Test if the Manipulator is in tilt mode.

void | setWorldUpVector (nvmath::Vec3f up)
Define the up direction of the world.

const nvmath::Vec3f & | getWorldUpVector ()
Get the current up vector of the world.

void | setSpeedIncreaseFactor (float factor)
Define speed increase factor for walking.

float | getSpeedIncreaseFactor ()
Get the current speed increase factor for walking.

void | setHSensitivity (float sensitivity)
Define horizontal sensitivity of the mouse.

float | getHSensitivity ()
Get the horizontal sensitivity of the mouse.

void | setSpeed (float speed)
Set the walking speed.

float | getSpeed ()
Get the current walking speed.

void | setScreenSize (UINT x, UINT y)
Set the screen size.

NVSG_API void | reset ()
Reset the camera manipulator to the default values.

NVSG_API void | keyDown (UINT key)
Handle key press events.

NVSG_API void | keyUp (UINT key)
Handle key release events.

NVSG_API void | mouseButtonDown (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseButtonUp (UINT btn, int x, int y)
Handle mouse button press events.

NVSG_API void | mouseMotion (int x, int y)
Handle mouse motion.

NVSG_API void | setCameraHeightAboveTerrain (float offset)
Set the Height Above Terrain offset.

NVSG_API float | getCameraHeightAboveTerrain ()
Get the Height Above Terrain offset.

Protected Member Functions

bool | findTerrainPosition (nvmath::Vec3f &)
Used to find the terrain.

virtual bool | walk ()
Do the walk.

virtual bool | translate ()
Do the translate.

virtual bool | tilt ()
Do the tilt.

Protected Attributes

UINT | m_ScreenSizeX
Width of the screen in pixel.

UINT | m_ScreenSizeY
Height of the screen in pixel.

nvmath::Vec3f m_worldUpVector
Up-vector of the world. Default (0,1,0). This vector must not be (0,0,0).

float | m_speedIncreaseFactor
Factor that influences the stepping. Default: 2.f. This factor must not be 0!

float | m_hSensitivity
Factor that influences the horizontal rotation. Default: 1.f.

float | m_speed
Walk speed. Default: 1.f.

float | m_cameraHeightAboveTerrain
Camera's Height Above Terrain. Default: 2.f.

nvui::MouseInput m_mouseInput
Track mouse input.

nvui::KeyInput m_keyInput
Track keyboard input.

Static Protected Attributes

NVSG_API const UINT | WALKFORWARD
Key/button configuration for walking. (_LEFT_MOUSE_BTN).

NVSG_API const UINT | WALKBACKWARD
Key/button configuration for walking backward. (_MIDDLE_MOUSE_BTN).

NVSG_API const UINT | TRANSLATE
Key/button configuration for translating up, down, left and right. (_CONTROL_KEY | _MIDDLE_MOUSE_BTN).

NVSG_API const UINT | TILT
Key/button configuration for looking left, right, up and down. (_CONTROL_KEY | _LEFT_MOUSE_BTN).

NVSG_API const UINT | INCREASESPEED
Key/button configuration for increasing the walk speed. (_W_KEY).

NVSG_API const UINT | DECREASESPEED
Key/button configuration for decreasing the walk speed. (_S_KEY).

NVSG_API const UINT | AREAOFPEACE
Size of the area where the mouse does not trigger the manipulator. (40 pixels).

Detailed Description

Simulate a walk-through camera-mouse interaction.

Namespace: nvui
Remarks:
This manipulator is a special Manipulator that interprets/converts mouse movement into walk-through camera movements. The user can simulate walk forward, walk backward, increase speed, decrease speed, tilt and translate.

Keys & Buttons
Left mouse button : Walk forward.
Middle mouse button : Walk backward.
W-key : Increase speed.
S-key : Decrease speed.
Ctrl + Left mouse button : Tilt.
Ctrl + Middle mouse button : Translate.

When the Manipulator is in walk mode (forward or backward) you can determine the walk direction by moving the mouse to the left or right.
You can look into the sky or onto the floor by going into the tilt mode. Hold down the Ctrl key and the left mouse button at the same time and move the mouse forward to look into the sky, backward to look onto the floor, left to make a look to the left and right to make a look to the right.
To translate the viewing position to another location (e.g. elevate to another floor in a building) simply press the Ctrl key and the middle mouse button and move the mouse into the direction you want to move the camera.

The manipulator automatically connects the eyepoint to the model's surface. See the setCameraHeightAboveTerrain and getCameraHeightAboveTerrain functions for how to manipulate the camera height above the terrain. This simulates pushing a camera on a tripod through an environment that will always be this height above the actual terrain.
If you use this manipulator your application must use a mechanism, such as using OnIdle() that calls updateFrame(). If updateFrame() returns true you should call triggerRedraw of the render area so the updated frame will be drawn. You will find some code samples in the description of the Manipulator class. Also, the SimpleViewer tutorial source code shows how to use a manipulator with MFC, the ConsoleViewer tutorial source code shows the details on how to use a manipulator and the ManipSampleViewer tutorial source code shows how to derive a new Manipulator class.
The WalkCameraManipulator needs a kind of continuous redraw to work. See the sample code in the documentation on WalkCameraManipulator::updateFrame.
See also:
Manipulator

Member Enumeration Documentation

anonymous enum

Keys for walking.

Enumeration values:
_NO_BTN_KEY | No button or key pressed.
_LEFT_MOUSE_BTN | Left mouse button.
_MIDDLE_MOUSE_BTN | Middle mouse button.
_CONTROL_KEY | Control key.
_W_KEY | Speed up.
_S_KEY | Slow down.

Constructor & Destructor Documentation

NVSG_API WalkCameraManipulator | ( | UINT | screenSizeX = 1280,
 |  | UINT | screenSizeY = 1024
 | ) |

Constructor .

Parameters:
screenSizeX | Screen x-resolution in pixel - default is 1280 pixels. The value must be greater than 0.
screenSizeY | Screen y-resolution in pixel - default is 1024 pixels. The value must be greater than 0.
Remarks:
Initialize the WalkCameraManipulator object. The screen resolution is used for the input sensitivity of the manipulator. The default for the world up direction is (0.f, 1.f, 0.f) so by default you are walking in the x-z-plane and the ceiling/heaven is expected to be in the y-direction.

NVSG_API ~WalkCameraManipulator ( )

Default destructor.

Member Function Documentation

virtual NVSG_API bool updateFrame ( ) [virtual]

Apply changes for the next frame.

Returns:
If there is a change regarding the last frame this function returns true.
Remarks:
This function updates the nvsg::Camera. The application should call this function from, for example, your idle handler. If it returns with a positive result - true - the application should call RenderArea::triggerRedraw.
Example
This is a piece of code that demonstrates the usage with MFC. The AnimationManipulator needs a method to draw constantly. In MFC - OnIdle() it is enough to return TRUE. The application can also use a kind of animation thread to provide continuous redraw.
  m_pWalkManip->nextFrame();
  if (m_pWalkManip->updateFrame())
  {
    m_pRA->triggerRedraw();
  }
  return TRUE;  // Return TRUE, continues redraw - we are not done
                // we need to draw the next frame.
                // See the return values of OnIdle() in the MSDN documentation
See also the sample code in the Manipulator class description and the ManipSampleViewer, SimpleViewer and ConsoleViewer tutorial source code.
See also:
RenderArea::triggerRedraw

Implements Manipulator.

virtual NVSG_API bool isActive ( ) [virtual]

Give feedback of the activeness of the Manipulator.

Returns:
This function returns true when the Manipulator is in active mode.
Remarks:
The WalkCameraManipulator is active when he is internally in walk, translate or tilt mode.

Implements Manipulator.

virtual NVSG_API bool isWalk ( ) [virtual]

Test if the Manipulator is in walk mode.

Returns:
This function returns true when the manipulator is in walk forward or walk backward mode
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in walk mode.

Walk:
  • Left mouse button (walk forward)
  • Middle mouse button (walk backward)

virtual NVSG_API bool isWalkForward ( ) [virtual]

Test if the Manipulator is in walk forward mode.

Returns:
This function returns true when the manipulator is in walk forward mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in walk forward mode.

Walk forward: Left mouse button (walk forward)

virtual NVSG_API bool isWalkBackward ( ) [virtual]

Test if the Manipulator is in walk backward mode.

Returns:
This function returns true when the manipulator is in walk backward mode.
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in walk backward mode.

Walk backward: Middle mouse button (walk backward)

virtual NVSG_API bool isTranslate ( ) [virtual]

Test if the Manipulator is in translate mode.

Returns:
This function returns true when the manipulator is in translate mode
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in translate mode.

Translate:
Ctrl + Middle mouse button

virtual NVSG_API bool isTilt ( ) [virtual]

Test if the Manipulator is in tilt mode.

Returns:
This function returns true when the manipulator is in tilt mode
Remarks:
This function tests all the current key and button states to determine if this Manipulator is currently in tilt mode.

Tilt:
Ctrl + Left mouse button

void setWorldUpVector ( nvmath::Vec3f up ) [inline]

Define the up direction of the world.

Parameters:
up The vector that points into the up direction of the world. (0,0,0) is an invalid value.
Remarks:
This function sets the world's up direction. The default up direction is the (0,1,0)-direction, meaning the y-axis points to the 'sky' and you are walking in the x-z-plane. It is a right handed coordinate system.
See also:
getWorldUpVector

const nvmath::Vec3f & getWorldUpVector ( ) [inline]

Get the current up vector of the world.

Returns:
The current up vector of the world.
Remarks:
The world's up vector is the vector that points into direction of the 'sky'. It is a right handed coordinate system.
See also:
setWorldUpVector

void setSpeedIncreaseFactor ( float factor ) [inline]

Define speed increase factor for walking.

Parameters:
factor Speed increase factor - default is 2.f. This factor must not be 0.f!
Remarks:
The current speed will be multiplied or divided by this factor. So with the default increase factor of 2.f, the current walking speed will be doubled whenever the user accelerates the walking speed by, for example, pressing the W-key or halved when pressing the S-key.
See also:
getSpeedIncreaseFactor

float getSpeedIncreaseFactor ( ) [inline]

Get the current speed increase factor for walking.

Remarks:
The current speed will be multiplied or divided by this factor. So with the default increase factor of 2.f, the current walking speed will be doubled whenever the user accelerates the walking speed by, for example, pressing the W-key or halved when pressing the S-key.
See also:
setSpeedIncreaseFactor

void setHSensitivity ( float sensitivity ) [inline]

Define horizontal sensitivity of the mouse.

Parameters:
sensitivity Sensitivity factor - default is 1.f.
Remarks:
The horizontal sensitivity factor is used to control how sensitive the mouse reacts when you are in walk mode and move your mouse to the left or right. The larger the factor, the greater the sensitivity and the smaller the curve you can walk with a minimum of mouse movement.
See also:
getHSensitivity

float getHSensitivity ( ) [inline]

Get the horizontal sensitivity of the mouse.

Returns:
The current sensitivity of the mouse.
Remarks:
The horizontal sensitivity factor is used to control how sensitive the mouse reacts when you are in walk mode and move your mouse to the left or right. The larger the factor, the greater the sensitivity and the smaller the curve you can walk with a minimum of mouse movement.
See also:
setHSensitivity

void setSpeed ( float speed ) [inline]

Set the walking speed.

Parameters:
speed The walking speed - default is 1.f.
Remarks:
The application can set the walking speed via this function.
See also:
getSpeed

float getSpeed ( ) [inline]

Get the current walking speed.

Returns:
The current walking speed.
See also:
setSpeed

void setScreenSize | ( | UINT | x,
 |  | UINT | y
 | ) | [inline]

Set the screen size.

Parameters:
x | Screen x-resolution in pixel - default is 1280 pixels. The value must be grater than 0.
y | Screen y-resolution in pixel - default is 1024 pixels. The value must be grater than 0.
Remarks:
The application can set the screen resolution of the system. The resolution is used inside the WalkCameraManipulator to define the overall Manipulator sensitivity. Even with other screen resolutions the default value (1280x1024) works quite good.

NVSG_API void reset ( )

Reset the camera manipulator to the default values.

Remarks:
This function resets all the internal states to default (e.g. speed, speed increase factor, key and button states, etc...) The screen resolution and the mouse position will not be reseted.
This function does not reset the mouse position since the mouse position will be updated via the mouseMotion function all the time. If you reset the mouse position manually you will see undesirable camera jumps.

NVSG_API void keyDown ( UINT key )

Handle key press events.

Parameters:
key The key code of the pressed key. This Manipulator accepts only the _CONTROL_KEY, _W_KEY and _S_KEY. Other key codes will lead to undefined behavior.
Remarks:
This function routes the key codes to the KeyInput class so the manipulator can react on keyboard input.
See also:
keyUp, KeyInput::keyDown

NVSG_API void keyUp ( UINT key )

Handle key release events.

Parameters:
key The key code of the released key. This Manipulator accepts only the _CONTROL_KEY, _W_KEY and _S_KEY. Other key codes will lead to undefined behavior.
Remarks:
This function routes the key codes to the KeyInput class so the manipulator can react on keyboard input.
See also:
keyDown, KeyInput::keyUp

NVSG_API void mouseButtonDown | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code of the pressed button(s). This Manipulator accepts only the _LEFT_MOUSE_BTN and _MIDDLE_MOUSE_BTN. Other button codes will lead to undefined behavior.
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse button code and the current mouse cursor position to the MouseInput object to store the events. Call this function from your mouse button handler of your application.
See also:
mouseButtonUp, MouseInput::mouseButtonUp

NVSG_API void mouseButtonUp | ( | UINT | btn,
 |  | int | x,
 |  | int | y
 | ) |

Handle mouse button press events.

Parameters:
btn | The mouse button code of the released button(s). This Manipulator accepts only the _LEFT_MOUSE_BTN and _MIDDLE_MOUSE_BTN. Other button codes will lead to undefined behavior.
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse button code and the current mouse cursor position to the MouseInput object to store the events. Call this function from your mouse button handler of your application.
See also:
mouseButtonDown, MouseInput::mouseButtonDown

NVSG_API void mouseMotion | ( | int | x,
 |  | int | y
 | ) |

Handle mouse motion.

Parameters:
x | Current x-position of the mouse cursor in window coordinates.
y | Current y-position of the mouse cursor in window coordinates.
Remarks:
The Manipulator routes the mouse motion to the MouseInput object. Call this function from your mouse motion handler of your application.
See also:
MouseInput::mouseMotion

void setCameraHeightAboveTerrain ( float offset ) [inline]

Set the Height Above Terrain offset.

Parameters:
offset The distance, in the direction of the "UP" vector, to offset the viewpoint from the terrain surface. The default is 2 units.
See also:
getCameraHeightAboveTerrain

float getCameraHeightAboveTerrain ( ) [inline]

Get the Height Above Terrain offset.

Returns:
The distance, in the direction of the "UP" vector, to offset the viewpoint from the terrain surface.
See also:
setCameraHeightAboveTerrain

bool findTerrainPosition ( nvmath::Vec3f & ) [protected]

Used to find the terrain.

virtual bool walk ( ) [protected, virtual]

Do the walk.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the walk functionality.
See also:
mouseButtonUp, MouseInput::mouseButtonUp, keyDown, KeyInput::keyUp

virtual bool translate ( ) [protected, virtual]

Do the translate.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the translate functionality.
See also:
mouseButtonUp, MouseInput::mouseButtonUp, keyDown, KeyInput::keyUp

virtual bool tilt ( ) [protected, virtual]

Do the tilt.

Returns:
This function returns true when a redraw is needed.
Remarks:
Implementation of the tilt functionality.
See also:
mouseButtonUp, MouseInput::mouseButtonUp, keyDown, KeyInput::keyUp

Member Data Documentation

NVSG_API const UINT WALKFORWARD [static, protected]

Key/button configuration for walking. (_LEFT_MOUSE_BTN).

NVSG_API const UINT WALKBACKWARD [static, protected]

Key/button configuration for walking backward. (_MIDDLE_MOUSE_BTN).

NVSG_API const UINT TRANSLATE [static, protected]

Key/button configuration for translating up, down, left and right. (_CONTROL_KEY | _MIDDLE_MOUSE_BTN).

NVSG_API const UINT TILT [static, protected]

Key/button configuration for looking left, right, up and down. (_CONTROL_KEY | _LEFT_MOUSE_BTN).

NVSG_API const UINT INCREASESPEED [static, protected]

Key/button configuration for increasing the walk speed. (_W_KEY).

NVSG_API const UINT DECREASESPEED [static, protected]

Key/button configuration for decreasing the walk speed. (_S_KEY).

NVSG_API const UINT AREAOFPEACE [static, protected]

Size of the area where the mouse does not trigger the manipulator. (40 pixels).

UINT m_ScreenSizeX [protected]

Width of the screen in pixel.

UINT m_ScreenSizeY [protected]

Height of the screen in pixel.

nvmath::Vec3f m_worldUpVector [protected]

Up-vector of the world. Default (0,1,0). This vector must not be (0,0,0).

float m_speedIncreaseFactor [protected]

Factor that influences the stepping. Default: 2.f. This factor must not be 0!

float m_hSensitivity [protected]

Factor that influences the horizontal rotation. Default: 1.f.

float m_speed [protected]

Walk speed. Default: 1.f.

float m_cameraHeightAboveTerrain [protected]

Camera's Height Above Terrain. Default: 2.f.

nvui::MouseInput m_mouseInput [protected]

Track mouse input.

nvui::KeyInput m_keyInput [protected]

Track keyboard input.

The documentation for this class was generated from the following file:
  • WalkCameraManipulator.h
Generated on Tue Jan 15 10:29:44 2008 for NVSGSDK by NVIDIA


Member List

WalkCameraManipulator Member List

This is the complete list of members for WalkCameraManipulator, including all inherited members.
_CONTROL_KEY enum value | WalkCameraManipulator |
_LEFT_MOUSE_BTN enum value | WalkCameraManipulator |
_MIDDLE_MOUSE_BTN enum value | WalkCameraManipulator |
_NO_BTN_KEY enum value | WalkCameraManipulator |
_S_KEY enum value | WalkCameraManipulator |
_W_KEY enum value | WalkCameraManipulator |
AREAOFPEACE | WalkCameraManipulator | [protected, static]
DECREASESPEED | WalkCameraManipulator | [protected, static]
findTerrainPosition(nvmath::Vec3f &) | WalkCameraManipulator | [protected]
getCameraHeightAboveTerrain() | WalkCameraManipulator | [inline]
getHSensitivity() | WalkCameraManipulator | [inline]
getSpeed() | WalkCameraManipulator | [inline]
getSpeedIncreaseFactor() | WalkCameraManipulator | [inline]
getWorldUpVector() | WalkCameraManipulator | [inline]
INCREASESPEED | WalkCameraManipulator | [protected, static]
isActive() | WalkCameraManipulator | [virtual]
isTilt() | WalkCameraManipulator | [virtual]
isTranslate() | WalkCameraManipulator | [virtual]
isWalk() | WalkCameraManipulator | [virtual]
isWalkBackward() | WalkCameraManipulator | [virtual]
isWalkForward() | WalkCameraManipulator | [virtual]
keyDown(UINT key) | WalkCameraManipulator |
keyUp(UINT key) | WalkCameraManipulator |
m_cameraHeightAboveTerrain | WalkCameraManipulator | [protected]
m_hSensitivity | WalkCameraManipulator | [protected]
m_keyInput | WalkCameraManipulator | [protected]
m_mouseInput | WalkCameraManipulator | [protected]
m_renderArea | Manipulator | [protected]
m_ScreenSizeX | WalkCameraManipulator | [protected]
m_ScreenSizeY | WalkCameraManipulator | [protected]
m_speed | WalkCameraManipulator | [protected]
m_speedIncreaseFactor | WalkCameraManipulator | [protected]
m_worldUpVector | WalkCameraManipulator | [protected]
Manipulator() | Manipulator |
mouseButtonDown(UINT btn, int x, int y) | WalkCameraManipulator |
mouseButtonUp(UINT btn, int x, int y) | WalkCameraManipulator |
mouseMotion(int x, int y) | WalkCameraManipulator |
reset() | WalkCameraManipulator |
setCameraHeightAboveTerrain(float offset) | WalkCameraManipulator | [inline]
setHSensitivity(float sensitivity) | WalkCameraManipulator | [inline]
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
setScreenSize(UINT x, UINT y) | WalkCameraManipulator | [inline]
setSpeed(float speed) | WalkCameraManipulator | [inline]
setSpeedIncreaseFactor(float factor) | WalkCameraManipulator | [inline]
setWorldUpVector(nvmath::Vec3f up) | WalkCameraManipulator | [inline]
TILT | WalkCameraManipulator | [protected, static]
tilt() | WalkCameraManipulator | [protected, virtual]
TRANSLATE | WalkCameraManipulator | [protected, static]
translate() | WalkCameraManipulator | [protected, virtual]
updateFrame() | WalkCameraManipulator | [virtual]
walk() | WalkCameraManipulator | [protected, virtual]
WALKBACKWARD | WalkCameraManipulator | [protected, static]
WalkCameraManipulator(UINT screenSizeX=1280, UINT screenSizeY=1024) | WalkCameraManipulator |
WALKFORWARD | WalkCameraManipulator | [protected, static]
~Manipulator() | Manipulator | [virtual]
~WalkCameraManipulator() | WalkCameraManipulator |
Generated on Tue Jan 15 10:29:44 2008 for NVSGSDK by NVIDIA


WriteMapping Class Reference

Helper class to ease efficient writing of large files. More...

#include <FileMapping.h>

Inheritance diagram for WriteMapping:

[legend]
Collaboration diagram for WriteMapping:

[legend]
List of all members.

Public Member Functions

NVSG_API | WriteMapping (const std::string &fileName, size_t fileSize)
Constructor using the name of the file to write.

NVSG_API | ~WriteMapping ()
Destructor of a writable mapping.

NVSG_API void * | mapIn (size_t offset, size_t numBytes)
Map a view of the file.

Detailed Description

Helper class to ease efficient writing of large files.

See also:
FileMapping

Constructor & Destructor Documentation

NVSG_API WriteMapping | ( | const std::string & | fileName,
 |  | size_t | fileSize
 | ) |

Constructor using the name of the file to write.

Parameters:
fileName | The name of the file to write.
fileSize | The size of the file to write.
Remarks:
If there is enough free space on the disk specified by fileName, a file of that with the name fileName is created.
Example:
    WriteMapping wm = new WriteMapping( fileName, preCalculatedFileSize );
    if ( wm->isValid() )
    {...}

NVSG_API ~WriteMapping ( )

Destructor of a writable mapping.

Remarks:
If the WriteMapping is valid, the written file is closed.

Member Function Documentation

NVSG_API void* mapIn | ( | size_t | offset,
 |  | size_t | numBytes
 | ) |

Map a view of the file.

Parameters:
offset | The offset that has to be part of the mapping.
numBytes | The number of bytes that, starting from offset, are to be part of the mapping.
Returns:
A pointer to the mapped memory location, or NULL if the mapping failed.
See also:
mapOut

Reimplemented from FileMapping.

The documentation for this class was generated from the following file:
  • FileMapping.h
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


Member List

WriteMapping Member List

This is the complete list of members for WriteMapping, including all inherited members.
FileMapping() | FileMapping | [protected]
getLastError() const | FileMapping | [inline]
isValid() const | FileMapping | [inline]
m_accessType | FileMapping | [protected]
m_file | FileMapping | [protected]
m_fileMapping | FileMapping | [protected]
m_isValid | FileMapping | [protected]
m_mappingSize | FileMapping | [protected]
mapIn(size_t offset, size_t numBytes) | WriteMapping |
mapOut(const void *offsetPtr) | FileMapping |
WriteMapping(const std::string &fileName, size_t fileSize) | WriteMapping |
~FileMapping() | FileMapping | [protected]
~WriteMapping() | WriteMapping |
Generated on Tue Jan 15 10:29:46 2008 for NVSGSDK by NVIDIA


WRLLoader Class Reference

A Scene loader for wrl files. More...

#include <WRLLoader.h>

Inheritance diagram for WRLLoader:

[legend]
Collaboration diagram for WRLLoader:

[legend]
List of all members.

Public Member Functions

unsigned int | getStepsPerUnit () const
Get the number of steps per time unit.

void | setStepsPerUnit (unsigned int stepsPerUnit)
Get the number of steps per time unit.

void | deleteThis (void)
Realization of the pure virtual interface function of a PlugIn.

nvsg::SceneHandle * | load (const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState)
Realization of the pure virtual interface function of a SceneLoader.

Detailed Description

A Scene loader for wrl files.

Remarks:
This loader does not support the complete VRML 2.0 standard. Only a subset of the Nodes are mapped to NVSG objects. Unsupported VRML Nodes are just ignored.
The following VRML Nodes are supported:
  • Appearance
    An Appearance Node is translated into a nvsg::StateSet that might hold a nvsg::Material and a nvsg::TextureAttribute. If the nvsg::Material has an opacity of less than one, or if the nvsg::TextureAttribute holds a texture with alpha channel, a nvsg::BlendAttribute is added.
  • Background
    The Background::skyColor is used as the back color of the nvsg::Scene.
  • Billboard
    A Billboard Node is translated into a nvsg::Billboard. If the length of Billboard::axisOfRotation is less than FLT_EPSILON, the nvsg::Billboard is set to be screen aligned, otherwise it is not and the Billboard::axisOfRotation is used as the rotation axis. All the Billboard::children are added to the nvsg::Billboard as children.
  • Box
    A Box Node first is translated into an IndexedFaceSet Node with eight faces. If the associated Appearance Node holds a Texture Node, texture coordinates are created. Then the IndexedFaceSet Node is interpreted as described below.
  • Color
    A Color Node is translated into the colors of a nvsg::VertexAttributeSet.
  • ColorInterpolator
    A ROUTE with an eventOut Node as a ColorInterpolator, an eventOut name of "value_changed", an eventIn Node as a Color, and an eventIn name of "color" or "set_color" is translated into an animation fo colors, used for example in an nvsg::AnimatedTriangles.
  • Coordinate
    A Coordinate Node is translated into the vertices of a nvsg::VertexAttributeSet.
  • CoordinateInterpolator
    A ROUTE with an eventOut Node as a CoordinateInterpolator, an eventOut name of "value_changed", an eventIn Node as a Coordinate, and an eventIn name of "point" or "set_point" is translated into an animation of vertices, used for example in an nvsg::AnimatedTriangles.
  • DirectionalLight
    A DirectionalLight Node is translated into a nvsg::DirectedLight. The DirectionalLight::ambientIntensity times the DirectionalLight::color is set as the ambient color; the DirectionalLight::intensity times the DirectionalLight::color is set as the diffuse and the specular color; the DirectionalLight::direction is set as the direction.
  • ElevationGrid
    An ElevationGrid Node is translated into an IndexedFaceSet Node with one Quad per grid cell, using xDimension, xSpacing, height, zDimension, and zSpacing. If ElevationGrid::color is not NULL, IndexedFaceSet::color is set to ElevationGrid::color and IndexedFaceSet::colorPerVertex is set to ElevationGrid::colorPerVertex. If ElevationGrid::normal is not NULL, IndexedFaceSet::normal is set to ElevationGrid::normal and IndexedFaceSet::normalPerVertex is set to ElevationGrid::normalPerVertex. If ElevationGrid::texCoord is not NULL, IndexedFaceSet::texCoord is set to ElevationGrid::texCoord. If ElevationGrid::texCoord is NULL, IndexedFaceSet::texCoord is set by creating texture coordinates ranging from (0,0) at the first vertex to (1,1) at the last vertex. IndexedFaceSet::ccw, IndexedFaceSet::creaseAngle, and IndexedFaceSet::solid are set to ElevationGrid::ccw, ElevationGrid::creaseAngle, and ElevationGrid::solid, respectively.
  • Group
    A Group Node is translated into a nvsg::Group. All the Group::children are added to the nvsg::Group as children.
  • ImageTexture
    An ImageTexture Node is translated into a nvsg::TextureAttribute. If a file could be found at Node::url, and a nvsg::TextureImage could be created out of that, a nvsg::TextureAttributeItem is created to hold that nvsg::TextureImage. ImageTexture::repeatS and ImageTexture::repeatT are translated to the nvsg::TextureWrapMode TWM_REPEAT or TWM_CLAMP for the nvsg::TextureWrapCoordAxis TWCA_S and TWCA_T, respectively. That nvsg::TextureAttributeItem then is bound to texture unit 0 in the new nvsg::TextureAttribute.
  • IndexedFaceSet
    An IndexedFaceSet Node is translated into a nvsg::Triangles and/or a nvsg::Quads. Only triangles and quadrangles are used. Faces with more than 4 vertices are ignored. If IndexedFaceSet::normal is NULL, a Normal Node holding a set of smoothed normals is created, using IndexedFaceSet::creaseAngle. If there is a ROUTE with a "set_point" eventIn on IndexedFaceSet::coord or if there is a ROUTE with a "set_vector" eventIn on IndexedFaceSet::normal, instead of a nvsg::Triangles and/or a nvsg::Quads a nvsg::AnimatedTriangles and/or a nvsg::AnimatedQuads are created, each one with a nvsg::LinearInterpolatedAnimation of a nvsg::VNVector. If IndexedFaceSet::color is not NULL, one color per vertex is created, using IndexedFaceSet::colorIndex and IndexedFaceSet::colorPerVertex if needed, and set as the color. The IndexedFaceSet::coord is set as the vertices, using IndexedFaceSet::coordIndex if needed. If IndexedFaceSet::normal is not NULL, one normal per vertex is created, using IndexedFaceSet::normalIndex and IndexedFaceSet::normalPerVertex if needed, and set as the normals. If IndexedFaceSet::texCoord is not NULL, one two-dimensional texture coordinate per vertex is created, using IndexedFaceSet::texCoordIndex, and as the texture coordinates for texture unit 0. If IndexedFaceSet::ccw is true, the triangles and quads are inverted. IndexedFaceSet::convex and IndexedFaceSet::solid are ignored.
  • IndexedLineSet
    An IndexedLineSet Node is translated into a nvsg::LineStrips. For each index in IndexedLineSet::coordIndex, a vertex is created out of IndexedLineSet::coord. If IndexedLineSet::color is not NULL, one color per vertex is created, using IndexedLineSet::colorIndex and IndexedLineSet::colorPerVertex if needed.
  • Inline
    If the file specified by Inline::url can be loaded, it is loaded into it's own nvsg::Scene, and the root node of that nvsg::Scene is used.
  • LOD
    A LOD Node is translated into a nvsg::LOD. All the LOD::level are added to the nvsg::LOD as children. The LOD::center is set as the center in the nvsg::LOD. If LOD::range is not empty, those values are used as the ranges in nvsg::LOD. Otherwise some default ranges are created.
  • Material
    A Material Node is translated into a nvsg::Material. The Material::ambientIntensity times the Material::diffuseColor is set as the ambient color of the nvsg::Material. The Material::diffuseColor, Material::emissiveColor, and Material::specularColor are set as the diffuse color, emissive color, and specular color, respectively, of the nvsg::Material. The Material::shininess is multiplied by 128 and set as the specular exponent of the nvsg::Material. One minus Material::transparency is set as the opacity of the nvsg::Material.
  • Normal
    A Normal Node is translated into the normals of a nvsg::VertexAttributeSet.
  • NormalInterpolator
    A ROUTE with an eventOut Node as a NormalInterpolator, an eventOut name of "value_changed", an eventIn Node as a Normal, and an eventIn name of "vector" or "set_vector" is translated into an animation of normals, used for example in an nvsg::AnimatedTriangles.
  • OrientationInterpolator
    A ROUTE with an eventOut Node as an OrientationInterpolator, an eventOut name of "value_changed", an eventIn Node as a Transform or a Viewpoint, and an eventIn name of "orientation" or "set_orientation" is translated into an animation of orientations, used for example in an nvsg::AnimatedTransform.
  • PointLight
    A PointLight Node is translated into a nvsg::PointLight. The PointLight::ambientIntensity times the PointLight::color is set as the ambient color of the nvsg::PointLight. The PointLight::intensity times the PointLight::color is set as the diffuse color of the nvsg::PointLight. The PointLight::diffuseColor, PointLight::attenuation, and PointLight::location are set as the specular color, attenuation, and position, respectively, of the nvsg::PointLight.
  • PointSet
    A PointSet Node is translated into a nvsg::Points. The PointSet::coord is set as the vertices of the nvsg::Points. If PointSet::colors is not NULL, they are set as the colors of the nvsg::Points.
  • PositionInterpolator
    A ROUTE with an eventOut Node as an PositionInterpolator, an eventOut name of "value_changed", an eventIn Node as a Transform or a Viewpoint, and an eventIn name of "center", "set_center", "scale", "set_scale", "translation", or "set_translation", in case of a Transform as the eventIn Node, or "position" or "set_position", in case of a Viewpoint as the eventIn Node, is translated into an animation of nvmath::Vec3f, used for example in an AnimatedTransform.
  • Shape
    A Shape Node is translated into a nvsg::GeoNode. If the Shape::appearance is not NULL, it is translated into a nvsg::StateSet, and if Shape::geometry is not NULL, it is translated into a number of nvsg::Drawable, that are added to the nvsg::GeoNode as the geometries.
  • SpotLight
    A SpotLight Node is translated into a nvsg::SpotLight. The SpotLight::ambientIntensity times the SpotLight::color is set as the ambient color of the nvsg::SpotLight. The SpotLight::intensity times the SpotLight::color is set as the diffuse color of the nvsg::SpotLight. The SpotLight::diffuseColor, SpotLight::attenuation, SpotLight::direction, SpotLight::location, and half of the SpotLight::cutOffAngle are set as the specular color, attenuation, direction, and cut off angle, respectively, of the nvsg::SpotLight. If the SpotLight::beamWidth is less than the SpotLight::cutOffAngle, the SpotLight::cutOffAngle divided by the SpotLight::beamWidth is set as the falloff exponent of the nvsg::SpotLight.
  • Switch
    A Switch Node is translated into a nvsg::Switch. All the Switch::choice are set as the children of the nvsg::Switch. If Switch::whichChoice is between 0 and the number of children, that child is set as active, otherwise no child is set as active.
  • TextureCoordinate
    A TextureCoordinate Node is translated into two-dimensional texture coordinates for the first texture unit in a nvsg::VertexAttributeSet.
  • TextureTransform
    A TextureTransform Node is translated into the orientation (rotation around the z-axis), scaling (in x and y), and translation (in x and y) of a nvsg::TextureAttributeItem. The TextureTransform::center is ignored.
  • TimeSensor
    A ROUTE with an eventOut Node as an TimeSensor, an eventOut name of "fraction_changed", an eventIn Node as an Interpolator, and an eventIn name of "fraction" or "set_fraction" is translated into a TimeSensor for that Interpolator. Currently, only the cycleInterval is used to determine the duration of the animation.
  • Transform
    A Transform Node is translated into a nvsg::Transform. If there is a ROUTE with a Transform as the eventIn Node and "center", "set_center", "rotation", "set_rotation", "scale", "set_scale", "translation" or "set_translation" as the eventIn name, an nvsg::AnimatedTransform is created instead. Transform::center, Transform::rotation, Transform::scale, Transform::scaleOrientation, and Transform::translation are used to form the nvmath::Trafo of the nvsg::Transform. All the Transform::children are added to the nvsg:Transform as children.
  • Viewpoint
    A Viewpoint Node is translated into a nvsg::PerspectiveCamera. Viewpoint::fieldOfView, Viewpoint::orientation, and Viewpoint::position are set as field of view, orientation and position, respectively of the nvsg::PerspectiveCamera. If there is a ROUTE with an eventOut Node as an OrientationInterpolator, an eventOut name of "value_changed", an eventIn Node as a Viewpoint, and an eventIn name of "orientation" or "set_orientation", or if there is a ROUTE with an eventOut Node as a PositionInterpolator, an eventOut name of "value_changed", an eventIn Node as a Viewpoint, and an eventIn name of "position" or "set_position", a camera animation of type nvsg::LinearInterpolatedAnimation of nvmath::Trafo is created in addition. The Viewpoint::jump and Viewpoint::description are ignored.
That is, the followng VRML Nodes are not supported: Anchor, AudioClip, Collision, Cone, Cylinder, CylinderSensor, Extrusion, Fog, FontStyle, MovieTexture, NavigationInfo, PixelTexture, PlaneSensor, ProximitySensor, ScalarInterpolator, Script, Sound, Sphere, SphereSensor, Text, TouchSensor, VisibilitySensor, WorldInfo. Additionally, as described in detail above, only a very limited number of events, and no sensors are supported. No PROTO or EXTERNPROTO is supported.
See also:
SceneLoader

Member Function Documentation

unsigned int getStepsPerUnit ( ) const [inline]

Get the number of steps per time unit.

Returns:
The number of steps per time unit used in animations.
Remarks:
The animations in a WRL file are specified by key values, usually in the range [0...1]. This is one time unit and this WRLLoader uses stepsPerUnit intervals for remapping them into the frame based animation approach of NVSG.
See also:
setStepsPerUnit

void setStepsPerUnit ( unsigned int stepsPerUnit ) [inline]

Get the number of steps per time unit.

Parameters:
stepsPerUnit The number of steps per time unit used in animations.
Remarks:
The animations in a WRL file are specified by key values, usually in the range [0...1]. This is one time unit and this WRLLoader uses stepsPerUnit intervals for remapping them into the frame based animation approach of NVSG.
See also:
getStepsPerUnit

void deleteThis ( void ) [inline, virtual]

Realization of the pure virtual interface function of a PlugIn.

Note:
Never call delete on a PlugIn, always use the member function.

Implements PlugIn.

nvsg::SceneHandle* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | nvsg::ViewStateHandle *& | viewState
 | ) | [virtual]

Realization of the pure virtual interface function of a SceneLoader.

Loads a nvsg file given by filename. It looks for this file and possibly referenced other files like textures or effects at the given path first, then at the current location and finally it searches through the searchPaths.

Returns:
A pointer to the loaded scene.
Parameters:
filename | file to load
searchPaths | paths to search through
viewState | If the function succeeded, this points to the optional ViewState stored with the scene.

Implements SceneLoader.

The documentation for this class was generated from the following file:
  • WRLLoader.h
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Member List

WRLLoader Member List

This is the complete list of members for WRLLoader, including all inherited members.
callback(void) const | PlugIn | [inline, protected]
callback(void) (defined in PlugIn) | PlugIn | [inline, protected]
deleteThis(void) | WRLLoader | [inline, virtual]
getStepsPerUnit() const | WRLLoader | [inline]
load(const std::string &filename, const std::vector< std::string > &searchPaths, nvsg::ViewStateHandle *&viewState) | WRLLoader | [virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
setStepsPerUnit(unsigned int stepsPerUnit) | WRLLoader | [inline]
WRLLoader() (defined in WRLLoader) | WRLLoader |
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneLoader() | SceneLoader | [protected, virtual]
~WRLLoader() (defined in WRLLoader) | WRLLoader |
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


WRLLoadTraverser Class Reference

Internally used traverser for post-processing a just loaded VRML file. More...

#include <WRLLoadTraverser.h>

Inheritance diagram for WRLLoadTraverser:

[legend]
Collaboration diagram for WRLLoadTraverser:

[legend]
List of all members.

Public Member Functions

WRLLoadTraverser ()
Constructor.

virtual | ~WRLLoadTraverser (void)
Destructor.

Protected Member Functions

virtual void | doApply (nvsg::NodeHandle *root)
Entry point of the postprocessor of the WRLLoader.

virtual void | handleAnimatedTransform (nvsg::AnimatedTransform *p)
Postprocessing on AnimatedTransform.

virtual void | handleBillboard (nvsg::Billboard *p)
Postprocessing on Billboard.

virtual void | handleGroup (nvsg::Group *p)
Postprocessing on Group.

virtual void | handleTransform (nvsg::Transform *p)
Postprocessing on Transform.

Detailed Description

Internally used traverser for post-processing a just loaded VRML file.

Constructor & Destructor Documentation

WRLLoadTraverser ( )

Constructor.

virtual ~WRLLoadTraverser ( void ) [virtual]

Destructor.

Member Function Documentation

virtual void doApply ( nvsg::NodeHandle * root ) [protected, virtual]

Entry point of the postprocessor of the WRLLoader.

It first initiates a standard traversal of the ViewSate and Scene, then all encountered lights are set to be children of the root node.

Reimplemented from ExclusiveTraverser.

virtual void handleAnimatedTransform ( nvsg::AnimatedTransform * p ) [protected, virtual]

Postprocessing on AnimatedTransform.

First the standard traversal of p is initiated, then all children of type LightSource are moved to the root node.

Reimplemented from ExclusiveTraverser.

virtual void handleBillboard ( nvsg::Billboard * p ) [protected, virtual]

Postprocessing on Billboard.

First the standard traversal of p is initiated, then all children of type LightSource are moved to the root node.

Reimplemented from ExclusiveTraverser.

virtual void handleGroup ( nvsg::Group * p ) [protected, virtual]

Postprocessing on Group.

First the standard traversal of p is initiated, then all children of type LightSource are moved to the root node.

Reimplemented from ExclusiveTraverser.

virtual void handleTransform ( nvsg::Transform * p ) [protected, virtual]

Postprocessing on Transform.

First the standard traversal of p is initiated, then all children of type LightSource are moved to the root node.

Reimplemented from ExclusiveTraverser.

The documentation for this class was generated from the following file:
  • WRLLoadTraverser.h
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Member List

WRLLoadTraverser Member List

This is the complete list of members for WRLLoadTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *)) | ExclusiveTraverser | [inline, protected]
addObjectHandler(unsigned int objectCode, void(T::*handler)(U *, V)) | ExclusiveTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(nvsg::NodeHandle *root) | Traverser |
apply(nvsg::SceneHandle *scene) | Traverser |
doApply(nvsg::NodeHandle *root) | WRLLoadTraverser | [protected, virtual]
evaluateCullTree(const nvsg::ViewState *viewState) | Traverser | [protected]
ExclusiveTraverser() | ExclusiveTraverser |
handleAlphaTestAttribute(nvsg::AlphaTestAttribute *alphaTestAttrib) | ExclusiveTraverser | [protected, virtual]
handleAnimatedTransform(nvsg::AnimatedTransform *p) | WRLLoadTraverser | [protected, virtual]
handleAnimatedVertexAttributeSet(nvsg::AnimatedVertexAttributeSet *avas) | ExclusiveTraverser | [protected, virtual]
handleBillboard(nvsg::Billboard *p) | WRLLoadTraverser | [protected, virtual]
handleBlendAttribute(nvsg::BlendAttribute *blendAttrib) | ExclusiveTraverser | [protected, virtual]
handleCgFx(nvsg::CgFx *cgfx) | ExclusiveTraverser | [protected, virtual]
handleDepthAttribute(nvsg::DepthAttribute *depthAttrib) | ExclusiveTraverser | [protected, virtual]
handleDirectedLight(nvsg::DirectedLight *light) | ExclusiveTraverser | [protected, virtual]
handleFaceAttribute(nvsg::FaceAttribute *faceAttrib) | ExclusiveTraverser | [protected, virtual]
handleFlipbookAnimation(nvsg::FlipbookAnimation *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedIndexAnimation(nvsg::FramedAnimation< unsigned int > *anim) | ExclusiveTraverser | [protected, virtual]
handleFramedTrafoAnimation(nvsg::FramedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleFramedVertexAttributeAnimation(nvsg::FramedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleGeoNode(nvsg::GeoNode *gnode) | ExclusiveTraverser | [protected, virtual]
handleGroup(nvsg::Group *p) | WRLLoadTraverser | [protected, virtual]
handleHighlightBox(nvsg::HighlightBox *hlBox, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleHighlightEdges(nvsg::HighlightEdges *hlEdges, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
handleLightingAttribute(nvsg::LightingAttribute *laAttrib) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *trafo) | ExclusiveTraverser | [protected, virtual]
handleLinearInterpolatedVertexAttributeAnimation(nvsg::LinearInterpolatedAnimation< nvsg::VertexAttribute > *p) | ExclusiveTraverser | [protected, virtual]
handleLineAttribute(nvsg::LineAttribute *lineAttrib) | ExclusiveTraverser | [protected, virtual]
handleLines(nvsg::Lines *lines) | ExclusiveTraverser | [protected, virtual]
handleLineStrips(nvsg::LineStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleLOD(nvsg::LOD *lod) | ExclusiveTraverser | [protected, virtual]
handleMapArray(nvsg::MapArray *mapArray) | ExclusiveTraverser | [protected, virtual]
handleMapElement(nvsg::MapElement *mapElement) | ExclusiveTraverser | [protected, virtual]
handleMapList(nvsg::MapList *mapList) | ExclusiveTraverser | [protected, virtual]
handleMapMatrix(nvsg::MapMatrix *mapMatrix) | ExclusiveTraverser | [protected, virtual]
handleMaterial(nvsg::Material *material) | ExclusiveTraverser | [protected, virtual]
handleParallelCamera(nvsg::ParallelCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePerspectiveCamera(nvsg::PerspectiveCamera *camera) | ExclusiveTraverser | [protected, virtual]
handlePointAttribute(nvsg::PointAttribute *pointAttrib) | ExclusiveTraverser | [protected, virtual]
handlePointLight(nvsg::PointLight *light) | ExclusiveTraverser | [protected, virtual]
handlePoints(nvsg::Points *points) | ExclusiveTraverser | [protected, virtual]
handleQuadMeshes(nvsg::QuadMeshes *meshes) | ExclusiveTraverser | [protected, virtual]
handleQuads(nvsg::Quads *quads) | ExclusiveTraverser | [protected, virtual]
handleQuadStrips(nvsg::QuadStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleShape(nvsg::Shape *shape) | ExclusiveTraverser | [protected, virtual]
handleSkin(nvsg::Skin *skin) | ExclusiveTraverser | [protected, virtual]
handleSkinnedTriangles(nvsg::SkinnedTriangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleSpotLight(nvsg::SpotLight *light) | ExclusiveTraverser | [protected, virtual]
handleStatePass(nvsg::StatePass *pass) | ExclusiveTraverser | [protected, virtual]
handleStateSet(nvsg::StateSet *stateSet) | ExclusiveTraverser | [protected, virtual]
handleStateVariant(nvsg::StateVariant *variant) | ExclusiveTraverser | [protected, virtual]
handleSwitch(nvsg::Switch *swtch) | ExclusiveTraverser | [protected, virtual]
handleTextureAttribute(nvsg::TextureAttribute *texAttrib) | ExclusiveTraverser | [protected, virtual]
handleTextureAttributeItem(nvsg::TextureAttributeItem *texAttribItem, unsigned int tu) | ExclusiveTraverser | [protected, virtual]
handleTransform(nvsg::Transform *p) | WRLLoadTraverser | [protected, virtual]
handleTriangles(nvsg::Triangles *triangles) | ExclusiveTraverser | [protected, virtual]
handleTriFans(nvsg::TriFans *fans) | ExclusiveTraverser | [protected, virtual]
handleTriStrips(nvsg::TriStrips *strips) | ExclusiveTraverser | [protected, virtual]
handleUnlitColorAttribute(nvsg::UnlitColorAttribute *unlitColor) | ExclusiveTraverser | [protected, virtual]
handleVertexAttributeSet(nvsg::VertexAttributeSet *vas) | ExclusiveTraverser | [protected, virtual]
handleVolumeNode(nvsg::VolumeNode *vnode) | ExclusiveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
lockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
lockScene() | ExclusiveTraverser | [protected, virtual]
lockViewState() | ExclusiveTraverser | [protected, virtual]
m_cullStack | Traverser | [protected]
m_currentAttrib (defined in Traverser) | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_lastLodCheckSum (defined in Traverser) | Traverser | [protected]
m_lockedScene | ExclusiveTraverser | [protected]
m_lockedViewState | ExclusiveTraverser | [protected]
m_lodCheckSum (defined in Traverser) | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_mftbl | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_root | Traverser | [protected]
m_scene | Traverser | [protected]
m_traverserBits | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSG_CULLTREE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_ROOT_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_SCENE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
NVSG_TRAVERSAL_INTERRUPTED enum value (defined in Traverser) | Traverser | [protected]
NVSG_TREE_DIRTY_MASK enum value (defined in Traverser) | Traverser | [protected]
NVSG_VIEWSTATE_DIRTY enum value (defined in Traverser) | Traverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, const char *src, unsigned int ln) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
preApply(nvsg::NodeHandle *root) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *gnode, unsigned int geomIndex) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *grp) | Traverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setScene(nvsg::SceneHandle *scene) | Traverser |
setViewState(nvsg::ViewStateHandle *viewState) | Traverser |
theAllocator typedef | IAllocator |
traverseCamera(nvsg::Camera *camera) | ExclusiveTraverser | [protected, virtual]
traverseGeoNode(const nvsg::GeoNode *gnode) | Traverser | [protected]
traverseGroup(const T *grp) | Traverser | [protected]
traverseHighlightObject(nvsg::HighlightObject *hlObject, const nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
traverseLight(nvsg::LightSource *light) | ExclusiveTraverser | [protected, virtual]
traverseMapList(const nvsg::MapList *mapList) | Traverser | [protected]
traverseObject(nvsg::ObjectHandle *obj) | Traverser | [inline, protected]
traverseObject(nvsg::ObjectHandle *obj, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(nvsg::PrimitiveSet *pset) | ExclusiveTraverser | [protected, virtual]
Traverser() | Traverser | [protected]
traverseShape(const nvsg::Shape *shape) | Traverser | [protected]
traverseStatePass(const nvsg::StatePass *pass) | Traverser | [protected]
traverseStateVariant(const nvsg::StateVariant *variant) | Traverser | [protected]
traverseTextureAttribute(const nvsg::TextureAttribute *texAttrib) | Traverser | [protected]
traverseVolumeNode(const nvsg::VolumeNode *volNode) | Traverser | [protected]
unlockObject(nvsg::ObjectHandle *obj) | ExclusiveTraverser | [protected, virtual]
unlockScene() | ExclusiveTraverser | [protected, virtual]
unlockViewState() | ExclusiveTraverser | [protected, virtual]
wasTraversalInterrupted() | Traverser | [inline]
WRLLoadTraverser() | WRLLoadTraverser |
~ExclusiveTraverser() | ExclusiveTraverser | [inline, protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser() | Traverser | [protected, virtual]
~WRLLoadTraverser(void) | WRLLoadTraverser | [virtual]
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Hierarchical Index

NVSGSDK Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

  • addReference
  • Allocator
  • AnalyzeResult
    • CombinableResult
    • DenormalizedNormalsResult
    • EmptyResult
    • EquivalenceResult
    • IdentityResult
    • MissingResult
    • NullNormalsResult
    • RedundantLODRangesResult
    • ShortStrippedResult
    • SingleChildResult
  • Animation
    • FramedAnimation
    • KeyFramedAnimation
      • LinearInterpolatedAnimation
  • AutoLock
  • BaseRenderElement
    • ClipPlanesElement
    • HighlightElement
    • LightsElement
    • RenderElement
    • TransformElement
  • Bit
  • Bone
  • bone_t
  • Boxnt
  • CallbackServer
  • CgDecomposer
  • CgDecomposer::Method
  • CgDecomposer::Struct
  • CgFxContext
  • CgFxEffect
  • Chunk
  • CloneObject
  • CompileTimeAssert< true >
  • Component
  • Conversion
  • Conversion< T, T >
  • CPUSkinningProcessor
  • DALData
    • nvgl::GLDALData
  • DALDataCreator
    • nvgl::GLDALDataCreator
  • DALHost
  • DALHostHolder
  • EmptyType
  • ErrorHandler
  • Face
  • FileMapping
    • ReadMapping
    • WriteMapping
  • FixedAllocator
  • FRAGOUT
  • geometrySet_t
  • GLArrayBufferCache
  • GLArrayBufferCache::Deleter
  • GLContext
  • GLDisplayListCache
  • GLDisplayListCache::Deleter
  • GLElementArrayBufferCache
  • GLElementArrayBufferCache::Deleter
  • GLEvalVertexAttrib
  • GLFunctions
  • GLObjects
  • GLPixelBufferCache
  • GLPixelBufferCache::Deleter
  • GLResourceDeleter
  • GLTexImageFmt
  • GLTextureCache
  • GLTextureCache::Deleter
  • GLTextureCache::GLImageFormat
  • GLXFunctions
  • GPUSkinningProcessor
  • Handle
  • Handle< U, V >
    • Handle< T, Handle< U, V > >
  • HandledObject
  • IAllocator
    • nvutil::Holder
    • RCObject
      • ChangeCallback
      • CullData
      • Path
      • ScaleFilter
        • BellFilter
        • BoxFilter
        • BSplineFilter
        • Lanczos3Filter
        • TriangleFilter
      • TextureAttributeItemData
      • nvtraverser::AppTraverser::SkinningProcessor
      • Traverser
        • ExclusiveTraverser
          • NVBLoadTraverser
          • DestrippingTraverser
          • ExclusiveModelViewTraverser
            • AppTraverser
            • BalanceTraverser
          • NormalizeTraverser
          • OptimizeTraverser
            • CombineTraverser
            • EliminateTraverser
            • IdentityToGroupTraverser
            • UnifyTraverser
            • VertexUnifyTraverser
          • SmoothTraverser
          • StrippingTraverser
          • TriangulateTraverser
          • WRLLoadTraverser
        • SharedTraverser
          • ExtractGeometryTraverser
          • NBFSaveTraverser
          • NVSGSaveTraverser
          • AnalyzeTraverser
          • SearchTraverser
          • SharedModelViewTraverser
            • CullTraverser
              • nvtraverser::DefaultCullTraverser
              • FrustumCullTraverser
              • NodeHintsCullTraverser
            • RayIntersectTraverser
            • RenderTraverser
              • GLTraverser
                • GLUploadTraverser
      • Handle< T, NullType >
      • PlugInCallback
      • RCVector
  • Image
  • Incarnation
  • IndexMesh
  • indexSet_t
  • Intersection
  • KeyInput
  • keyVariant_t
  • Log
  • LogListCompare
  • Manipulator
    • AnimationManipulator
    • FlightCameraManipulator
    • TrackballCameraManipulator
    • TransformManipulator
      • TrackballTransformManipulator
    • WalkCameraManipulator
  • Matnnt
  • MemFunTbl
  • meshSet_t
  • MouseInput
  • NBFAnimation
    • NBFFramedAnimation
      • NBFFramedIndexAnimation
      • NBFFramedTrafoAnimation
      • NBFFramedVertexAttributeAnimation
    • NBFInterpolatedAnimation
      • NBFInterpolatedTrafoAnimation
      • NBFInterpolatedVertexAttributeAnimation
  • NBFHeader
  • NBFObject
    • NBFCamera
      • NBFParallelCamera
      • NBFPerspectiveCamera
    • NBFDrawable
      • NBFPrimitiveSet
        • NBFIndependentPrimitiveSet
          • NBFSkinnedTriangles
        • NBFMeshedPrimitiveSet
        • NBFStrippedPrimitiveSet
    • NBFIndexAnimation
      • NBFFramedIndexAnimation
    • NBFLightSource
      • NBFDirectedLight
      • NBFPointLight
      • NBFSpotLight
    • NBFNode
      • NBFGeoNode
      • NBFGroup
        • NBFBillboard
        • NBFFlipbookAnimation
        • NBFLOD
        • NBFSwitch
        • NBFTransform
          • NBFAnimatedTransform
      • NBFVolumeNode
    • NBFSkin
    • NBFStateAttribute
      • NBFAlphaTestAttribute
      • NBFBlendAttribute
      • NBFCgFx
      • NBFDepthAttribute
      • NBFFaceAttribute
      • NBFLightingAttribute
      • NBFLineAttribute
      • NBFMaterial
      • NBFPointAttribute
      • NBFTextureAttribute
      • NBFUnlitColorAttribute
    • NBFStatePass
    • NBFStateSet
    • NBFStateVariant
    • NBFTextureAttributeItem
    • NBFTrafoAnimation
      • NBFFramedTrafoAnimation
      • NBFInterpolatedTrafoAnimation
    • NBFVertexAttributeAnimation
      • NBFFramedVertexAttributeAnimation
      • NBFInterpolatedVertexAttributeAnimation
    • NBFVertexAttributeSet
      • NBFAnimatedVertexAttributeSet
  • NBFScene
  • NBFViewState
  • NVGVOCAPS
  • NVGVOCOLORCONVERSION
  • NVGVODATAFORMATDETAIL
  • NVGVODRIVER
  • NVGVOFIRMWARE
  • NVGVOOUTPUTREGION
  • NVGVOSIGNALFORMATDETAIL
  • NVGVOSTATUS
  • NVNVB
  • NVSGException
  • NVSGLight
  • NVSGMaterial
  • NVSGScene
  • NVSGTexImageFmt
  • NVVIDEOMODE
  • Object
    • Camera
      • ParallelCamera
      • PerspectiveCamera
    • HighlightObject
      • HighlightBox
      • HighlightEdges
    • Map
    • MapList
    • MapObject
      • MapArray
      • MapElement
      • MapMatrix
    • Node
      • GeoNode
      • Group
        • Billboard
        • FlipbookAnimation
        • LOD
        • Switch
        • Transform
          • AnimatedTransform
      • VolumeNode
    • OwnedObject
    • OwnedObject< GroupHandle >
      • LightSource
        • DirectedLight
        • PointLight
        • SpotLight
    • OwnedObject< NodeHandle >
      • Drawable
        • PrimitiveSet
          • IndependentPrimitiveSet
            • Lines
            • Points
            • Quads
            • Triangles
              • SkinnedTriangles
          • MeshedPrimitiveSet
            • QuadMeshes
          • StrippedPrimitiveSet
            • LineStrips
            • QuadStrips
            • TriFans
            • TriStrips
        • Shape
      • StateSet
    • OwnedObject< ObjectHandle >
      • nvsg::AnimationBase
    • OwnedObject< PrimitiveSetHandle >
      • Skin
      • VertexAttributeSet
        • AnimatedVertexAttributeSet
    • OwnedObject< StatePassHandle >
      • StateAttribute
        • AlphaTestAttribute
        • BlendAttribute
        • CgFx
        • DepthAttribute
        • LightingAttribute
        • Material
        • PrimitiveAttribute
          • FaceAttribute
          • LineAttribute
          • PointAttribute
        • TextureAttribute
        • UnlitColorAttribute
    • OwnedObject< StateSetHandle >
      • StateVariant
    • OwnedObject< StateVariantHandle >
      • StatePass
    • OwnedObject< TextureAttributeHandle >
      • TextureAttributeItem
  • ObjFace
  • ObjGeoSet
  • ObjLoader
  • ObjMaterial
  • ObjScene
  • plane_t
  • Planent
  • PlugIn
    • SceneLoader
      • NBFLoader
      • NVBLoader
      • NVSGLoader
      • PLYLoader
      • WRLLoader
    • SceneSaver
      • NBFSaver
      • NVSGSaver
      • OBJSaver
    • TextureLoader
      • ILTexLoader
      • VolLoader
    • TextureSaver
      • ILTexSaver
      • VolSaver
  • PlugInCallback::DegenerateGeometryInfo
  • PlugInCallback::EmptyTokenInfo
  • PlugInCallback::FileAccessFailedInfo
  • PlugInCallback::FileMappingFailedInfo
  • PlugInCallback::IncompatibleFileInfo
  • PlugInCallback::IncompatibleValueInfo
  • PlugInCallback::InvalidFileInfo
  • PlugInCallback::InvalidValueInfo
  • PlugInCallback::UndefinedTokenInfo
  • PlugInCallback::UnexpectedTokenInfo
  • PlugInCallback::UnknownTokenInfo
  • PlugInCallback::UnsupportedTokenInfo
  • PlugInServer
  • PLYElement
  • PLYProperty
  • ProblemInfo
  • ProblemLog
  • Quatt
  • RCIPtr
  • RCObject_AutoPtr
  • RCPtr
  • ReadableObject
  • RegVal
  • removeReference
  • RenderArea
    • GLWinRenderArea
      • GLMFCRAWnd
  • RenderElementCompareBackToFront
  • RenderElementCompareFrontToBack
  • RenderElementCompareStateAttributes
  • RenderElementPool
  • Renderer
  • sampler_t
  • Scene
  • SimpleTesselator
  • Singleton
  • skin_t
  • SkinnedTriangles::Skin
  • Spherent
  • sstr_t
  • StackedAtlas
  • StackedAtlasManager
  • std::vector
  • std::vector
  • std::vector
  • std::vector
  • std::vector
  • str_t
  • StrTokenizer
  • switchMask_t
  • SWMRSync
  • tagNVGAMMARAMP10
  • tagNVGAMMARAMP8
  • tagNVGVOCONFIG
  • tagNVGVOSYNCDELAY
  • TaiEntry
  • TaiManager
  • texBinding_t
  • texCoordSet_t
  • texImage_t
  • TextureImage
    • VolumeTexture
  • Trace
  • traceConsoleDebugOutput
  • traceConsoleOutput
  • traceDebugOutput
  • traceFileConsoleOutput
  • traceFileDebugOutput
  • traceFileOutput
  • TraceFunctor
  • Trackball
  • Trafo
  • trafo_t
  • TransformStack
  • tweak_t
  • Type2EnumType
  • Type2EnumType< char >
  • Type2EnumType< double >
  • Type2EnumType< float >
  • Type2EnumType< int >
  • Type2EnumType< short >
  • Type2EnumType< unsigned char >
  • Type2EnumType< unsigned int >
  • Type2EnumType< unsigned short >
  • UPIID
  • UPITID
  • Validated
  • VariantIterator
  • Vec2f
  • Vec3f
  • Vecnt
  • vertexAttrib_t
  • VertexAttribute
  • ViewState
  • VNVector
  • VolLoader::FileInfo
  • VolumeBrick
  • VS_INPUT
  • VS_OUTPUT
  • WGLFunctions
  • WritableObject
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions
_ | a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | y | z | ~

Here is a list of all documented class members with links to the class documentation for each member:

- _ -

  • _BSFAR : RayIntersectTraverser
  • _BSNEAR : RayIntersectTraverser
  • _BSNEARFAR : RayIntersectTraverser
  • _BSTANGENT : RayIntersectTraverser
  • _CONTROL_KEY : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator
  • _LEFT_MOUSE_BTN : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • _MIDDLE_MOUSE_BTN : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • _NO_BTN_KEY : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • _NONE : RayIntersectTraverser
  • _S_KEY : WalkCameraManipulator, FlightCameraManipulator
  • _SHIFT_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _W_KEY : WalkCameraManipulator, FlightCameraManipulator
  • _X_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _Y_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _Z_KEY : TrackballCameraManipulator

- a -

  • activateClipPlane() : Group
  • active : plane_t
  • activeKey : NBFStateSet
  • activeMaskKey : NBFSwitch
  • addAsParentTo() : Node
  • addAttribute() : StateVariant, StateSet, StatePass
  • addCallback() : CallbackServer
  • addCamera() : Scene
  • addCameraAnimation() : Scene
  • addChild() : Group, CullData
  • addClipPlane() : Group
  • addEmptyColumn() : MapMatrix
  • addEntry() : MemFunTbl
  • addGeometry() : GeoNode
  • addHeadLight() : Camera
  • addHighlightObject() : HighlightElement
  • addHints() : NodeHintsCullTraverser, Node
  • addImage() : TextureImage
  • addItem() : SearchTraverser
  • addJoint() : Skin
  • addKey() : KeyFramedAnimation
  • addKeys() : KeyFramedAnimation
  • addLight() : LightsElement
  • addLightSource() : Group
  • addMap() : MapMatrix, MapArray
  • addMapObject() : MapList
  • addMask() : Switch
  • addObjectHandler() : ExclusiveTraverser, SharedTraverser
  • addObjectRenderer() : RenderTraverser
  • addOnDestroyCallback() : RCObject
  • addOwner() : OwnedObject
  • addPass() : StateVariant, StateSet
  • addPlugInSearchPath : PlugInServer
  • addPrimitiveSet() : RenderElement, Shape
  • addRef() : RCObject, BaseRenderElement
  • addStep() : FramedAnimation
  • addSteps() : FramedAnimation
  • addVariant() : StateSet
  • advanceAnimation() : ViewState
  • Alignment : Billboard
  • alignment : NBFBillboard
  • alloc() : Allocator, FixedAllocator, Chunk, NBFSaveTraverser
  • Allocator() : Allocator
  • alphaFunction : NBFAlphaTestAttribute
  • AlphaTestAttribute() : AlphaTestAttribute
  • ambient : NVSGScene, NVSGMaterial, NVSGLight
  • ambientColor : NBFLightSource, NBFScene
  • AnalyzeTraverser() : AnalyzeTraverser
  • AnimatedTransform() : AnimatedTransform
  • AnimatedVertexAttributeSet() : AnimatedVertexAttributeSet
  • animation : NBFLightSource, NBFAnimatedTransform, NBFFlipbookAnimation, bone_t
  • Animation() : Animation
  • AnimationManipulator() : AnimationManipulator
  • animations : NBFAnimatedVertexAttributeSet
  • annotation : NBFNode
  • antiAliasing : NBFPointAttribute, NBFLineAttribute
  • apply() : Trackball, Traverser
  • applyPass() : CgFxEffect
  • AppTraverser() : AppTraverser
  • AREAOFPEACE : WalkCameraManipulator, FlightCameraManipulator
  • assertInvalidBoundingSphere() : Node
  • assignCustomLightToEffectLight() : RenderTraverser
  • assignDirectedLightToEffectLight() : RenderTraverser, GLTraverser
  • assignPointLightToEffectLight() : RenderTraverser, GLTraverser
  • assignSpotLightToEffectLight() : RenderTraverser, GLTraverser
  • attachHighlightObject() : Drawable
  • attachWindow() : GLWinRenderArea
  • attenuation : NBFSpotLight, NBFPointLight
  • attribs : NBFVertexAttributeAnimation

- b -

  • BA_AXIS : Billboard
  • BA_SCREEN : Billboard
  • BA_VIEWER : Billboard
  • backAmbientColor : NBFMaterial
  • backColor : NBFScene
  • backDiffuseColor : NBFMaterial
  • backEmissiveColor : NBFMaterial
  • backFaceMode : NBFFaceAttribute
  • backImg : NBFScene
  • backOpacity : NBFMaterial
  • backSpecularColor : NBFMaterial
  • backSpecularExponent : NBFMaterial
  • balance() : CullData
  • BalanceTraverser() : BalanceTraverser
  • BaseRenderElement() : BaseRenderElement
  • beginEdit() : Handle< T, NullType >
  • beginOcclusionCullQuery() : RenderTraverser, GLTraverser
  • beginRead() : Handle< T, NullType >
  • Billboard() : Billboard
  • bindings : NBFTextureAttribute
  • bindShapeMatrix : NBFSkin
  • bindTextureAttributeItem() : TextureAttribute
  • BlendAttribute() : BlendAttribute
  • blocksAvailable() : Chunk
  • Bone() : Bone
  • bones : skin_t
  • Boxnt() : Boxnt
  • bricksName : NBFVolumeNode
  • BT_CHILDREN : BalanceTraverser
  • BT_VERTICES : BalanceTraverser
  • byteOrder : NBFHeader

- c -

  • calcNearFarDistances() : Camera
  • calculateBoundingBox() : VolumeNode, Transform, Switch, StrippedPrimitiveSet, Shape, Node, MeshedPrimitiveSet, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, Drawable
  • calculateBoundingSphere() : VolumeNode, Transform, Switch, StrippedPrimitiveSet, Shape, Node, MeshedPrimitiveSet, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, Drawable
  • calculateTangentSpace() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • calculatingStorageRequirements() : NBFSaveTraverser
  • callback() : PlugIn
  • CallbackServer() : CallbackServer
  • camera : NBFViewState
  • Camera() : Camera
  • cameraAnimations : NBFScene
  • cameras : NBFScene
  • castShadow : NBFLightSource
  • center : NBFLOD, trafo_t
  • CgFx() : CgFx
  • CGFX_STATE_MACHINE_GL : CgFxContext
  • CGFX_STATE_MACHINE_INVALID : CgFxContext
  • CgFxContext() : CgFxContext
  • CgFxEffect() : CgFxEffect
  • CgFxStateMachineEnum : CgFxContext
  • ChangeCallback() : ChangeCallback
  • changed() : ChangeCallback, CallbackServer
  • chars : sstr_t, str_t
  • checkClipPlanes() : RayIntersectTraverser
  • checkIntersection() : RayIntersectTraverser
  • children : NBFGroup, switchMask_t
  • Chunk() : Chunk
  • clear() : MapList, MapArray
  • clearCullTree() : ViewState
  • clearGeometries() : GeoNode
  • clearHeadLights() : Camera
  • clearRenderLists() : RenderTraverser
  • clearTexCoords() : GeoNode
  • clipPlanes : NBFGroup
  • ClipPlanesElement() : ClipPlanesElement
  • clone() : CullData, Handle< T, Handle< U, V > >, Handle< T, NullType >, Intersection
  • color : NBFUnlitColorAttribute
  • combinableCount : CombinableResult
  • combineMethod : NBFViewState
  • CombineTraverser() : CombineTraverser
  • compileProgram() : CgFxEffect
  • compressedFmt : NVSGTexImageFmt
  • constantAttenuation : NVSGLight
  • ConstOwnerIterator : OwnedObject
  • containsAnimation() : VertexAttributeSet, SkinnedTriangles, Scene, PrimitiveSet, Node, Drawable, AnimatedVertexAttributeSet
  • containsCgFx() : StateVariant, StateSet, StatePass, Scene, Node
  • containsHints() : Node
  • containsLight() : Scene, Node
  • containsLOD() : Node
  • containsTransparentGeometry() : Scene, Node
  • containsVolumeNode() : Node
  • context : PlugInCallback::InvalidFileInfo, PlugInCallback::IncompatibleFileInfo, PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo, PlugInCallback::EmptyTokenInfo
  • convert2DToCubeMap() : TextureImage
  • convertPixelFormat() : TextureImage
  • coordDim : texCoordSet_t
  • counts : NBFSkin
  • CPUSkinningProcessor() : CPUSkinningProcessor
  • createFromFile() : TextureImage, CgFx, CgFxEffect
  • createFromLump() : CgFx, CgFxEffect
  • createImage() : TextureImage
  • createMipmaps() : TextureImage
  • createNewRenderAreaID() : RenderArea
  • createOcclusionCullID() : RenderTraverser, GLTraverser
  • createTextureImageHandle() : TextureLoader, VolLoader
  • CT_GEONODE : CombineTraverser
  • CT_LOD : CombineTraverser
  • CT_LOD_RANGES : CombineTraverser
  • CT_PRIMITIVE_SET : CombineTraverser
  • CT_TRANSFORM : CombineTraverser
  • cullCode() : NodeHintsCullTraverser, FrustumCullTraverser, CullTraverser
  • CullData() : CullData
  • cullMode : NBFFaceAttribute
  • CullTraverser() : CullTraverser
  • currTech : NBFCgFx
  • cutoffAngle : NBFSpotLight

- d -

  • DALData() : DALData
  • dataType : texImage_t
  • dayLastModified : NBFHeader
  • deactivateClipPlane() : Group
  • dealloc() : Allocator, FixedAllocator, Chunk, NBFSaveTraverser
  • DECREASESPEED : WalkCameraManipulator, FlightCameraManipulator
  • decrementJointCount() : Transform
  • decrementMipmapUseCount() : TextureImage
  • deleteThis() : PlugIn, DALData, VolSaver, OBJSaver, NVSGSaver, NBFSaver, ILTexSaver, WRLLoader, VolLoader, PLYLoader, NVSGLoader, NVBLoader, NBFLoader, ILTexLoader
  • demandUpload() : TextureImage
  • denormalizedNormalsCount : DenormalizedNormalsResult
  • denormalizedNormalsNumber : DenormalizedNormalsResult
  • depth : texImage_t
  • DepthAttribute() : DepthAttribute
  • depthFunction : NBFDepthAttribute
  • depthTestingEnabled : NBFDepthAttribute
  • depthWritingEnabled : NBFDepthAttribute
  • destinationFunction : NBFBlendAttribute
  • DestrippingTraverser() : DestrippingTraverser
  • destroy() : GLMFCRAWnd, RenderArea, GLWinRenderArea
  • destroyOcclusionCullID() : RenderTraverser, GLTraverser
  • detectedVersion : PlugInCallback::IncompatibleFileInfo
  • determineActiveBricks() : VolumeNode
  • determineAnimationContainment() : Node, Group, GeoNode, FlipbookAnimation, AnimatedTransform
  • determineCgFxContainment() : VolumeNode, Switch, Node, Group, GeoNode
  • determineCullCode() : PerspectiveCamera, ParallelCamera, Camera
  • determineHintsContainment() : Switch, Node, Group
  • determineLightContainment() : Switch, Node, Group
  • determineLODContainment() : Switch, Node, LOD, Group
  • determineTransparencyContainment() : VolumeNode, Switch, Node, Group, GeoNode
  • determineVolumeNodeContainment() : VolumeNode, Switch, Node, Group
  • diffuse : NVSGMaterial, NVSGLight
  • diffuseColor : NBFLightSource
  • DirectedLight() : DirectedLight
  • direction : NVSGLight, NBFSpotLight, NBFDirectedLight, NBFCamera
  • disableHWFSAA() : GLWinRenderArea
  • doApply() : VertexUnifyTraverser, UnifyTraverser, ExclusiveTraverser, SharedTraverser, Traverser, SmoothTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, OptimizeTraverser, NormalizeTraverser, GLUploadTraverser, GLTraverser, FrustumCullTraverser, EliminateTraverser, DestrippingTraverser, CullTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • dofJitters : NBFViewState
  • dolly() : TrackballTransformManipulator, TrackballCameraManipulator
  • DOLLY1 : TrackballTransformManipulator
  • DOLLY2 : TrackballTransformManipulator, TrackballCameraManipulator
  • doRender() : RenderTraverser, GLUploadTraverser, GLTraverser
  • Drawable() : Drawable
  • drawables : geometrySet_t
  • dumpIntersectionList() : RayIntersectTraverser

- e -

  • effectChanged() : VolumeNode
  • EliminateTraverser() : EliminateTraverser
  • emission : NVSGMaterial
  • emptyCount : EmptyResult
  • enabled : NBFLightingAttribute, NBFLightSource
  • enabledMSAlpha : NBFAlphaTestAttribute
  • enableFlags : NBFVertexAttributeSet
  • enableHWFSAA() : GLWinRenderArea
  • encountered : PlugInCallback::UnexpectedTokenInfo
  • endEdit() : Handle< T, NullType >
  • EndImport() : NVNVB
  • endOcclusionCullQuery() : RenderTraverser, GLTraverser
  • endRead() : Handle< T, NullType >
  • enterCS() : Object
  • equivalentCount : EquivalenceResult
  • ET_GROUP : EliminateTraverser
  • ET_LOD : EliminateTraverser
  • ET_STATE_PASS : EliminateTraverser
  • ET_STATE_SET : EliminateTraverser
  • ET_STATE_VARIANT : EliminateTraverser
  • ET_TEXTURE_ATTRIBUTE : EliminateTraverser
  • ET_TEXTURE_ATTRIBUTE_ITEM : EliminateTraverser
  • evaluateAnimation() : SkinnedTriangles
  • evaluateCullTree() : Traverser
  • ExclusiveModelViewTraverser() : ExclusiveModelViewTraverser
  • ExclusiveTraverser() : ExclusiveTraverser
  • expected : PlugInCallback::UnexpectedTokenInfo
  • expectedVersion : PlugInCallback::IncompatibleFileInfo
  • ExtractGeometryTraverser() : ExtractGeometryTraverser

- f -

  • F_IMAGE_STREAM : TextureImage
  • F_NO_IMAGE_CREATION : TextureImage
  • F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD : TextureImage
  • F_SCALE_FILTER_BELL : TextureImage
  • F_SCALE_FILTER_BOX : TextureImage
  • F_SCALE_FILTER_BSPLINE : TextureImage
  • F_SCALE_FILTER_LANCZOS3 : TextureImage
  • F_SCALE_FILTER_TRIANGLE : TextureImage
  • F_SCALE_POT_ABOVE : TextureImage
  • F_SCALE_POT_BELOW : TextureImage
  • F_SCALE_POT_NEAREST : TextureImage
  • FaceAttribute() : FaceAttribute
  • falloffExponent : NBFSpotLight
  • farDist : NBFCamera
  • file : PlugInCallback::InvalidFileInfo, PlugInCallback::IncompatibleFileInfo, PlugInCallback::FileAccessFailedInfo, texImage_t
  • FileMapping() : FileMapping
  • findTerrainPosition() : WalkCameraManipulator
  • finishUpload() : TextureImage
  • FixedAllocator() : FixedAllocator
  • fixedPtFmt : NVSGTexImageFmt
  • flags : texImage_t
  • FlightCameraManipulator() : FlightCameraManipulator
  • FlipbookAnimation() : FlipbookAnimation
  • floatFmt : NVSGTexImageFmt
  • floats : tweak_t
  • fly() : FlightCameraManipulator
  • FLYBACKWARD : FlightCameraManipulator
  • FLYFORWARD : FlightCameraManipulator
  • focusDist : NBFCamera
  • forcePixelFormat() : GLWinRenderArea
  • forceTraversal() : AppTraverser
  • format() : TraceFunctor, Log
  • forward : NBFAnimation
  • FramedAnimation() : FramedAnimation
  • frameNumber : NVSGScene
  • freeMemory() : Chunk
  • fromFile : NBFCgFx
  • frontAmbientColor : NBFMaterial
  • frontDiffuseColor : NBFMaterial
  • frontEmissiveColor : NBFMaterial
  • frontFaceMode : NBFFaceAttribute
  • frontOpacity : NBFMaterial
  • frontSpecularColor : NBFMaterial
  • frontSpecularExponent : NBFMaterial
  • FrustumCullTraverser() : FrustumCullTraverser
  • fsaaJitters : NBFViewState

- g -

  • GCT_DL : RenderTraverser
  • GCT_NONE : RenderTraverser
  • GCT_VBO : RenderTraverser
  • generateNormals() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • generateTexCoords() : VertexAttributeSet, GeoNode
  • GeometryCacheTechnique : RenderTraverser
  • geometrySets : NBFGeoNode
  • GeoNode() : GeoNode
  • get() : Validated, RCObject_AutoPtr
  • getActive() : Switch
  • getActiveBricks() : VolumeNode
  • getActiveMask() : Switch
  • getActiveVariant() : StateSet
  • getActiveVariantKey() : StateSet
  • getAlignment() : MapMatrix, MapArray, Billboard
  • getAlphaFunction() : AlphaTestAttribute
  • getAmbientColor() : Scene, Material, LightSource
  • getAnalysis() : AnalyzeTraverser
  • getAnimation() : Bone, LightSource, FlipbookAnimation, AnimatedVertexAttributeSet, AnimatedTransform
  • getAnnotation() : Object
  • getAnnotationName() : CgFxEffect
  • getAnnotationTypeString() : CgFxEffect
  • getAnnotationValueSize() : CgFxEffect
  • getAppTraverser() : RenderArea
  • getArrayParameterElement() : CgFxEffect
  • getAspectRatio() : RenderArea, Camera
  • getAttenuation() : SpotLight, PointLight
  • getAttribute() : StateVariant, StateSet, StatePass
  • getAttributeByObjectCode() : StateVariant, StateSet, StatePass
  • getAttributeIndex() : StateVariant, StateSet, StatePass
  • getBackColor() : Scene
  • getBackFaceMode() : FaceAttribute
  • getBackImage() : Scene
  • getBalanceTargets() : BalanceTraverser
  • getBindShapeMatrix() : Skin
  • getBoolAnnotationValue() : CgFxEffect
  • getBoolParameterValue() : CgFxEffect
  • getBoolPassStateValue() : CgFxEffect
  • getBoolSamplerStateValue() : CgFxEffect
  • getBorderColor() : TextureAttributeItem
  • getBoundingBox() : Node, HighlightObject, Drawable
  • getBoundingSphere() : Node, HighlightObject, Drawable
  • getBrickBox() : VolumeBrick
  • getBrickData() : VolumeBrick
  • getBricksOverallSize() : VolumeNode
  • getBrickTextureSize() : VolumeNode
  • getButtonState() : MouseInput
  • getBytesPerPixel() : TextureImage
  • getBytesPerPlane() : TextureImage
  • getBytesPerScanLine() : TextureImage
  • getCamera() : ViewState, Scene
  • getCameraAnimation() : Scene
  • getCameraHeightAboveTerrain() : WalkCameraManipulator
  • getCenter() : LOD, Trafo, Spherent
  • getChild() : Group, CullData
  • getChildPositions() : Group
  • getClipPlane() : ClipPlanesElement, Group
  • getClipPlanes() : RenderElement, HighlightElement
  • getClipToModel() : TransformStack
  • getClipToView() : TransformStack
  • getCollectRenderElements() : RenderTraverser
  • getColor() : UnlitColorAttribute, HighlightEdges, HighlightBox
  • getColors() : VertexAttributeSet
  • getCombineTargets() : CombineTraverser
  • getContainmentFlags() : Node
  • getContainmentValidFlags() : Node
  • getContext() : CgFxEffect
  • getCounts() : Skin
  • getCreationFlags() : TextureImage
  • getCullCode() : CullData
  • getCullTraverser() : RenderArea
  • getCullTree() : ViewState
  • getCurrentCgFx() : RenderTraverser
  • getCurrentChild() : FlipbookAnimation
  • getCurrentDelta() : ViewState
  • getCurrentHints() : CullTraverser
  • getCurrentHintsContainment() : CullTraverser
  • getCurrentTechnique() : CgFxEffect
  • getCurrentTick() : ViewState
  • getCurrentValue() : LinearInterpolatedAnimation, KeyFramedAnimation, FramedAnimation, Animation
  • getCurrentX() : MouseInput
  • getCurrentY() : MouseInput
  • getCutoffAngle() : SpotLight
  • getData() : VertexAttribute, Map
  • getDataID() : VertexAttributeSet, TextureAttributeItem, StrippedPrimitiveSet, SkinnedTriangles, Object, MeshedPrimitiveSet, Material, IndependentPrimitiveSet, CgFx
  • getDepth() : TextureImage
  • getDepthFunction() : DepthAttribute
  • getDestinationFunction() : BlendAttribute
  • getDeviceAbstractionLinkData() : DALHost
  • getDiffuseColor() : Material, LightSource
  • getDirection() : SpotLight, DirectedLight, Camera
  • getDisplay() : GLContext
  • getDist() : Intersection
  • getDoFJitters() : ViewState
  • getDrawable() : Intersection, HighlightObject, GeoNode
  • getEffect() : CgFx
  • getEliminateTargets() : EliminateTraverser
  • getEmissiveColor() : Material
  • getEnabled() : LightingAttribute
  • getEnabledDuringMultiSampleAlpha() : AlphaTestAttribute
  • getEntrySize() : MapMatrix, MapArray
  • getEnvColor() : TextureAttributeItem
  • getEnvMode() : TextureAttributeItem
  • getEnvScale() : TextureAttributeItem
  • getEpsilon() : UnifyTraverser
  • getErrorMessage() : NVSGException
  • getFaceMode() : RenderTraverser
  • getFaces() : Triangles, Quads
  • getFalloffExponent() : SpotLight
  • getFarDistance() : Camera
  • getFieldOfView() : PerspectiveCamera
  • getFileInfo() : VolLoader
  • getFileName() : TextureImage, CgFxEffect
  • getFirstItem() : TextureAttribute
  • getFirstMaskIterator() : Switch
  • getFirstVariantIterator() : StateSet
  • getFloatAnnotationValue() : CgFxEffect
  • getFloatParameterValue() : CgFxEffect
  • getFloatPassStateValue() : CgFxEffect
  • getFloatSamplerStateValue() : CgFxEffect
  • getFocusDistance() : Camera
  • getFogCoords() : VertexAttributeSet
  • getFormat() : TextureImage
  • getFragmentProgram() : CgFxEffect
  • getFrameNumber() : Scene
  • getFrameValue() : Animation
  • getFromHead() : Path
  • getFromTail() : Path
  • getFrontClipPlane() : VolumeNode
  • getFrontFaceMode() : FaceAttribute
  • getFrontPlane() : VolumeBrick
  • getFSAAJitters() : ViewState
  • getGeometryCacheTechnique() : RenderTraverser
  • getGeometryProgram() : CgFxEffect
  • getGroup() : LightsElement, ClipPlanesElement
  • getHead() : Path
  • getHeadLight() : Camera
  • getHeight() : TextureImage, Map
  • getHigherLevelObjectCode() : Object
  • getHighlightObject() : HighlightElement, Drawable
  • getHints() : NodeHintsCullTraverser, Node
  • getHintsContainment() : Node
  • getHSensitivity() : WalkCameraManipulator, FlightCameraManipulator
  • getIgnoreNames() : OptimizeTraverser
  • getIncarnation() : ViewState, Object
  • getIndexOfMap() : MapMatrix, MapArray
  • getIndices() : Skin, IndependentPrimitiveSet
  • getIntAnnotationValue() : CgFxEffect
  • getIntensity() : LightSource
  • getInterface : PlugInServer
  • getIntersections() : RayIntersectTraverser
  • getIntParameterValue() : CgFxEffect
  • getIntPassStateValue() : CgFxEffect
  • getIntSamplerStateValue() : CgFxEffect
  • getInverse() : LightSource, Trafo
  • getInverseBindMatrix() : Skin
  • getInverseProjection() : PerspectiveCamera, ParallelCamera, Camera
  • getIsp() : Intersection
  • getJitters() : ViewState
  • getJittersCombineMethod() : ViewState
  • getJitterTechnique() : RenderTraverser
  • getJoint() : Skin
  • getKey() : KeyFramedAnimation
  • getKeyState() : KeyInput
  • getKeyStep() : KeyFramedAnimation
  • getKeySteps() : KeyFramedAnimation
  • getKeyValue() : KeyFramedAnimation
  • getKeyValues() : KeyFramedAnimation
  • getLastError() : FileMapping
  • getLastMaskIterator() : Switch
  • getLastRecentlyUsedDeviceAbstractionLinkData() : DALHost
  • getLastVariantIterator() : StateSet
  • getLastX() : MouseInput
  • getLastY() : MouseInput
  • getLength() : Path
  • getLight() : LightsElement, CgFxEffect
  • getLightAmbientValue() : CgFxEffect
  • getLightByName() : CgFxEffect
  • getLightBySemantic() : CgFxEffect
  • getLightConstantAttenuationValue() : CgFxEffect
  • getLightDiffuseValue() : CgFxEffect
  • getLightDirectionValue() : CgFxEffect
  • getLightLinearAttenuationValue() : CgFxEffect
  • getLightPositionValue() : CgFxEffect
  • getLightQuadraticAttenuationValue() : CgFxEffect
  • getLights() : RenderElement
  • getLightSource() : Group
  • getLightSpecularValue() : CgFxEffect
  • getLightSpotCutoffValue() : CgFxEffect
  • getLightSpotExponentValue() : CgFxEffect
  • getLineWidth() : RenderTraverser, HighlightEdges, HighlightBox
  • getLODRangeScale() : ViewState
  • getLODToUse() : LOD
  • getLower() : Boxnt
  • getLowerLeft() : MapObject
  • getMagFilterMode() : TextureAttributeItem
  • getMap() : MapMatrix, MapElement, MapArray
  • getMapList() : ViewState
  • getMapObject() : MapList
  • getMaskKey() : Switch
  • getMaterial() : CgFxEffect
  • getMaterialAmbientValue() : CgFxEffect
  • getMaterialDiffuseValue() : CgFxEffect
  • getMaterialEmissionValue() : CgFxEffect
  • getMaterialShininessValue() : CgFxEffect
  • getMaterialSpecularValue() : CgFxEffect
  • getMatrix() : TextureAttributeItem, Bone, Trafo
  • getMaximalNumberOfChildren() : BalanceTraverser
  • getMaximalNumberOfVertices() : BalanceTraverser
  • getMeshes() : MeshedPrimitiveSet
  • getMinFilterMode() : TextureAttributeItem
  • getMinimalLengths() : StrippingTraverser
  • getMipmapUseCount() : TextureImage
  • getModelToClip() : TransformStack
  • getModelToView() : TransformStack
  • getModelToWorld() : TransformStack, TransformElement, LightsElement, ClipPlanesElement
  • getModelToWorldMatrix() : Path
  • getName() : Object
  • getNearDistance() : Camera
  • getNearest() : RayIntersectTraverser
  • getNextItem() : TextureAttribute
  • getNextMaskIterator() : Switch
  • getNextVariantIterator() : StateSet
  • getNormal() : Planent
  • getNormalize() : AnimatedVertexAttributeSet
  • getNormalizeFlags() : AnimatedVertexAttributeSet
  • getNormals() : VertexAttributeSet
  • getNumberOfActive() : Switch
  • getNumberOfActiveClipPlanes() : Group
  • getNumberOfAnnotationValueComponents() : CgFxEffect
  • getNumberOfArrayParameterElements() : CgFxEffect
  • getNumberOfAttributes() : StateVariant, StateSet, StatePass
  • getNumberOfBytes() : TextureImage
  • getNumberOfCameraAnimations() : Scene
  • getNumberOfCameras() : Scene
  • getNumberOfChildren() : Group, CullData
  • getNumberOfClipPlanes() : ClipPlanesElement, Group
  • getNumberOfColors() : VertexAttributeSet
  • getNumberOfColumns() : MapMatrix
  • getNumberOfCullTraverser() : RenderArea
  • getNumberOfDoFJitters() : ViewState
  • getNumberOfDrawables() : GeoNode
  • getNumberOfFaces() : Triangles, Quads
  • getNumberOfFogCoords() : VertexAttributeSet
  • getNumberOfFSAAJitters() : ViewState
  • getNumberOfGeometries() : GeoNode
  • getNumberOfHeadLights() : Camera
  • getNumberOfHighlightObjects() : HighlightElement
  • getNumberOfImages() : TextureImage
  • getNumberOfIndices() : IndependentPrimitiveSet
  • getNumberOfInfluences() : Skin
  • getNumberOfIntersections() : RayIntersectTraverser
  • getNumberOfItems() : TextureAttribute
  • getNumberOfJitters() : ViewState
  • getNumberOfJoints() : Skin
  • getNumberOfKeys() : KeyFramedAnimation
  • getNumberOfLights() : LightsElement, CgFxEffect
  • getNumberOfLightSources() : Group
  • getNumberOfMapObjects() : MapList
  • getNumberOfMaps() : MapMatrix, MapArray
  • getNumberOfMasks() : Switch
  • getNumberOfMeshes() : MeshedPrimitiveSet
  • getNumberOfMipmaps() : TextureImage
  • getNumberOfNormals() : VertexAttributeSet
  • getNumberOfOwners() : OwnedObject
  • getNumberOfParameterAnnotations() : CgFxEffect
  • getNumberOfParameterValueComponents() : CgFxEffect
  • getNumberOfParents() : Node
  • getNumberOfPassAnnotations() : CgFxEffect
  • getNumberOfPasses() : StateVariant, StateSet, CgFxEffect
  • getNumberOfPassStateValueComponents() : CgFxEffect
  • getNumberOfPrimitiveSets() : RenderElement, Shape
  • getNumberOfProgramParameters() : CgFxEffect
  • getNumberOfProgramSamplers() : CgFxEffect
  • getNumberOfRanges() : LOD
  • getNumberOfSamplers() : CgFxEffect
  • getNumberOfSamplerStateValueComponents() : CgFxEffect
  • getNumberOfSecondaryColors() : VertexAttributeSet
  • getNumberOfSegments() : Lines
  • getNumberOfSkins() : SkinnedTriangles
  • getNumberOfStrips() : StrippedPrimitiveSet
  • getNumberOfStructParameterMembers() : CgFxEffect
  • getNumberOfTechniqueAnnotations() : CgFxEffect
  • getNumberOfTechniques() : CgFxEffect
  • getNumberOfTexCoords() : VertexAttributeSet
  • getNumberOfTransforms() : CgFxEffect
  • getNumberOfTweakables() : CgFxEffect
  • getNumberOfVariants() : StateSet
  • getNumberOfVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • getNumberOfVertices() : VertexAttributeSet
  • getObjectCode() : Object
  • getOcclusionCullID() : RenderElement
  • getOcclusionCullResult() : RenderTraverser, GLTraverser
  • getOffset() : Planent
  • getOffsets() : Skin
  • getOITMaxPasses() : RenderTraverser
  • getOITTechnique() : RenderTraverser
  • getOITThreshold() : RenderTraverser
  • getOpacity() : Material
  • getOrientation() : TextureAttributeItem, SpotLight, MapArray, DirectedLight, Camera, Trafo
  • getOverlapSize() : VolumeTexture
  • getOwner() : OwnedObject
  • getParameterAnnotation() : CgFxEffect
  • getParameterAnnotationByName() : CgFxEffect
  • getParameterByName() : CgFxEffect
  • getParameterBySemantic() : CgFxEffect
  • getParameterName() : CgFxEffect
  • getParameterSemantic() : CgFxEffect
  • getParameterTypeString() : CgFxEffect
  • getParameterValueAsFloat() : CgFxEffect
  • getParameterValueSize() : CgFxEffect
  • getParent() : TransformElement, Node
  • getPass() : StateVariant, StateSet, CgFxEffect
  • getPassAnnotation() : CgFxEffect
  • getPassAnnotationByName() : CgFxEffect
  • getPassByName() : CgFxEffect
  • getPassName() : CgFxEffect
  • getPath() : Intersection
  • getPaths() : SearchTraverser
  • getPickRay() : PerspectiveCamera, ParallelCamera, Camera
  • getPixels() : TextureImage
  • getPlugInSearchPath : PlugInServer
  • getPlugInterface : VolSaver, ILTexSaver, VolLoader, ILTexLoader
  • getPlugInterfaceType() : UPIID
  • getPlugSpecificIDString() : UPIID
  • getPointSize() : RenderTraverser
  • getPolygonOffsetFactor() : FaceAttribute
  • getPolygonOffsetUnits() : FaceAttribute
  • getPosition() : SpotLight, PointLight, MapObject, Camera
  • getPrimitiveIndex() : Intersection
  • getPrimitiveSet() : RenderElement, Shape
  • getProblems() : RenderArea
  • getProgramInputType() : CgFxEffect
  • getProgramOutputType() : CgFxEffect
  • getProgramParameter() : CgFxEffect
  • getProgramProfile() : CgFxEffect
  • getProgramSampler() : CgFxEffect
  • getProjection() : PerspectiveCamera, ParallelCamera, Camera
  • getPtr() : Vecnt, Matnnt
  • getRadius() : Spherent
  • getRangeLock() : LOD
  • getRanges() : LOD
  • getRasterOffsetX() : RenderTraverser
  • getRasterOffsetY() : RenderTraverser
  • getRefCnt() : BaseRenderElement
  • getRelation() : MapObject
  • getRenderTechnique() : RenderTraverser
  • getRenderTraverser() : RenderArea
  • getResults() : SearchTraverser
  • getRootNode() : Scene
  • getRotationAxis() : Billboard
  • getSampler() : CgFxEffect
  • getSamplerByName() : CgFxEffect
  • getSamplerByTextureParameterName() : CgFxEffect
  • getSamplerTexture() : CgFxEffect
  • getSamplerTextureFileName() : CgFxEffect
  • getSamplerTextureGPUFormat() : CgFxEffect
  • getSamplerTextureImage() : CgFxEffect
  • getSamplerTextureTarget() : CgFxEffect
  • getScaleOrientation() : Trafo
  • getScaling() : TextureAttributeItem, Trafo
  • getScene() : RenderArea, CgFxEffect
  • getSceneAmbientValue() : CgFxEffect
  • getSceneFrameNumberValue() : CgFxEffect
  • getSecondaryColors() : VertexAttributeSet
  • getSegments() : Lines
  • getShader() : VolumeNode
  • getShadowMapIntensity() : RenderTraverser
  • getShadowMapSize() : RenderTraverser
  • getShadowTechnique() : RenderTraverser
  • getSize() : Trackball, PointAttribute, MapObject, MapMatrix, MapElement, MapArray
  • getSizeOfColors() : VertexAttributeSet
  • getSizeOfTexCoords() : VertexAttributeSet
  • getSizeOfVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • getSkin() : PrimitiveSet
  • getSkinningProcessor() : AppTraverser
  • getSkinningType() : Skin
  • getSkins() : SkinnedTriangles
  • getSliceThickness() : VolumeTexture
  • getSortingPolicy() : RenderTraverser
  • getSourceCode() : CgFxEffect
  • getSourceFunction() : BlendAttribute
  • getSpacing() : MapMatrix, MapArray
  • getSpecularColor() : Material, LightSource
  • getSpecularExponent() : Material
  • getSpeed() : WalkCameraManipulator, FlightCameraManipulator
  • getSpeedIncreaseFactor() : WalkCameraManipulator, FlightCameraManipulator
  • getSquaredDistance() : RenderElement
  • getStackDepth() : TransformStack
  • getStartX() : MouseInput
  • getStartY() : MouseInput
  • getStateMachine() : CgFxContext
  • getStateSet() : GeoNode
  • getStateVariant() : RenderElement, VolumeBrick
  • getStepsPerUnit() : WRLLoader
  • getStepValue() : LinearInterpolatedAnimation, KeyFramedAnimation, FramedAnimation, Animation
  • getStepValues() : FramedAnimation
  • getStereoAutomaticEyeDistanceFactor() : ViewState
  • getStereoEyeDistance() : ViewState
  • getStippleFactor() : LineAttribute
  • getStipplePattern() : LineAttribute
  • getStringAnnotationValue() : CgFxEffect
  • getStringParameterValue() : CgFxEffect
  • getStrips() : StrippedPrimitiveSet
  • getStructParameterMember() : CgFxEffect
  • getStructParameterMemberByName() : CgFxEffect
  • getSubImagePixels() : TextureImage
  • getSuccess() : NBFSaveTraverser
  • getSupportWidth() : Lanczos3Filter, BSplineFilter, BellFilter, TriangleFilter, BoxFilter, ScaleFilter
  • getSwitchMask() : Switch
  • getTail() : Path
  • getTargetDistance() : ViewState
  • getTechnique() : CgFxEffect
  • getTechniqueAnnotation() : CgFxEffect
  • getTechniqueAnnotationByName() : CgFxEffect
  • getTechniqueByName() : CgFxEffect
  • getTechniqueIndex() : CgFxEffect
  • getTechniqueName() : CgFxEffect
  • getTexCoords() : VertexAttributeSet
  • getTexGenLinearPlane() : TextureAttributeItem
  • getTexGenMode() : TextureAttributeItem
  • getTextureAttributeItem() : TextureAttribute
  • getTextureFileName() : TextureAttributeItem
  • getTextureGenericGPUFormat() : GLTraverser
  • getTextureGPUFormat() : TextureImage
  • getTextureImage() : TextureAttributeItem
  • getTextureSizeLimit() : RenderTraverser
  • getTextureTarget() : TextureAttributeItem
  • getThreshold() : AlphaTestAttribute
  • getTopBrickTextureName() : VolumeNode
  • getTopLevelBrick() : VolumeNode
  • getTotalNumberOfBytes() : TextureImage
  • getTotalNumberOfIndices() : Skin
  • getTrafo() : Transform, Billboard, AnimatedTransform
  • getTransform() : TransformElement, RenderElement, HighlightElement, CgFxEffect
  • getTransformationMatrix() : LightSource
  • getTransformPath() : TransformManipulator
  • getTransformType() : CgFxEffect
  • getTranslation() : TextureAttributeItem, Trafo
  • getTransparencyTechnique() : RenderTraverser
  • getTraversalDirection() : MapMatrix, MapArray
  • getTreeModified() : OptimizeTraverser
  • getTweakable() : CgFxEffect
  • getTweakableByName() : CgFxEffect
  • getTweakableBySemantic() : CgFxEffect
  • getType() : TextureImage
  • getTypeOfColors() : VertexAttributeSet
  • getTypeOfFogCoords() : VertexAttributeSet
  • getTypeOfSecondaryColors() : VertexAttributeSet
  • getTypeOfTexCoords() : VertexAttributeSet
  • getTypeOfVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • getUnifyTargets() : UnifyTraverser
  • getUnpackAlignment() : TextureImage
  • getUpper() : Boxnt
  • getUpVector() : Camera
  • getUserData() : Object
  • getUserID() : DALData
  • getVariant() : StateSet
  • getVariantKey() : StateSet
  • getVersion() : GLFunctions
  • getVertexAttributeIndex() : NormalizeTraverser
  • getVertexAttributeSet() : PrimitiveSet
  • getVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • getVertexDataBytes() : VertexAttribute
  • getVertexDataCount() : VertexAttribute
  • getVertexDataSize() : VertexAttribute
  • getVertexDataType() : VertexAttribute
  • getVertexIndices() : Intersection
  • getVertexProgram() : CgFxEffect
  • getVertices() : VertexAttributeSet, HighlightBox
  • getViewportHeight() : RenderArea, ViewState
  • getViewportWidth() : RenderArea, ViewState
  • getViewState() : RenderArea
  • getViewToClip() : TransformStack
  • getViewToModel() : TransformStack
  • getViewToWorld() : TransformStack
  • getViewToWorldMatrix() : Camera
  • getVolumeTextureName() : VolumeNode
  • getVolumeTextureSize() : VolumeNode
  • getVoxelLimitFraction() : VolumeNode
  • getVSensitivity() : FlightCameraManipulator
  • getWeight() : Bone
  • getWeights() : Skin
  • getWidth() : TextureImage, Map, LineAttribute
  • getWindowOffset() : Camera
  • getWindowRegion() : Camera
  • getWindowSize() : Camera
  • getWorldIntersection() : RayIntersectTraverser
  • getWorldToModel() : TransformStack, TransformElement, LightsElement
  • getWorldToView() : TransformStack
  • getWorldToViewMatrix() : Camera
  • getWorldUpVector() : WalkCameraManipulator, FlightCameraManipulator
  • getWrapMode() : TextureAttributeItem
  • GLAccum : GLContext
  • GLActiveStencilFace : GLContext
  • GLActiveTexture : GLContext
  • GLActiveVarying : GLContext
  • GLAddSwapHintRect : GLContext
  • GLAlphaFunc : GLContext
  • GLAreProgramsResident : GLContext
  • GLAreTexturesResident : GLContext
  • GLArrayElement : GLContext
  • GLAttachObject : GLContext
  • GLAttachShader : GLContext
  • GLBegin : GLContext
  • GLBeginOcclusionQuery : GLContext
  • GLBeginQuery : GLContext
  • GLBeginTransformFeedback : GLContext
  • GLBindArraySet : GLContext
  • GLBindAttribLocation : GLContext
  • GLBindBuffer : GLContext
  • GLBindBufferBase : GLContext
  • GLBindBufferOffset : GLContext
  • GLBindBufferRange : GLContext
  • GLBindFragDataLocation : GLContext
  • GLBindFramebuffer : GLContext
  • GLBindProgram : GLContext
  • GLBindRenderbuffer : GLContext
  • GLBindTexture : GLContext
  • GLBitmap : GLContext
  • GLBlendColor : GLContext
  • GLBlendEquation : GLContext
  • GLBlendEquationSeparate : GLContext
  • GLBlendFunc : GLContext
  • GLBlendFuncSeparate : GLContext
  • GLBlitFramebuffer : GLContext
  • GLBufferData : GLContext
  • GLBufferSubData : GLContext
  • GLCallList : GLContext
  • GLCallLists : GLContext
  • GLCheckFramebufferStatus : GLContext
  • GLClampColor : GLContext
  • GLClear : GLContext
  • GLClearAccum : GLContext
  • GLClearColor : GLContext
  • GLClearColorIi : GLContext
  • GLClearColorIui : GLContext
  • GLClearDepth : GLContext
  • GLClearDepthd : GLContext
  • GLClearIndex : GLContext
  • GLClearStencil : GLContext
  • GLClientActiveTexture : GLContext
  • GLClipPlane : GLContext
  • GLColor3b : GLContext
  • GLColor3bv : GLContext
  • GLColor3d : GLContext
  • GLColor3dv : GLContext
  • GLColor3f : GLContext
  • GLColor3fv : GLContext
  • GLColor3h : GLContext
  • GLColor3hv : GLContext
  • GLColor3i : GLContext
  • GLColor3iv : GLContext
  • GLColor3s : GLContext
  • GLColor3sv : GLContext
  • GLColor3ub : GLContext
  • GLColor3ubv : GLContext
  • GLColor3ui : GLContext
  • GLColor3uiv : GLContext
  • GLColor3us : GLContext
  • GLColor3usv : GLContext
  • GLColor4b : GLContext
  • GLColor4bv : GLContext
  • GLColor4d : GLContext
  • GLColor4dv : GLContext
  • GLColor4f : GLContext
  • GLColor4fv : GLContext
  • GLColor4h : GLContext
  • GLColor4hv : GLContext
  • GLColor4i : GLContext
  • GLColor4iv : GLContext
  • GLColor4s : GLContext
  • GLColor4sv : GLContext
  • GLColor4ub : GLContext
  • GLColor4ubv : GLContext
  • GLColor4ui : GLContext
  • GLColor4uiv : GLContext
  • GLColor4us : GLContext
  • GLColor4usv : GLContext
  • GLColorMask : GLContext
  • GLColorMaskIndexed : GLContext
  • GLColorMaterial : GLContext
  • GLColorPointer : GLContext
  • GLColorSubTable : GLContext
  • GLColorTable : GLContext
  • GLColorTableParameterfv : GLContext
  • GLColorTableParameteriv : GLContext
  • GLCombinerInput : GLContext
  • GLCombinerOutput : GLContext
  • GLCombinerParameterf : GLContext
  • GLCombinerParameterfv : GLContext
  • GLCombinerParameteri : GLContext
  • GLCombinerParameteriv : GLContext
  • GLCombinerStageParameterfv : GLContext
  • GLCompileShader : GLContext
  • GLCompressedTexImage1D : GLContext
  • GLCompressedTexImage2D : GLContext
  • GLCompressedTexImage3D : GLContext
  • GLCompressedTexSubImage1D : GLContext
  • GLCompressedTexSubImage2D : GLContext
  • GLCompressedTexSubImage3D : GLContext
  • GLConvolutionFilter1D : GLContext
  • GLConvolutionFilter2D : GLContext
  • GLConvolutionParameterf : GLContext
  • GLConvolutionParameterfv : GLContext
  • GLConvolutionParameteri : GLContext
  • GLConvolutionParameteriv : GLContext
  • GLCopyColorSubTable : GLContext
  • GLCopyColorTable : GLContext
  • GLCopyConvolutionFilter1D : GLContext
  • GLCopyConvolutionFilter2D : GLContext
  • GLCopyPixels : GLContext
  • GLCopyTexImage1D : GLContext
  • GLCopyTexImage2D : GLContext
  • GLCopyTexSubImage1D : GLContext
  • GLCopyTexSubImage2D : GLContext
  • GLCopyTexSubImage3D : GLContext
  • GLCreateProgram : GLContext
  • GLCreateProgramObject : GLContext
  • GLCreateShader : GLContext
  • GLCreateShaderObject : GLContext
  • GLCullFace : GLContext
  • GLCullFaceLock : GLContext
  • GLCullFaceUnlock : GLContext
  • GLDeleteArraySets : GLContext
  • GLDeleteBuffers : GLContext
  • GLDeleteFences : GLContext
  • GLDeleteFramebuffers : GLContext
  • GLDeleteLists : GLContext
  • GLDeleteObject : GLContext
  • GLDeleteOcclusionQueries : GLContext
  • GLDeleteProgram : GLContext
  • GLDeletePrograms : GLContext
  • GLDeleteQueries : GLContext
  • GLDeleteRenderbuffers : GLContext
  • GLDeleteShader : GLContext
  • GLDeleteTextures : GLContext
  • GLDepthBounds : GLContext
  • GLDepthBoundsd : GLContext
  • GLDepthFunc : GLContext
  • GLDepthMask : GLContext
  • GLDepthRange : GLContext
  • GLDepthRanged : GLContext
  • GLDetachObject : GLContext
  • GLDetachShader : GLContext
  • GLDisable : GLContext
  • GLDisableAlphaTest : GLContext
  • GLDisableAutoNormal : GLContext
  • GLDisableBlend : GLContext
  • GLDisableClientState : GLContext
  • GLDisableClipPlane : GLContext
  • GLDisableColorArray : GLContext
  • GLDisableColorLogicOp : GLContext
  • GLDisableColorMaterial : GLContext
  • GLDisableCullFace : GLContext
  • GLDisableCullFaceLock : GLContext
  • GLDisableCullFaceUnlock : GLContext
  • GLDisableDepthTest : GLContext
  • GLDisableDither : GLContext
  • GLDisableFog : GLContext
  • GLDisableFogCoordinateArray : GLContext
  • GLDisableIndexed : GLContext
  • GLDisableLight : GLContext
  • GLDisableLighting : GLContext
  • GLDisableLightingLock : GLContext
  • GLDisableLightingUnlock : GLContext
  • GLDisableLineSmooth : GLContext
  • GLDisableLineStipple : GLContext
  • GLDisableLogicOp : GLContext
  • GLDisableNormalArray : GLContext
  • GLDisableNormalize : GLContext
  • GLDisablePointSmooth : GLContext
  • GLDisablePolygonOffsetFill : GLContext
  • GLDisablePolygonOffsetLine : GLContext
  • GLDisablePolygonOffsetPoint : GLContext
  • GLDisablePolygonSmooth : GLContext
  • GLDisablePolygonStipple : GLContext
  • GLDisableScissorTest : GLContext
  • GLDisableSecondaryColorArray : GLContext
  • GLDisableStencilTest : GLContext
  • GLDisableTexture : GLContext
  • GLDisableTextureCoordArray : GLContext
  • GLDisableTextureGen : GLContext
  • GLDisableVertexArray : GLContext
  • GLDisableVertexAttribArray : GLContext
  • GLDrawArrays : GLContext
  • GLDrawArraysInstanced : GLContext
  • GLDrawBuffer : GLContext
  • GLDrawBuffers : GLContext
  • GLDrawElements : GLContext
  • GLDrawElementsInstanced : GLContext
  • GLDrawPixels : GLContext
  • GLDrawRangeElements : GLContext
  • GLEdgeFlag : GLContext
  • GLEdgeFlagPointer : GLContext
  • GLEdgeFlagv : GLContext
  • GLEnable : GLContext
  • GLEnableAlphaTest : GLContext
  • GLEnableAutoNormal : GLContext
  • GLEnableBlend : GLContext
  • GLEnableClientState : GLContext
  • GLEnableClipPlane : GLContext
  • GLEnableColorArray : GLContext
  • GLEnableColorLogicOp : GLContext
  • GLEnableColorMaterial : GLContext
  • GLEnableCullFace : GLContext
  • GLEnableCullFaceLock : GLContext
  • GLEnableCullFaceUnlock : GLContext
  • GLEnableDepthTest : GLContext
  • GLEnableDither : GLContext
  • GLEnableFog : GLContext
  • GLEnableFogCoordinateArray : GLContext
  • GLEnableIndexed : GLContext
  • GLEnableLight : GLContext
  • GLEnableLighting : GLContext
  • GLEnableLineSmooth : GLContext
  • GLEnableLineStipple : GLContext
  • GLEnableLogicOp : GLContext
  • GLEnableNormalArray : GLContext
  • GLEnableNormalize : GLContext
  • GLEnablePointSmooth : GLContext
  • GLEnablePolygonOffsetFill : GLContext
  • GLEnablePolygonOffsetLine : GLContext
  • GLEnablePolygonOffsetPoint : GLContext
  • GLEnablePolygonSmooth : GLContext
  • GLEnablePolygonStipple : GLContext
  • GLEnableScissorTest : GLContext
  • GLEnableSecondaryColorArray : GLContext
  • GLEnableStencilTest : GLContext
  • GLEnableTexture : GLContext
  • GLEnableTextureCoordArray : GLContext
  • GLEnableTextureGen : GLContext
  • GLEnableVertexArray : GLContext
  • GLEnableVertexAttribArray : GLContext
  • GLEnd : GLContext
  • GLEndList : GLContext
  • GLEndOcclusionQuery : GLContext
  • GLEndQuery : GLContext
  • GLEndTransformFeedback : GLContext
  • GLEvalCoord1d : GLContext
  • GLEvalCoord1f : GLContext
  • GLEvalCoord2d : GLContext
  • GLEvalCoord2f : GLContext
  • GLEvalMesh1 : GLContext
  • GLEvalMesh2 : GLContext
  • GLEvalPoint1 : GLContext
  • GLEvalPoint2 : GLContext
  • GLExecuteProgram : GLContext
  • GLFeedbackBuffer : GLContext
  • GLFinalCombinerInput : GLContext
  • GLFinish : GLContext
  • GLFinishFence : GLContext
  • GLFlush : GLContext
  • GLFlushPixelDataRange : GLContext
  • GLFlushVertexArrayRange : GLContext
  • GLFogColor : GLContext
  • GLFogCoordd : GLContext
  • GLFogCoorddv : GLContext
  • GLFogCoordf : GLContext
  • GLFogCoordfv : GLContext
  • GLFogCoordh : GLContext
  • GLFogCoordhv : GLContext
  • GLFogCoordPointer : GLContext
  • GLFogDensity : GLContext
  • GLFogEnd : GLContext
  • GLFogf : GLContext
  • GLFogfv : GLContext
  • GLFogi : GLContext
  • GLFogiv : GLContext
  • GLFogMode : GLContext
  • GLFogStart : GLContext
  • GLFramebufferRenderbuffer : GLContext
  • GLFramebufferTexture : GLContext
  • GLFramebufferTexture1D : GLContext
  • GLFramebufferTexture2D : GLContext
  • GLFramebufferTexture3D : GLContext
  • GLFramebufferTextureFace : GLContext
  • GLFramebufferTextureLayer : GLContext
  • GLFrameTerminator : GLContext
  • GLFrontFace : GLContext
  • GLFrustum : GLContext
  • GLFunctions() : GLFunctions
  • GLGenArraySets : GLContext
  • GLGenBuffers : GLContext
  • GLGenerateMipmap : GLContext
  • GLGenFences : GLContext
  • GLGenFramebuffers : GLContext
  • GLGenLists : GLContext
  • GLGenOcclusionQueries : GLContext
  • GLGenPrograms : GLContext
  • GLGenQueries : GLContext
  • GLGenRenderbuffers : GLContext
  • GLGenTextures : GLContext
  • GLGetActiveAttrib : GLContext
  • GLGetActiveUniform : GLContext
  • GLGetActiveVarying : GLContext
  • GLGetAttachedObjects : GLContext
  • GLGetAttachedShaders : GLContext
  • GLGetAttribLocation : GLContext
  • GLGetBooleanIndexedv : GLContext
  • GLGetBooleanv : GLContext
  • GLGetBufferParameteriv : GLContext
  • GLGetBufferPointerv : GLContext
  • GLGetBufferSubData : GLContext
  • GLGetClipPlane : GLContext
  • GLGetColorTable : GLContext
  • GLGetColorTableParameterfv : GLContext
  • GLGetColorTableParameteriv : GLContext
  • GLGetCombinerInputParameterfv : GLContext
  • GLGetCombinerInputParameteriv : GLContext
  • GLGetCombinerOutputParameterfv : GLContext
  • GLGetCombinerOutputParameteriv : GLContext
  • GLGetCombinerStageParameterfv : GLContext
  • GLGetCompressedTexImage : GLContext
  • GLGetConvolutionFilter : GLContext
  • GLGetConvolutionParameterfv : GLContext
  • GLGetConvolutionParameteriv : GLContext
  • GLGetDoublev : GLContext
  • GLGetFenceiv : GLContext
  • GLGetFinalCombinerInputParameterfv : GLContext
  • GLGetFinalCombinerInputParameteriv : GLContext
  • GLGetFloatv : GLContext
  • GLGetFragDataLocation : GLContext
  • GLGetFramebufferAttachmentParameteriv : GLContext
  • GLGetHandle : GLContext
  • GLGetHistogram : GLContext
  • GLGetHistogramParameterfv : GLContext
  • GLGetHistogramParameteriv : GLContext
  • GLGetInfoLog : GLContext
  • GLGetIntegerIndexedv : GLContext
  • GLGetIntegerv : GLContext
  • GLGetLightfv : GLContext
  • GLGetLightiv : GLContext
  • GLGetMapdv : GLContext
  • GLGetMapfv : GLContext
  • GLGetMapiv : GLContext
  • GLGetMaterialfv : GLContext
  • GLGetMaterialiv : GLContext
  • GLGetMaxTexCoords : GLContext
  • GLGetMaxTexImageUnits : GLContext
  • GLGetMaxTexUnits : GLContext
  • GLGetMinmax : GLContext
  • GLGetMinmaxParameterfv : GLContext
  • GLGetMinmaxParameteriv : GLContext
  • GLGetObjectParameterfv : GLContext
  • GLGetObjectParameteriv : GLContext
  • GLGetOcclusionQueryiv : GLContext
  • GLGetOcclusionQueryuiv : GLContext
  • GLGetPixelMapfv : GLContext
  • GLGetPixelMapuiv : GLContext
  • GLGetPixelMapusv : GLContext
  • GLGetPointerv : GLContext
  • GLGetPolygonStipple : GLContext
  • GLGetProgramEnvParameterdv : GLContext
  • GLGetProgramEnvParameterfv : GLContext
  • GLGetProgramEnvParameterIiv : GLContext
  • GLGetProgramEnvParameterIuiv : GLContext
  • GLGetProgramInfoLog : GLContext
  • GLGetProgramiv : GLContext
  • GLGetProgramLocalParameterdv : GLContext
  • GLGetProgramLocalParameterfv : GLContext
  • GLGetProgramLocalParameterIiv : GLContext
  • GLGetProgramLocalParameterIuiv : GLContext
  • GLGetProgramNamedParameterdv : GLContext
  • GLGetProgramNamedParameterfv : GLContext
  • GLGetProgramParameterdv : GLContext
  • GLGetProgramParameterfv : GLContext
  • GLGetProgramString : GLContext
  • GLGetQueryiv : GLContext
  • GLGetQueryObjecti64v : GLContext
  • GLGetQueryObjectiv : GLContext
  • GLGetQueryObjectui64v : GLContext
  • GLGetQueryObjectuiv : GLContext
  • GLGetRenderbufferParameteriv : GLContext
  • GLGetSeparableFilter : GLContext
  • GLGetShaderInfoLog : GLContext
  • GLGetShaderiv : GLContext
  • GLGetShaderSource : GLContext
  • GLGetString : GLContext
  • GLGetTexEnvfv : GLContext
  • GLGetTexEnviv : GLContext
  • GLGetTexGendv : GLContext
  • GLGetTexGenfv : GLContext
  • GLGetTexGeniv : GLContext
  • GLGetTexImage : GLContext
  • GLGetTexImageFmt : GLContext
  • GLGetTexLevelParameterfv : GLContext
  • GLGetTexLevelParameteriv : GLContext
  • GLGetTexParameterfv : GLContext
  • GLGetTexParameterIiv : GLContext
  • GLGetTexParameterIuiv : GLContext
  • GLGetTexParameteriv : GLContext
  • GLGetTexWrapMode : GLContext
  • GLGetTrackMatrixiv : GLContext
  • GLGetTransformFeedbackVarying : GLContext
  • GLGetUniformBufferSize : GLContext
  • GLGetUniformfv : GLContext
  • GLGetUniformiv : GLContext
  • GLGetUniformLocation : GLContext
  • GLGetUniformOffset : GLContext
  • GLGetUniformuiv : GLContext
  • GLGetVaryingLocation : GLContext
  • GLGetVersion : GLContext
  • GLGetVertexAttribdv : GLContext
  • GLGetVertexAttribfv : GLContext
  • GLGetVertexAttribIiv : GLContext
  • GLGetVertexAttribIuiv : GLContext
  • GLGetVertexAttribiv : GLContext
  • GLGetVertexAttribPointerv : GLContext
  • GLHint : GLContext
  • GLHistogram : GLContext
  • GLIndexd : GLContext
  • GLIndexf : GLContext
  • GLIndexi : GLContext
  • GLIndexMask : GLContext
  • GLIndexPointer : GLContext
  • GLIndexs : GLContext
  • GLIndexub : GLContext
  • GLInitNames : GLContext
  • GLInterleavedArrays : GLContext
  • GLIsArraySet : GLContext
  • GLIsBuffer : GLContext
  • GLIsEnabled : GLContext
  • GLIsEnabledAlphaTest : GLContext
  • GLIsEnabledAutoNormal : GLContext
  • GLIsEnabledBlend : GLContext
  • GLIsEnabledClipPlane : GLContext
  • GLIsEnabledColorLogicOp : GLContext
  • GLIsEnabledColorMaterial : GLContext
  • GLIsEnabledCullFace : GLContext
  • GLIsEnabledDepthTest : GLContext
  • GLIsEnabledDither : GLContext
  • GLIsEnabledFog : GLContext
  • GLIsEnabledIndexed : GLContext
  • GLIsEnabledLight : GLContext
  • GLIsEnabledLighting : GLContext
  • GLIsEnabledLineSmooth : GLContext
  • GLIsEnabledLineStipple : GLContext
  • GLIsEnabledLogicOp : GLContext
  • GLIsEnabledNormalize : GLContext
  • GLIsEnabledPointSmooth : GLContext
  • GLIsEnabledPolygonOffsetFill : GLContext
  • GLIsEnabledPolygonOffsetLine : GLContext
  • GLIsEnabledPolygonOffsetPoint : GLContext
  • GLIsEnabledPolygonSmooth : GLContext
  • GLIsEnabledPolygonStipple : GLContext
  • GLIsEnabledScissorTest : GLContext
  • GLIsEnabledStencilTest : GLContext
  • GLIsEnabledTexture : GLContext
  • GLIsEnabledTextureGen : GLContext
  • GLIsExtensionAvailable : GLContext
  • GLIsExtensionExported : GLContext
  • GLIsFence : GLContext
  • GLIsFramebuffer : GLContext
  • GLIsList : GLContext
  • GLIsOcclusionQuery : GLContext
  • GLIsProgram : GLContext
  • GLIsQuery : GLContext
  • GLIsRenderbuffer : GLContext
  • GLIsShader : GLContext
  • GLIsTexture : GLContext
  • GLLightAmbient : GLContext
  • GLLightConstantAttenuation : GLContext
  • GLLightDiffuse : GLContext
  • GLLightf : GLContext
  • GLLightfv : GLContext
  • GLLighti : GLContext
  • GLLightiv : GLContext
  • GLLightLinearAttenuation : GLContext
  • GLLightModelAmbient : GLContext
  • GLLightModelf : GLContext
  • GLLightModelfv : GLContext
  • GLLightModeli : GLContext
  • GLLightModeliv : GLContext
  • GLLightModelLocalViewer : GLContext
  • GLLightModelTwoSide : GLContext
  • GLLightModelTwoSideLock : GLContext
  • GLLightModelTwoSideUnlock : GLContext
  • GLLightPosition : GLContext
  • GLLightQuadraticAttenuation : GLContext
  • GLLightSpecular : GLContext
  • GLLightSpotCutoff : GLContext
  • GLLightSpotDirection : GLContext
  • GLLightSpotExponent : GLContext
  • GLLineStipple : GLContext
  • GLLineWidth : GLContext
  • GLLinkProgram : GLContext
  • GLListBase : GLContext
  • GLLoadIdentity : GLContext
  • GLLoadMatrixd : GLContext
  • GLLoadMatrixf : GLContext
  • GLLoadName : GLContext
  • GLLoadProgram : GLContext
  • GLLoadTransposedMatrixd : GLContext
  • GLLoadTransposeMatrixf : GLContext
  • GLLockArrays : GLContext
  • GLLogicOp : GLContext
  • GLMap1d : GLContext
  • GLMap1f : GLContext
  • GLMap2d : GLContext
  • GLMap2f : GLContext
  • GLMapBuffer : GLContext
  • GLMapGrid1d : GLContext
  • GLMapGrid1f : GLContext
  • GLMapGrid2d : GLContext
  • GLMapGrid2f : GLContext
  • GLMaterialAmbient : GLContext
  • GLMaterialAmbientBack : GLContext
  • GLMaterialAmbientFront : GLContext
  • GLMaterialAmbientFrontAndBack : GLContext
  • GLMaterialDiffuse : GLContext
  • GLMaterialDiffuseBack : GLContext
  • GLMaterialDiffuseFront : GLContext
  • GLMaterialDiffuseFrontAndBack : GLContext
  • GLMaterialEmission : GLContext
  • GLMaterialEmissionBack : GLContext
  • GLMaterialEmissionFront : GLContext
  • GLMaterialEmissionFrontAndBack : GLContext
  • GLMaterialf : GLContext
  • GLMaterialfv : GLContext
  • GLMateriali : GLContext
  • GLMaterialiv : GLContext
  • GLMaterialShininess : GLContext
  • GLMaterialShininessBack : GLContext
  • GLMaterialShininessFront : GLContext
  • GLMaterialShininessFrontAndBack : GLContext
  • GLMaterialSpecular : GLContext
  • GLMaterialSpecularBack : GLContext
  • GLMaterialSpecularFront : GLContext
  • GLMaterialSpecularFrontAndBack : GLContext
  • GLMatrixMode : GLContext
  • GLMinmax : GLContext
  • GLMultiDrawArrays : GLContext
  • GLMultiDrawElements : GLContext
  • GLMultiTexCoord1d : GLContext
  • GLMultiTexCoord1dv : GLContext
  • GLMultiTexCoord1f : GLContext
  • GLMultiTexCoord1fv : GLContext
  • GLMultiTexCoord1h : GLContext
  • GLMultiTexCoord1hv : GLContext
  • GLMultiTexCoord1i : GLContext
  • GLMultiTexCoord1iv : GLContext
  • GLMultiTexCoord1s : GLContext
  • GLMultiTexCoord1sv : GLContext
  • GLMultiTexCoord2d : GLContext
  • GLMultiTexCoord2dv : GLContext
  • GLMultiTexCoord2f : GLContext
  • GLMultiTexCoord2fv : GLContext
  • GLMultiTexCoord2h : GLContext
  • GLMultiTexCoord2hv : GLContext
  • GLMultiTexCoord2i : GLContext
  • GLMultiTexCoord2iv : GLContext
  • GLMultiTexCoord2s : GLContext
  • GLMultiTexCoord2sv : GLContext
  • GLMultiTexCoord3d : GLContext
  • GLMultiTexCoord3dv : GLContext
  • GLMultiTexCoord3f : GLContext
  • GLMultiTexCoord3fv : GLContext
  • GLMultiTexCoord3h : GLContext
  • GLMultiTexCoord3hv : GLContext
  • GLMultiTexCoord3i : GLContext
  • GLMultiTexCoord3iv : GLContext
  • GLMultiTexCoord3s : GLContext
  • GLMultiTexCoord3sv : GLContext
  • GLMultiTexCoord4d : GLContext
  • GLMultiTexCoord4dv : GLContext
  • GLMultiTexCoord4f : GLContext
  • GLMultiTexCoord4fv : GLContext
  • GLMultiTexCoord4h : GLContext
  • GLMultiTexCoord4hv : GLContext
  • GLMultiTexCoord4i : GLContext
  • GLMultiTexCoord4iv : GLContext
  • GLMultiTexCoord4s : GLContext
  • GLMultiTexCoord4sv : GLContext
  • GLMultiTexCoordPointer : GLContext
  • GLMultMatrixd : GLContext
  • GLMultMatrixf : GLContext
  • GLMultTransposeMatrixd : GLContext
  • GLMultTransposeMatrixf : GLContext
  • GLNewList : GLContext
  • GLNormal3b : GLContext
  • GLNormal3bv : GLContext
  • GLNormal3d : GLContext
  • GLNormal3dv : GLContext
  • GLNormal3f : GLContext
  • GLNormal3fv : GLContext
  • GLNormal3h : GLContext
  • GLNormal3hv : GLContext
  • GLNormal3i : GLContext
  • GLNormal3iv : GLContext
  • GLNormal3s : GLContext
  • GLNormal3sv : GLContext
  • GLNormalPointer : GLContext
  • GLObjects() : GLObjects
  • GLOrtho : GLContext
  • GLPassThrough : GLContext
  • GLPixelDataRange : GLContext
  • GLPixelMapfv : GLContext
  • GLPixelMapuiv : GLContext
  • GLPixelMapusv : GLContext
  • GLPixelStoref : GLContext
  • GLPixelStorei : GLContext
  • GLPixelTransferf : GLContext
  • GLPixelTransferi : GLContext
  • GLPixelZoom : GLContext
  • GLPointParameterf : GLContext
  • GLPointParameterfv : GLContext
  • GLPointParameteri : GLContext
  • GLPointParameteriv : GLContext
  • GLPointSize : GLContext
  • GLPolygonMode : GLContext
  • GLPolygonModeBack : GLContext
  • GLPolygonModeFront : GLContext
  • GLPolygonModeFrontAndBack : GLContext
  • GLPolygonModeLock : GLContext
  • GLPolygonModeUnlock : GLContext
  • GLPolygonOffset : GLContext
  • GLPolygonStipple : GLContext
  • GLPopAttrib : GLContext
  • GLPopClientAttrib : GLContext
  • GLPopMatrix : GLContext
  • GLPopName : GLContext
  • GLPrimitiveRestart : GLContext
  • GLPrimitiveRestartIndex : GLContext
  • GLPrioritizeTextures : GLContext
  • GLProgramBufferParametersfv : GLContext
  • GLProgramBufferParametersIiv : GLContext
  • GLProgramBufferParametersIuiv : GLContext
  • GLProgramEnvParameter4d : GLContext
  • GLProgramEnvParameter4dv : GLContext
  • GLProgramEnvParameter4f : GLContext
  • GLProgramEnvParameter4fv : GLContext
  • GLProgramEnvParameterI4i : GLContext
  • GLProgramEnvParameterI4iv : GLContext
  • GLProgramEnvParameterI4ui : GLContext
  • GLProgramEnvParameterI4uiv : GLContext
  • GLProgramEnvParameters4fv : GLContext
  • GLProgramEnvParametersI4iv : GLContext
  • GLProgramEnvParametersI4uiv : GLContext
  • GLProgramLocalParameter4d : GLContext
  • GLProgramLocalParameter4dv : GLContext
  • GLProgramLocalParameter4f : GLContext
  • GLProgramLocalParameter4fv : GLContext
  • GLProgramLocalParameterI4i : GLContext
  • GLProgramLocalParameterI4iv : GLContext
  • GLProgramLocalParameterI4ui : GLContext
  • GLProgramLocalParameterI4uiv : GLContext
  • GLProgramLocalParameters4fv : GLContext
  • GLProgramLocalParametersI4iv : GLContext
  • GLProgramLocalParametersI4uiv : GLContext
  • GLProgramNamedParameter4d : GLContext
  • GLProgramNamedParameter4dv : GLContext
  • GLProgramNamedParameter4f : GLContext
  • GLProgramNamedParameter4fv : GLContext
  • GLProgramParameter4d : GLContext
  • GLProgramParameter4dv : GLContext
  • GLProgramParameter4f : GLContext
  • GLProgramParameter4fv : GLContext
  • GLProgramParameteri : GLContext
  • GLProgramParameters4dv : GLContext
  • GLProgramParameters4fv : GLContext
  • GLProgramString : GLContext
  • GLProgramVertexLimit : GLContext
  • GLPushAttrib : GLContext
  • GLPushClientAttrib : GLContext
  • GLPushMatrix : GLContext
  • GLPushName : GLContext
  • GLRasterPos2d : GLContext
  • GLRasterPos2f : GLContext
  • GLRasterPos2i : GLContext
  • GLRasterPos2s : GLContext
  • GLRasterPos3d : GLContext
  • GLRasterPos3f : GLContext
  • GLRasterPos3i : GLContext
  • GLRasterPos3s : GLContext
  • GLRasterPos4d : GLContext
  • GLRasterPos4f : GLContext
  • GLRasterPos4i : GLContext
  • GLRasterPos4s : GLContext
  • GLReadBuffer : GLContext
  • GLReadPixels : GLContext
  • GLRectd : GLContext
  • GLRectf : GLContext
  • GLRecti : GLContext
  • GLRects : GLContext
  • GLRenderbufferStorage : GLContext
  • GLRenderbufferStorageMultisample : GLContext
  • GLRenderbufferStorageMultisampleCoverage : GLContext
  • GLRenderMode : GLContext
  • GLRequestResidentPrograms : GLContext
  • GLResetAlphaFunc : GLContext
  • GLResetAlphaTest : GLContext
  • GLResetAutoNormal : GLContext
  • GLResetBlend : GLContext
  • GLResetBlendFunc : GLContext
  • GLResetBlendFuncSeparate : GLContext
  • GLResetClearColor : GLContext
  • GLResetClearDepth : GLContext
  • GLResetClearStencil : GLContext
  • GLResetClipPlane : GLContext
  • GLResetClipPlaneEquation : GLContext
  • GLResetColorLogicOp : GLContext
  • GLResetColorMask : GLContext
  • GLResetColorMaterial : GLContext
  • GLResetColorMaterialMode : GLContext
  • GLResetCullFace : GLContext
  • GLResetCullFaceMode : GLContext
  • GLResetDepthFunc : GLContext
  • GLResetDepthMask : GLContext
  • GLResetDepthRange : GLContext
  • GLResetDepthTest : GLContext
  • GLResetDither : GLContext
  • GLResetFog : GLContext
  • GLResetFogColor : GLContext
  • GLResetFogDensity : GLContext
  • GLResetFogEnd : GLContext
  • GLResetFogMode : GLContext
  • GLResetFogStart : GLContext
  • GLResetFrontFace : GLContext
  • GLResetHistogram : GLContext
  • GLResetLight : GLContext
  • GLResetLightAmbient : GLContext
  • GLResetLightConstantAttenuation : GLContext
  • GLResetLightDiffuse : GLContext
  • GLResetLighting : GLContext
  • GLResetLightLinearAttenuation : GLContext
  • GLResetLightModelAmbient : GLContext
  • GLResetLightModelLocalViewer : GLContext
  • GLResetLightModelTwoSide : GLContext
  • GLResetLightPosition : GLContext
  • GLResetLightQuadraticAttenuation : GLContext
  • GLResetLightSpecular : GLContext
  • GLResetLightSpotCutoff : GLContext
  • GLResetLightSpotDirection : GLContext
  • GLResetLightSpotExponent : GLContext
  • GLResetLineSmooth : GLContext
  • GLResetLineStipple : GLContext
  • GLResetLineStippleDefinition : GLContext
  • GLResetLineWidth : GLContext
  • GLResetLogicOp : GLContext
  • GLResetMaterialAmbientBack : GLContext
  • GLResetMaterialAmbientFront : GLContext
  • GLResetMaterialAmbientFrontAndBack : GLContext
  • GLResetMaterialDiffuseBack : GLContext
  • GLResetMaterialDiffuseFront : GLContext
  • GLResetMaterialDiffuseFrontAndBack : GLContext
  • GLResetMaterialEmissionBack : GLContext
  • GLResetMaterialEmissionFront : GLContext
  • GLResetMaterialEmissionFrontAndBack : GLContext
  • GLResetMaterialShininessBack : GLContext
  • GLResetMaterialShininessFront : GLContext
  • GLResetMaterialShininessFrontAndBack : GLContext
  • GLResetMaterialSpecularBack : GLContext
  • GLResetMaterialSpecularFront : GLContext
  • GLResetMaterialSpecularFrontAndBack : GLContext
  • GLResetMinmax : GLContext
  • GLResetNormalize : GLContext
  • GLResetPointSize : GLContext
  • GLResetPointSmooth : GLContext
  • GLResetPolygonModeBack : GLContext
  • GLResetPolygonModeFront : GLContext
  • GLResetPolygonModeFrontAndBack : GLContext
  • GLResetPolygonOffset : GLContext
  • GLResetPolygonOffsetFill : GLContext
  • GLResetPolygonOffsetLine : GLContext
  • GLResetPolygonOffsetPoint : GLContext
  • GLResetPolygonSmooth : GLContext
  • GLResetPolygonStipple : GLContext
  • GLResetScissor : GLContext
  • GLResetScissorTest : GLContext
  • GLResetShadeModel : GLContext
  • GLResetStencilFunc : GLContext
  • GLResetStencilMask : GLContext
  • GLResetStencilOp : GLContext
  • GLResetStencilTest : GLContext
  • GLResetTexture : GLContext
  • GLRotated : GLContext
  • GLRotatef : GLContext
  • GLSampleCoverage : GLContext
  • GLScaled : GLContext
  • GLScalef : GLContext
  • GLScissor : GLContext
  • GLSecondaryColor3b : GLContext
  • GLSecondaryColor3bv : GLContext
  • GLSecondaryColor3d : GLContext
  • GLSecondaryColor3dv : GLContext
  • GLSecondaryColor3f : GLContext
  • GLSecondaryColor3fv : GLContext
  • GLSecondaryColor3h : GLContext
  • GLSecondaryColor3hv : GLContext
  • GLSecondaryColor3i : GLContext
  • GLSecondaryColor3iv : GLContext
  • GLSecondaryColor3s : GLContext
  • GLSecondaryColor3sv : GLContext
  • GLSecondaryColor3ub : GLContext
  • GLSecondaryColor3ubv : GLContext
  • GLSecondaryColor3ui : GLContext
  • GLSecondaryColor3uiv : GLContext
  • GLSecondaryColor3us : GLContext
  • GLSecondaryColor3usv : GLContext
  • GLSecondaryColorPointer : GLContext
  • GLSelectBuffer : GLContext
  • GLSelectTexture : GLContext
  • GLSelectTextureCoordSet : GLContext
  • GLSeparableFilter2D : GLContext
  • GLSetFence : GLContext
  • GLSetWindowStereoMode : GLContext
  • GLShadeModel : GLContext
  • GLShaderSource : GLContext
  • GLStencilClearTag : GLContext
  • GLStencilFunc : GLContext
  • GLStencilFuncSeparate : GLContext
  • GLStencilMask : GLContext
  • GLStencilMaskSeparate : GLContext
  • GLStencilOp : GLContext
  • GLStencilOpSeparate : GLContext
  • GLStringMarker : GLContext
  • GLTestFence : GLContext
  • GLTexBuffer : GLContext
  • GLTexCoord1d : GLContext
  • GLTexCoord1dv : GLContext
  • GLTexCoord1f : GLContext
  • GLTexCoord1fv : GLContext
  • GLTexCoord1h : GLContext
  • GLTexCoord1hv : GLContext
  • GLTexCoord1i : GLContext
  • GLTexCoord1iv : GLContext
  • GLTexCoord1s : GLContext
  • GLTexCoord1sv : GLContext
  • GLTexCoord2d : GLContext
  • GLTexCoord2dv : GLContext
  • GLTexCoord2f : GLContext
  • GLTexCoord2fv : GLContext
  • GLTexCoord2h : GLContext
  • GLTexCoord2hv : GLContext
  • GLTexCoord2i : GLContext
  • GLTexCoord2iv : GLContext
  • GLTexCoord2s : GLContext
  • GLTexCoord2sv : GLContext
  • GLTexCoord3d : GLContext
  • GLTexCoord3dv : GLContext
  • GLTexCoord3f : GLContext
  • GLTexCoord3fv : GLContext
  • GLTexCoord3h : GLContext
  • GLTexCoord3hv : GLContext
  • GLTexCoord3i : GLContext
  • GLTexCoord3iv : GLContext
  • GLTexCoord3s : GLContext
  • GLTexCoord3sv : GLContext
  • GLTexCoord4d : GLContext
  • GLTexCoord4dv : GLContext
  • GLTexCoord4f : GLContext
  • GLTexCoord4fv : GLContext
  • GLTexCoord4h : GLContext
  • GLTexCoord4hv : GLContext
  • GLTexCoord4i : GLContext
  • GLTexCoord4iv : GLContext
  • GLTexCoord4s : GLContext
  • GLTexCoord4sv : GLContext
  • GLTexCoordPointer : GLContext
  • GLTexEnvf : GLContext
  • GLTexEnvfv : GLContext
  • GLTexEnvi : GLContext
  • GLTexEnviv : GLContext
  • GLTexGend : GLContext
  • GLTexGenf : GLContext
  • GLTexGenfv : GLContext
  • GLTexGeni : GLContext
  • GLTexImage1D : GLContext
  • GLTexImage2D : GLContext
  • GLTexImage3D : GLContext
  • GLTexParameterf : GLContext
  • GLTexParameterfv : GLContext
  • GLTexParameteri : GLContext
  • GLTexParameterIiv : GLContext
  • GLTexParameterIuiv : GLContext
  • GLTexParameteriv : GLContext
  • GLTexSubImage1D : GLContext
  • GLTexSubImage2D : GLContext
  • GLTexSubImage3D : GLContext
  • GLTextureBorderColor : GLContext
  • GLTextureEnvColor : GLContext
  • GLTextureEnvMode : GLContext
  • GLTextureMagFilter : GLContext
  • GLTextureMinFilter : GLContext
  • GLTextureWrapR : GLContext
  • GLTextureWrapS : GLContext
  • GLTextureWrapT : GLContext
  • GLTrackMatrix : GLContext
  • GLTransformFeedbackAttribs : GLContext
  • GLTransformFeedbackVaryings : GLContext
  • GLTranslated : GLContext
  • GLTranslatef : GLContext
  • GLTraverser() : GLTraverser
  • GLUniform1f : GLContext
  • GLUniform1fv : GLContext
  • GLUniform1i : GLContext
  • GLUniform1iv : GLContext
  • GLUniform1ui : GLContext
  • GLUniform1uiv : GLContext
  • GLUniform2f : GLContext
  • GLUniform2fv : GLContext
  • GLUniform2i : GLContext
  • GLUniform2iv : GLContext
  • GLUniform2ui : GLContext
  • GLUniform2uiv : GLContext
  • GLUniform3f : GLContext
  • GLUniform3fv : GLContext
  • GLUniform3i : GLContext
  • GLUniform3iv : GLContext
  • GLUniform3ui : GLContext
  • GLUniform3uiv : GLContext
  • GLUniform4f : GLContext
  • GLUniform4fv : GLContext
  • GLUniform4i : GLContext
  • GLUniform4iv : GLContext
  • GLUniform4ui : GLContext
  • GLUniform4uiv : GLContext
  • GLUniformBuffer : GLContext
  • GLUniformMatrix2fv : GLContext
  • GLUniformMatrix2x3fv : GLContext
  • GLUniformMatrix2x4fv : GLContext
  • GLUniformMatrix3fv : GLContext
  • GLUniformMatrix3x2fv : GLContext
  • GLUniformMatrix3x4fv : GLContext
  • GLUniformMatrix4fv : GLContext
  • GLUniformMatrix4x2fv : GLContext
  • GLUniformMatrix4x3fv : GLContext
  • GLUnlockArrays : GLContext
  • GLUnmapBuffer : GLContext
  • GLUploadTraverser() : GLUploadTraverser
  • GLUseProgram : GLContext
  • GLUseProgramObject : GLContext
  • GLValidateProgram : GLContext
  • GLValidBackBufferHint : GLContext
  • GLVertex2d : GLContext
  • GLVertex2dv : GLContext
  • GLVertex2f : GLContext
  • GLVertex2fv : GLContext
  • GLVertex2h : GLContext
  • GLVertex2hv : GLContext
  • GLVertex2i : GLContext
  • GLVertex2iv : GLContext
  • GLVertex2s : GLContext
  • GLVertex2sv : GLContext
  • GLVertex3d : GLContext
  • GLVertex3dv : GLContext
  • GLVertex3f : GLContext
  • GLVertex3fv : GLContext
  • GLVertex3h : GLContext
  • GLVertex3hv : GLContext
  • GLVertex3i : GLContext
  • GLVertex3iv : GLContext
  • GLVertex3s : GLContext
  • GLVertex3sv : GLContext
  • GLVertex4d : GLContext
  • GLVertex4dv : GLContext
  • GLVertex4f : GLContext
  • GLVertex4fv : GLContext
  • GLVertex4h : GLContext
  • GLVertex4hv : GLContext
  • GLVertex4i : GLContext
  • GLVertex4iv : GLContext
  • GLVertex4s : GLContext
  • GLVertex4sv : GLContext
  • GLVertexArrayRange : GLContext
  • GLVertexAttrib1d : GLContext
  • GLVertexAttrib1dv : GLContext
  • GLVertexAttrib1f : GLContext
  • GLVertexAttrib1fv : GLContext
  • GLVertexAttrib1h : GLContext
  • GLVertexAttrib1hv : GLContext
  • GLVertexAttrib1s : GLContext
  • GLVertexAttrib1sv : GLContext
  • GLVertexAttrib2d : GLContext
  • GLVertexAttrib2dv : GLContext
  • GLVertexAttrib2f : GLContext
  • GLVertexAttrib2fv : GLContext
  • GLVertexAttrib2h : GLContext
  • GLVertexAttrib2hv : GLContext
  • GLVertexAttrib2s : GLContext
  • GLVertexAttrib2sv : GLContext
  • GLVertexAttrib3d : GLContext
  • GLVertexAttrib3dv : GLContext
  • GLVertexAttrib3f : GLContext
  • GLVertexAttrib3fv : GLContext
  • GLVertexAttrib3h : GLContext
  • GLVertexAttrib3hv : GLContext
  • GLVertexAttrib3s : GLContext
  • GLVertexAttrib3sv : GLContext
  • GLVertexAttrib4bv : GLContext
  • GLVertexAttrib4d : GLContext
  • GLVertexAttrib4dv : GLContext
  • GLVertexAttrib4f : GLContext
  • GLVertexAttrib4fv : GLContext
  • GLVertexAttrib4h : GLContext
  • GLVertexAttrib4hv : GLContext
  • GLVertexAttrib4iv : GLContext
  • GLVertexAttrib4Nbv : GLContext
  • GLVertexAttrib4Niv : GLContext
  • GLVertexAttrib4Nsv : GLContext
  • GLVertexAttrib4Nub : GLContext
  • GLVertexAttrib4Nubv : GLContext
  • GLVertexAttrib4Nuiv : GLContext
  • GLVertexAttrib4Nusv : GLContext
  • GLVertexAttrib4s : GLContext
  • GLVertexAttrib4sv : GLContext
  • GLVertexAttrib4ub : GLContext
  • GLVertexAttrib4ubv : GLContext
  • GLVertexAttrib4uiv : GLContext
  • GLVertexAttrib4usv : GLContext
  • GLVertexAttribI1i : GLContext
  • GLVertexAttribI1iv : GLContext
  • GLVertexAttribI1ui : GLContext
  • GLVertexAttribI1uiv : GLContext
  • GLVertexAttribI2i : GLContext
  • GLVertexAttribI2iv : GLContext
  • GLVertexAttribI2ui : GLContext
  • GLVertexAttribI2uiv : GLContext
  • GLVertexAttribI3i : GLContext
  • GLVertexAttribI3iv : GLContext
  • GLVertexAttribI3ui : GLContext
  • GLVertexAttribI3uiv : GLContext
  • GLVertexAttribI4bv : GLContext
  • GLVertexAttribI4i : GLContext
  • GLVertexAttribI4iv : GLContext
  • GLVertexAttribI4sv : GLContext
  • GLVertexAttribI4ubv : GLContext
  • GLVertexAttribI4ui : GLContext
  • GLVertexAttribI4uiv : GLContext
  • GLVertexAttribI4usv : GLContext
  • GLVertexAttribIPointer : GLContext
  • GLVertexAttribPointer : GLContext
  • GLVertexAttribPointerNV : GLContext
  • GLVertexAttribs1dvNV : GLContext
  • GLVertexAttribs1fvNV : GLContext
  • GLVertexAttribs1hv : GLContext
  • GLVertexAttribs1svNV : GLContext
  • GLVertexAttribs2dvNV : GLContext
  • GLVertexAttribs2fvNV : GLContext
  • GLVertexAttribs2hv : GLContext
  • GLVertexAttribs2svNV : GLContext
  • GLVertexAttribs3dvNV : GLContext
  • GLVertexAttribs3fvNV : GLContext
  • GLVertexAttribs3hv : GLContext
  • GLVertexAttribs3svNV : GLContext
  • GLVertexAttribs4dvNV : GLContext
  • GLVertexAttribs4fvNV : GLContext
  • GLVertexAttribs4hv : GLContext
  • GLVertexAttribs4svNV : GLContext
  • GLVertexAttribs4ubvNV : GLContext
  • GLVertexPointer : GLContext
  • GLViewport : GLContext
  • GLWindowBackBufferHint : GLContext
  • GLWindowPos2d : GLContext
  • GLWindowPos2dv : GLContext
  • GLWindowPos2f : GLContext
  • GLWindowPos2fv : GLContext
  • GLWindowPos2i : GLContext
  • GLWindowPos2iv : GLContext
  • GLWindowPos2s : GLContext
  • GLWindowPos2sv : GLContext
  • GLWindowPos3d : GLContext
  • GLWindowPos3dv : GLContext
  • GLWindowPos3f : GLContext
  • GLWindowPos3fv : GLContext
  • GLWindowPos3i : GLContext
  • GLWindowPos3iv : GLContext
  • GLWindowPos3s : GLContext
  • GLWindowPos3sv : GLContext
  • GLWinRenderArea() : GLWinRenderArea
  • GLXCreateContext : GLContext
  • GLXDestroyContext : GLContext
  • GLXGetCurrentContext : GLContext
  • GLXGetCurrentDrawable : GLContext
  • GPUSkinningProcessor() : GPUSkinningProcessor
  • Group() : Group

- h -

  • handleAlphaTestAttribute() : ExclusiveTraverser, SharedTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleAnimatedQuads() : VertexUnifyTraverser
  • handleAnimatedTransform() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, IdentityToGroupTraverser, EliminateTraverser, CombineTraverser, BalanceTraverser, AppTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleAnimatedVertexAttributeSet() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, StrippingTraverser, SearchTraverser, RenderTraverser, NormalizeTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleBillboard() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, IdentityToGroupTraverser, EliminateTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleBlendAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleCgFx() : ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleDepthAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleDirectedLight() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFaceAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFlipbookAnimation() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, EliminateTraverser, CullTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedIndexAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedTrafoAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedVertexAttributeAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NormalizeTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleGeoNode() : UnifyTraverser, TriangulateTraverser, ExclusiveTraverser, SharedTraverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, EliminateTraverser, DestrippingTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleGroup() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, IdentityToGroupTraverser, EliminateTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleHighlightBox() : ExclusiveTraverser, SharedTraverser
  • handleHighlightEdges() : ExclusiveTraverser, SharedTraverser
  • handleLightingAttribute() : ExclusiveTraverser, SharedTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLinearInterpolatedTrafoAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLinearInterpolatedVertexAttributeAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NormalizeTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLineAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLines() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLineStrips() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, DestrippingTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLOD() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, IdentityToGroupTraverser, GLUploadTraverser, EliminateTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleMapArray() : ExclusiveTraverser, SharedTraverser, GLTraverser
  • handleMapElement() : ExclusiveTraverser, SharedTraverser, GLTraverser
  • handleMapList() : ExclusiveTraverser, SharedTraverser, GLTraverser
  • handleMapMatrix() : ExclusiveTraverser, SharedTraverser, GLTraverser
  • handleMaterial() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleParallelCamera() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePerspectiveCamera() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePointAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePointLight() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePoints() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuadMeshes() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuads() : UnifyTraverser, TriangulateTraverser, ExclusiveTraverser, SharedTraverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuadStrips() : UnifyTraverser, TriangulateTraverser, ExclusiveTraverser, SharedTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, DestrippingTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleShape() : ExclusiveTraverser, SharedTraverser, CullTraverser, AnalyzeTraverser
  • handleSkin() : ExclusiveTraverser, SharedTraverser, StrippingTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSkinnedTriangles() : VertexUnifyTraverser, UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSpotLight() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleStatePass() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, EliminateTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleStateSet() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, EliminateTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleStateVariant() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RenderTraverser, EliminateTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSwitch() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, IdentityToGroupTraverser, GLUploadTraverser, EliminateTraverser, CullTraverser, BalanceTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleTextureAttribute() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, EliminateTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTextureAttributeItem() : ExclusiveTraverser, SharedTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTransform() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, IdentityToGroupTraverser, EliminateTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AppTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleTriangles() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleTriFans() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, DestrippingTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTriStrips() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, DestrippingTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleUnlitColorAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleVertexAttributeSet() : VertexUnifyTraverser, UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, NormalizeTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleVolumeNode() : ExclusiveTraverser, SharedTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, CullTraverser, AppTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • hasChild() : Group
  • hasFaces() : Triangles, Quads
  • hasIndices() : IndependentPrimitiveSet
  • hasLightSource() : Group
  • hasMeshes() : MeshedPrimitiveSet
  • hasSegments() : Lines
  • hasStrips() : StrippedPrimitiveSet
  • headLights : NBFCamera
  • height : texImage_t, meshSet_t
  • hiddenBegin() : RenderTraverser, GLTraverser
  • hiddenEnd() : RenderTraverser, GLTraverser
  • highlightBegin() : RenderTraverser, GLTraverser
  • HighlightBox() : HighlightBox
  • HighlightEdges() : HighlightEdges
  • HighlightElement() : HighlightElement
  • highlightEnd() : RenderTraverser, GLTraverser
  • HighlightObject() : HighlightObject
  • hourLastModified : NBFHeader

- i -

  • IAllocator() : IAllocator
  • identityCount : IdentityResult
  • IdentityToGroupTraverser() : IdentityToGroupTraverser
  • Image() : Image
  • IMG_ALPHA : Image
  • IMG_BGR : Image
  • IMG_BGRA : Image
  • IMG_BYTE : Image
  • IMG_COLOR_INDEX : Image
  • IMG_DEPTH_COMPONENT : Image
  • IMG_DEPTH_STENCIL : Image
  • IMG_FLOAT16 : Image
  • IMG_FLOAT32 : Image
  • IMG_INT : Image
  • IMG_LUMINANCE : Image
  • IMG_LUMINANCE_ALPHA : Image
  • IMG_NUM_FORMATS : Image
  • IMG_NUM_TYPES : Image
  • IMG_RGB : Image
  • IMG_RGBA : Image
  • IMG_SHORT : Image
  • IMG_UNKNOWN_FORMAT : Image
  • IMG_UNKNOWN_TYPE : Image
  • IMG_UNSIGNED_BYTE : Image
  • IMG_UNSIGNED_INT : Image
  • IMG_UNSIGNED_INT_10F_11F_11F : Image
  • IMG_UNSIGNED_INT_24_8 : Image
  • IMG_UNSIGNED_INT_2_10_10_10 : Image
  • IMG_UNSIGNED_INT_5_9_9_9 : Image
  • IMG_UNSIGNED_SHORT : Image
  • Incarnation() : Incarnation
  • INCREASESPEED : WalkCameraManipulator, FlightCameraManipulator
  • incrementJointCount() : Transform
  • incrementMipmapUseCount() : TextureImage
  • IndependentPrimitiveSet() : IndependentPrimitiveSet
  • indices : NBFIndependentPrimitiveSet, NBFSkin, NBFIndexAnimation, meshSet_t, indexSet_t
  • init() : GLMFCRAWnd, Log, FixedAllocator, RenderArea, GLWinRenderArea, Switch
  • initGL() : GLWinRenderArea
  • insertEmptyColumn() : MapMatrix
  • insertKey() : KeyFramedAnimation
  • insertMap() : MapMatrix, MapArray
  • insertMapObject() : MapList
  • instance() : Singleton
  • integerFmt : NVSGTexImageFmt
  • intensity : NBFLightSource
  • interruptRender() : RenderArea
  • interruptTraversal() : Traverser
  • intersectBox() : RayIntersectTraverser
  • Intersection() : Intersection
  • intersectLine() : RayIntersectTraverser
  • intersectPoint() : RayIntersectTraverser
  • intersectTriangle() : RayIntersectTraverser
  • intFmt : GLTexImageFmt
  • invalidate() : Validated, Spherent
  • invalidateAnimationContainment() : PrimitiveSet, Node, LightSource, Drawable
  • invalidateBoundingVolumes() : VertexAttributeSet, Node, HighlightObject, Drawable
  • invalidateCaches() : Group
  • invalidateCgFxContainment() : StateVariant, StateSet, StatePass, Node
  • invalidateContainment() : StateVariant, StateSet, StatePass, StateAttribute, Node
  • invalidateHintsContainment() : Node
  • invalidateIncarnation() : OwnedObject, Object, Node, AnimatedVertexAttributeSet, AnimatedTransform
  • invalidateLightContainment() : Node
  • invalidateLODContainment() : Node
  • invalidateSquaredDistance() : RenderElement
  • invalidateTransparencyContainment() : StateVariant, StateSet, StatePass, StateAttribute, Node
  • invalidateVolumeNodeContainment() : Node
  • inverseBindMatrices : NBFSkin
  • invert() : Matnnt
  • is1D() : TextureImage
  • is1DArray() : TextureImage
  • is2D() : TextureImage
  • is2DArray() : TextureImage
  • is3D() : TextureImage
  • isActive() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, Manipulator, FlightCameraManipulator, AnimationManipulator, VolumeNode, Switch
  • isAnimating() : ViewState
  • isAntiAliased() : PointAttribute, LineAttribute
  • isArrayParameter() : CgFxEffect
  • isAttenuated() : SpotLight, PointLight
  • isAutoClipPlanes : Camera, NBFCamera
  • isAvailable() : GLFunctions
  • isBackFaceCulling() : RenderTraverser, FaceAttribute
  • isBoolAnnotation() : CgFxEffect
  • isBoolParameter() : CgFxEffect
  • isBoolPassState() : CgFxEffect
  • isBoolSamplerState() : CgFxEffect
  • isClipPlaneActive() : Group
  • isCompatible() : VertexAttributeSet, PrimitiveSet, KeyFramedAnimation, FramedAnimation, Animation, AnimatedVertexAttributeSet
  • isCompressed() : TextureImage
  • isCritical() : NVSGException
  • isCubeMap() : TextureImage
  • isDataShared() : VertexAttributeSet, TextureAttributeItem, StrippedPrimitiveSet, SkinnedTriangles, Object, MeshedPrimitiveSet, Material, IndependentPrimitiveSet, CgFx
  • isDepthTestingEnabled() : DepthAttribute
  • isDepthWritingEnabled() : DepthAttribute
  • isDolly() : TrackballTransformManipulator, TrackballCameraManipulator
  • isEachPassTransparent() : StateVariant
  • isEmpty() : Path
  • isEnabled() : Log, VertexAttributeSet, LightSource
  • isEquivalent() : VolumeNode, VertexAttributeSet, Transform, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, SpotLight, SkinnedTriangles, Skin, Shape, PrimitiveSet, PointLight, PointAttribute, Object, MeshedPrimitiveSet, Material, LOD, LineAttribute, LightSource, LightingAttribute, KeyFramedAnimation, IndependentPrimitiveSet, Group, GeoNode, FramedAnimation, FlipbookAnimation, FaceAttribute, DepthAttribute, CgFx, BlendAttribute, Billboard, Animation, AnimatedVertexAttributeSet, AnimatedTransform, AlphaTestAttribute
  • isExported() : GLFunctions
  • isFaceCullingOverwrite() : RenderTraverser
  • isFaceModeOverwrite() : RenderTraverser
  • isFixed() : TransformElement
  • isFixedPoint() : TextureImage
  • isFloatAnnotation() : CgFxEffect
  • isFloatingPoint() : TextureImage
  • isFloatParameter() : CgFxEffect
  • isFloatPassState() : CgFxEffect
  • isFloatSamplerState() : CgFxEffect
  • isFly() : FlightCameraManipulator
  • isFlyBackward() : FlightCameraManipulator
  • isFlyForward() : FlightCameraManipulator
  • isFromFile() : CgFxEffect
  • isFromLump() : CgFxEffect
  • isFrontFaceCulling() : RenderTraverser, FaceAttribute
  • isGeometryCacheTechniqueSupported() : RenderTraverser, GLTraverser
  • isHighlightPass() : RenderTraverser
  • isHWFSAAAvailable() : RenderArea
  • isHWFSAAEnabled() : GLWinRenderArea
  • isImageStream() : TextureImage
  • isInputProgramParameter() : CgFxEffect
  • isInsideBounds() : Chunk
  • isIntAnnotation() : CgFxEffect
  • isIntParameter() : CgFxEffect
  • isIntPassState() : CgFxEffect
  • isIntSamplerState() : CgFxEffect
  • isJitter() : ViewState
  • isJitterTechniqueSupported() : RenderTraverser, GLTraverser
  • isJoint() : Transform
  • isLeaf() : VolumeBrick
  • isLengthPreserving() : TransformElement
  • isLightArrayParameter() : CgFxEffect
  • isLightParameter() : CgFxEffect
  • isLineAntiAliasingEnabled() : RenderTraverser
  • isLocalViewerEnabled() : GLTraverser
  • isMaterialParameter() : CgFxEffect
  • isMatrix22Parameter() : CgFxEffect
  • isMatrix23Parameter() : CgFxEffect
  • isMatrix24Parameter() : CgFxEffect
  • isMatrix32Parameter() : CgFxEffect
  • isMatrix33Parameter() : CgFxEffect
  • isMatrix34Parameter() : CgFxEffect
  • isMatrix42Parameter() : CgFxEffect
  • isMatrix43Parameter() : CgFxEffect
  • isMatrix44Parameter() : CgFxEffect
  • isMipmapped() : TextureAttributeItem
  • isMipmapSamplerState() : CgFxEffect
  • isMirroring() : TransformElement
  • isNormalizeEnabled() : VertexAttributeSet
  • isOcclusionCulling() : RenderTraverser
  • isOcclusionCullingSupported() : RenderTraverser, GLTraverser
  • isOITTechniqueSupported() : RenderTraverser, GLTraverser
  • isOrbit() : TrackballCameraManipulator
  • isOutputProgramParameter() : CgFxEffect
  • isOverlayPass() : RenderTraverser
  • isPan() : TrackballTransformManipulator, TrackballCameraManipulator
  • isPointAntiAliasingEnabled() : RenderTraverser
  • isPolygonOffset() : FaceAttribute
  • isProgramCompiled() : CgFxEffect
  • isRangeLockEnabled() : LOD
  • isRenderTechniqueSupported() : RenderTraverser, GLTraverser
  • isRotate() : TrackballTransformManipulator, TrackballCameraManipulator
  • isSampler1DParameter() : CgFxEffect
  • isSampler2DParameter() : CgFxEffect
  • isSampler3DParameter() : CgFxEffect
  • isSamplerArrayParameter() : CgFxEffect
  • isSamplerCubeParameter() : CgFxEffect
  • isSamplerParameter() : CgFxEffect
  • isSamplerRectParameter() : CgFxEffect
  • isScalarParameter() : CgFxEffect
  • isSceneParameter() : CgFxEffect
  • isSeparateSpecularColorEnabled() : GLTraverser
  • isShadowCasting() : LightSource
  • isShadowTechniqueSupported() : RenderTraverser, GLTraverser
  • isShareable() : RCObject
  • isShared : RCObject, NBFObject
  • isSkinningProcessorSupported() : AppTraverser
  • isSquaredDistanceValid() : RenderElement
  • isStereo : ViewState, NBFViewState
  • isStereoAutomatic : NBFViewState
  • isStereoAutomaticEyeDistanceAdjustment() : ViewState
  • isStereoAvailable() : RenderArea
  • isStereoReversedEyes() : ViewState
  • isStringAnnotation() : CgFxEffect
  • isStringParameter() : CgFxEffect
  • isStructParameter() : CgFxEffect
  • isSubjectToCull() : RenderElement
  • isSupported() : GPUSkinningProcessor, CPUSkinningProcessor
  • isTextureImageSamplerCompliant() : CgFxEffect
  • isTilt() : WalkCameraManipulator
  • isTransformParameter() : CgFxEffect
  • isTranslate() : WalkCameraManipulator
  • isTransparencyTechniqueSupported() : RenderTraverser, GLTraverser
  • isTransparent() : StateVariant, StateSet, StatePass, StateAttribute, LightingAttribute, CgFx, BlendAttribute, AlphaTestAttribute
  • isTransparentPass() : RenderTraverser, CgFxEffect
  • isTwoSidedLighting() : RenderTraverser, FaceAttribute
  • isTwoSidedLightingOverwrite() : RenderTraverser
  • ISType : RayIntersectTraverser
  • isUnused() : Chunk
  • isUploadDemanded() : TextureImage
  • isValid() : Validated, FileMapping, CgFxEffect
  • isVector2Parameter() : CgFxEffect
  • isVector3Parameter() : CgFxEffect
  • isVector4Parameter() : CgFxEffect
  • isWalk() : WalkCameraManipulator
  • isWalkBackward() : WalkCameraManipulator
  • isWalkForward() : WalkCameraManipulator
  • iterator : SearchTraverser

- j -

  • JCT_CROSS_PRODUCT : ViewState
  • JCT_HIGHER_PASS : ViewState
  • JCT_NONE : ViewState
  • JitterCombineTechnique : ViewState
  • JitterTechnique : RenderTraverser
  • joints : NBFSkin
  • JT_ACCUM : RenderTraverser
  • JT_FBO : RenderTraverser
  • JT_NONE : RenderTraverser
  • JT_PBUFFER : RenderTraverser
  • JT_READ_PIXELS : RenderTraverser

- k -

  • key : keyVariant_t
  • keyDown() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, KeyInput, FlightCameraManipulator
  • KeyFramedAnimation() : KeyFramedAnimation
  • KeyInput() : KeyInput
  • keys : NBFInterpolatedAnimation
  • keyStateVariantPairs : NBFStateSet
  • keyUp() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, KeyInput, FlightCameraManipulator

- l -

  • lerp() : Trafo
  • levelToDisplay : NBFVolumeNode
  • LightingAttribute() : LightingAttribute
  • LightsElement() : LightsElement
  • LightSource() : LightSource
  • lightSources : NBFGroup
  • linearAttenuation : NVSGLight
  • LinearInterpolatedAnimation() : LinearInterpolatedAnimation
  • LineAttribute() : LineAttribute
  • Lines() : Lines
  • LineStrips() : LineStrips
  • load() : TextureLoader, SceneLoader, WRLLoader, PLYLoader, NVSGLoader, NVNVB, NVBLoader, NBFLoader
  • loadCustomObject() : NBFLoader
  • lock() : CgFxContext
  • lockExclusive() : SWMRSync
  • lockObject() : ExclusiveTraverser, SharedTraverser, Traverser
  • lockScene() : ExclusiveTraverser, SharedTraverser, Traverser
  • lockShared() : SWMRSync
  • lockViewState() : ExclusiveTraverser, SharedTraverser, Traverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, GLUploadTraverser
  • LOD() : LOD
  • lodRanges : RedundantLODRangesResult
  • Log() : Log
  • loopCount : NBFAnimation

- m -

  • m_accessType : FileMapping
  • m_animationFrame : AppTraverser
  • m_appTraverser : RenderArea
  • m_bApplyingCgFx : AppTraverser
  • m_bones : SkinnedTriangles::Skin
  • m_bpl : Image
  • m_bpp : Image
  • m_bps : Image
  • m_buttonState : MouseInput
  • m_cameraAnimation : AnimationManipulator
  • m_cameraHeightAboveTerrain : WalkCameraManipulator
  • m_cullStack : Traverser
  • m_cullTraverser : RenderArea
  • m_currentTick : AnimationManipulator
  • m_currentX : MouseInput
  • m_currentY : MouseInput
  • m_delta : AnimationManipulator
  • m_depth : Image
  • m_dist : Intersection
  • m_features : RenderArea
  • m_file : FileMapping
  • m_fileMapping : FileMapping
  • m_filename : VolLoader::FileInfo
  • m_format : Image, VolLoader::FileInfo
  • m_hdc : GLWinRenderArea
  • m_height : Image
  • m_hglrc : GLWinRenderArea
  • m_hSensitivity : WalkCameraManipulator, FlightCameraManipulator
  • m_idRenderArea : RenderArea
  • m_indices : Face
  • m_instance : ILTexLoader
  • m_interrupt : Traverser
  • m_isCritical : ProblemInfo
  • m_isp : Intersection
  • m_isValid : FileMapping
  • m_keyInput : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • m_keyState : KeyInput
  • m_lastX : MouseInput
  • m_lastY : MouseInput
  • m_lockedCamera : ExclusiveModelViewTraverser, SharedModelViewTraverser
  • m_lockedScene : ExclusiveTraverser, SharedTraverser
  • m_lockedViewState : ExclusiveTraverser, SharedTraverser
  • m_lodStack : Traverser
  • m_mappingSize : FileMapping
  • m_mftbl : Traverser
  • m_miLast : TrackballCameraManipulator
  • m_missingFeatures : ProblemInfo
  • m_mouseInput : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • m_nob : Image
  • m_normal : SkinnedTriangles::Skin
  • m_numMSBuffers : RenderArea
  • m_objectCode : Object
  • m_overlapSize : VolLoader::FileInfo
  • m_pDrawable : Intersection
  • m_pixels : Image
  • m_pPath : Intersection
  • m_primitiveIndex : Intersection
  • m_problem : ProblemInfo
  • m_problemLog : RenderArea, Traverser
  • m_raCreated : RenderArea
  • m_raHeight : RenderArea
  • m_raWidth : RenderArea
  • m_refCount : ILTexLoader
  • m_renderArea : Manipulator
  • m_renderTraverser : RenderArea
  • m_root : Traverser
  • m_rotationAxis : TrackballCameraManipulator
  • m_scene : RenderArea, Traverser
  • m_ScreenSizeX : WalkCameraManipulator, FlightCameraManipulator
  • m_ScreenSizeY : WalkCameraManipulator, FlightCameraManipulator
  • m_sliceThickness : VolLoader::FileInfo
  • m_speed : WalkCameraManipulator, FlightCameraManipulator
  • m_speedIncreaseFactor : WalkCameraManipulator, FlightCameraManipulator
  • m_startX : MouseInput
  • m_startY : MouseInput
  • m_tbsize : Trackball
  • m_trackball : TrackballCameraManipulator
  • m_trafo : LightSource
  • m_transformPath : TransformManipulator
  • m_transformStack : ExclusiveModelViewTraverser, SharedModelViewTraverser, ExtractGeometryTraverser
  • m_traverser : NBFSaver
  • m_traverserBits : Traverser
  • m_trueY : TrackballTransformManipulator, TrackballCameraManipulator
  • m_type : Image, VolLoader::FileInfo
  • m_vertex : SkinnedTriangles::Skin
  • m_vertexIndices : Intersection
  • m_viewState : RenderArea, Traverser
  • m_vSensitivity : FlightCameraManipulator
  • m_width : Image
  • m_worldUpVector : WalkCameraManipulator, FlightCameraManipulator
  • magFilter : NBFTextureAttributeItem
  • makeCurrent() : GLWinRenderArea
  • Manipulator() : Manipulator
  • Map() : Map
  • MapArray() : MapArray
  • MapElement() : MapElement
  • mapIn() : WriteMapping, ReadMapping, FileMapping
  • MapList() : MapList
  • MapMatrix() : MapMatrix
  • MapObject() : MapObject
  • mapOffset() : PLYLoader, NBFLoader
  • mapOut() : FileMapping
  • markUnshareable() : RCObject
  • MaskIterator : Switch
  • MaskKey : Switch
  • maskKey : switchMask_t
  • masks : NBFSwitch
  • Material() : Material
  • Matnnt() : Matnnt
  • MemFunTbl() : MemFunTbl
  • MeshedPrimitiveSet() : MeshedPrimitiveSet
  • meshes : NBFMeshedPrimitiveSet
  • minFilter : NBFTextureAttributeItem
  • minuteLastModified : NBFHeader
  • mirrorX() : TextureImage
  • mirrorY() : TextureImage
  • missingCount : MissingResult
  • monthLastModified : NBFHeader
  • motionHandled() : MouseInput
  • mouseButtonDown() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, MouseInput, FlightCameraManipulator
  • mouseButtonUp() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, MouseInput, FlightCameraManipulator
  • MouseInput() : MouseInput
  • mouseMotion() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, MouseInput, FlightCameraManipulator
  • move() : Camera
  • moveX() : Camera
  • moveY() : Camera
  • moveZ() : Camera

- n -

  • name : PlugInCallback::DegenerateGeometryInfo, sampler_t, tweak_t
  • nbfBugfixLevel : NBFHeader
  • nbfMajorVersion : NBFHeader
  • nbfMinorVersion : NBFHeader
  • NBFSaver() : NBFSaver
  • NBFSaveTraverser() : NBFSaveTraverser
  • nearDist : NBFCamera
  • needsTraversal() : AppTraverser
  • NewCamera() : NVNVB
  • NewController() : NVNVB
  • NewHelper() : NVNVB
  • NewLight() : NVNVB
  • NewMaterial() : NVNVB
  • NewMesh() : NVNVB
  • NewMotion() : NVNVB
  • NewScene() : NVNVB
  • NewShape() : NVNVB
  • NewTexture() : NVNVB
  • nextFrame() : AnimationManipulator
  • NH_CULL_ALWAYS : Node
  • NH_CULL_MASK : Node
  • NH_CULL_NEVER : Node
  • NH_CUSTOM_BITS : Node
  • NH_MODIFY_FREQUENCY_HIGH : Node
  • NH_MODIFY_FREQUENCY_LOW : Node
  • NH_MODIFY_FREQUENCY_MASK : Node
  • NH_NO_SHADOW_CASTER : Node
  • NH_NO_SHADOW_RECEIVER : Node
  • NH_OVERLAY : Node
  • NH_RESERVED_BITS : Node
  • Node() : Node
  • NodeHints : Node
  • NodeHintsCullTraverser() : NodeHintsCullTraverser
  • NonConstMaskIterator : Switch
  • nonLinearFmt : NVSGTexImageFmt
  • normal : plane_t, skin_t
  • normalize() : Vecnt, Quatt
  • normalizeEnableFlags : NBFVertexAttributeSet
  • normalizeFlags : NBFAnimatedVertexAttributeSet
  • NormalizeTraverser() : NormalizeTraverser
  • normals : VNVector
  • nullNormalsCount : NullNormalsResult
  • nullNormalsNumber : NullNormalsResult
  • numberOfAnimationFrames : NBFScene
  • numBindings : NBFTextureAttribute
  • numBones : skin_t
  • numCameraAnimations : NBFScene
  • numCameras : NBFScene
  • numChars : sstr_t, str_t
  • numChildren : NBFGroup, switchMask_t
  • numClipPlanes : NBFGroup
  • numCounts : NBFSkin
  • numDoFJitters : NBFViewState
  • numDrawables : geometrySet_t
  • numFSAAJitters : NBFViewState
  • numGeometrySets : NBFGeoNode
  • numHeadLights : NBFCamera
  • numIndices : NBFIndependentPrimitiveSet, indexSet_t
  • numJoints : NBFSkin
  • numKeys : NBFInterpolatedAnimation
  • numLightSource : NBFGroup
  • numMasks : NBFSwitch
  • numMeshes : NBFMeshedPrimitiveSet
  • numRanges : NBFLOD
  • numSamplers : NBFCgFx
  • numSkins : NBFSkinnedTriangles
  • numStateAttribs : NBFStatePass
  • numStatePasses : NBFStateVariant
  • numStateVariants : NBFStateSet
  • numSteps : NBFFramedAnimation
  • numStrips : NBFStrippedPrimitiveSet
  • numTexCoords : texCoordSet_t
  • numTweaks : NBFCgFx, tweak_t
  • numValues : tweak_t
  • numVData : vertexAttrib_t
  • NVBImportError() : NVNVB
  • NVBLoadTraverser() : NVBLoadTraverser
  • NVBLog() : NVNVB
  • NVSG_MULTISAMPLE : RenderArea
  • NVSG_STEREO : RenderArea
  • nvsgBugfixLevel : NBFHeader
  • NVSGException() : NVSGException
  • nvsgMajorVersion : NBFHeader
  • nvsgMinorVersion : NBFHeader
  • NVSGSaveTraverser() : NVSGSaveTraverser

- o -

  • Object() : Object
  • objectAnno : NBFObject
  • objectCode : AnalyzeResult, NBFObject, NBFViewState
  • objectCount : AnalyzeResult
  • objectDataID : NBFObject
  • objectName : NBFObject
  • occlusionTest() : RenderTraverser
  • offset : plane_t
  • OITTechnique : RenderTraverser
  • onDegenerateGeometry() : PlugInCallback
  • onEmptyToken() : PlugInCallback
  • OnEraseBkgnd() : GLMFCRAWnd
  • onError() : PlugInCallback
  • onFileAccessFailed() : PlugInCallback
  • onFileEmpty() : PlugInCallback
  • onFileMappingFailed() : PlugInCallback
  • onFileNotFound() : PlugInCallback
  • onFilesNotFound() : PlugInCallback
  • onIncompatibleFile() : PlugInCallback
  • onIncompatibleValues() : PlugInCallback
  • onInvalidFile() : PlugInCallback
  • onInvalidValue() : PlugInCallback
  • onLoad() : TextureLoader, VolLoader, ILTexLoader
  • OnPaint() : GLMFCRAWnd
  • onReleaseDAL() : DALDataCreator
  • onUndefinedToken() : PlugInCallback
  • onUnexpectedEndOfFile() : PlugInCallback
  • onUnexpectedToken() : PlugInCallback
  • onUnknownToken() : PlugInCallback
  • onUnLocalizedMessage() : PlugInCallback
  • onUnsupportedToken() : PlugInCallback
  • onWarning() : PlugInCallback
  • operator *() : RCObject_AutoPtr, RCIPtr, RCPtr
  • operator *=() : Vecnt, Quatt, Matnnt
  • operator CGcontext() : CgFxContext
  • operator const T &() : RegVal
  • operator delete() : IAllocator
  • operator new() : IAllocator
  • operator!=() : CullData, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VariantIterator
  • operator()() : TraceFunctor, traceFileConsoleOutput, traceFileDebugOutput, traceFileOutput, traceConsoleDebugOutput, traceConsoleOutput, traceDebugOutput, removeReference, addReference, RenderElementCompareStateAttributes, RenderElementCompareFrontToBack, RenderElementCompareBackToFront, Lanczos3Filter, BSplineFilter, BellFilter, TriangleFilter, BoxFilter, ScaleFilter, Bone, Spherent, Planent
  • operator+() : Incarnation
  • operator++() : Incarnation
  • operator+=() : Vecnt, Matnnt
  • operator-=() : Vecnt, Matnnt
  • operator->() : RCObject_AutoPtr, RCIPtr, RCPtr
  • operator/=() : Vecnt, Quatt, Matnnt
  • operator< : UPIID, UPITID
  • operator=() : RegVal, RCObject_AutoPtr, RCIPtr, RCPtr, RCObject, UPIID, MouseInput, KeyInput, Intersection, VolumeNode, VertexAttributeSet, VertexAttribute, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, StateAttribute, SpotLight, SkinnedTriangles, Bone, Skin, Shape, QuadStrips, Quads, QuadMeshes, PrimitiveSet, PrimitiveAttribute, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, OwnedObject, Object, Node, MeshedPrimitiveSet, Material, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, LightSource, LightingAttribute, KeyFramedAnimation, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FlipbookAnimation, FaceAttribute, Drawable, DirectedLight, DepthAttribute, CgFx, Camera, BlendAttribute, Billboard, Animation, AnimatedVertexAttributeSet, AnimatedTransform, AlphaTestAttribute, Vecnt, Trafo, Quatt
  • operator==() : CullData, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VNVector, VariantIterator, Bone, Trafo
  • operator[]() : MemFunTbl, VolumeBrick, Face, Vecnt, Quatt, Matnnt
  • OptimizeTraverser() : OptimizeTraverser
  • ORBIT : TrackballCameraManipulator
  • orbit() : TrackballCameraManipulator, Camera
  • orbitX() : Camera
  • orbitY() : Camera
  • orbitZ() : Camera
  • orientation : trafo_t
  • orthonormalize() : Vecnt
  • OT_FBO : RenderTraverser
  • OT_PBUFFER : RenderTraverser
  • OT_TEXTURE : RenderTraverser
  • overlayBegin() : RenderTraverser, GLTraverser
  • overlayEnd() : RenderTraverser, GLTraverser
  • OwnedObject() : OwnedObject
  • OwnerIterator : OwnedObject
  • ownersBegin() : OwnedObject
  • ownersEnd() : OwnedObject

- p -

  • PADDING() : NBFPointAttribute, NBFLineAttribute, NBFLightingAttribute, NBFFaceAttribute, NBFDepthAttribute, NBFCgFx, NBFBlendAttribute, NBFAlphaTestAttribute, NBFStateSet, NBFSpotLight, NBFLightSource, NBFAnimatedTransform, NBFFlipbookAnimation, NBFTransform, NBFBillboard, NBFSwitch, NBFLOD, NBFNode, NBFCamera, NBFFramedAnimation, NBFAnimation, NBFVertexAttributeAnimation, NBFTrafoAnimation, NBFIndexAnimation, NBFObject, NBFViewState, NBFHeader, texImage_t
  • pan() : TrackballTransformManipulator, TrackballCameraManipulator
  • PAN1 : TrackballTransformManipulator, TrackballCameraManipulator
  • PAN2 : TrackballTransformManipulator, TrackballCameraManipulator
  • ParallelCamera() : ParallelCamera
  • Path() : Path
  • PerspectiveCamera() : PerspectiveCamera
  • PIC_ERROR : PlugInCallback
  • PIC_TYPE_ID : PlugInCallback
  • PIC_WARNING : PlugInCallback
  • pickMap() : MapObject, MapMatrix, MapList, MapElement, MapArray
  • PixelDataType : Image
  • pixelFormat : texImage_t
  • PixelFormat : Image
  • pixels : texImage_t
  • Planent() : Planent
  • PlugInCallback() : PlugInCallback
  • PointAttribute() : PointAttribute
  • PointLight() : PointLight
  • Points() : Points
  • polygonOffsetEnabled : NBFFaceAttribute
  • polygonOffsetFactor : NBFFaceAttribute
  • polygonOffsetUnits : NBFFaceAttribute
  • pop() : Path
  • popCullTraverser() : RenderArea
  • popModelToWorld() : TransformStack
  • position : NVSGLight, PlugInCallback::DegenerateGeometryInfo, PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UnexpectedTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo, PlugInCallback::EmptyTokenInfo, NBFSpotLight, NBFPointLight, NBFCamera
  • postAddChild() : Switch, Group
  • postApply() : Traverser, IdentityToGroupTraverser, CullTraverser
  • postRemoveChild() : Switch, Group
  • postTraverseDrawables() : Traverser, RenderTraverser
  • postTraverseGroup() : Traverser, RenderTraverser, RayIntersectTraverser
  • postTraverseTransform() : RenderTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, FrustumCullTraverser, AppTraverser, ExtractGeometryTraverser
  • preAddChild() : Group
  • preApply() : Traverser, NVSGSaveTraverser
  • preCalculateFileSize() : NBFSaveTraverser
  • PreCreateWindow() : GLMFCRAWnd
  • preRemoveChild() : Group
  • preTraverseDrawables() : Traverser, RenderTraverser, CombineTraverser
  • preTraverseGroup() : Traverser, RenderTraverser, RayIntersectTraverser
  • preTraverseTransform() : RenderTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, FrustumCullTraverser, AppTraverser, ExtractGeometryTraverser
  • previousFrame() : AnimationManipulator
  • PrimitiveAttribute() : PrimitiveAttribute
  • PrimitiveSet() : PrimitiveSet
  • primitiveSetsBegin() : RenderTraverser, GLTraverser
  • primitiveSetsEnd() : RenderTraverser, GLTraverser
  • ProblemInfo() : ProblemInfo
  • process() : GPUSkinningProcessor, CPUSkinningProcessor
  • PROGRAM_IO_FRAGMENT : CgFxEffect
  • PROGRAM_IO_LINE : CgFxEffect
  • PROGRAM_IO_LINE_ADJ : CgFxEffect
  • PROGRAM_IO_POINT : CgFxEffect
  • PROGRAM_IO_TRIANGLE : CgFxEffect
  • PROGRAM_IO_TRIANGLE_ADJ : CgFxEffect
  • PROGRAM_IO_VERTEX : CgFxEffect
  • ProgramIOType : CgFxEffect
  • projectOntoTBSphere() : Trackball
  • pseudoAlloc() : NBFSaveTraverser
  • push() : Path
  • pushCullTraverser() : RenderArea
  • pushModelToWorld() : TransformStack

- q -

  • QuadMeshes() : QuadMeshes
  • quadraticAttenuation : NVSGLight
  • Quads() : Quads
  • QuadStrips() : QuadStrips
  • Quatt() : Quatt
  • queryInterfaceType : PlugInServer

- r -

  • ranges : NBFLOD
  • RayIntersectTraverser() : RayIntersectTraverser
  • RCIPtr() : RCIPtr
  • RCObject() : RCObject
  • RCObject_AutoPtr() : RCObject_AutoPtr
  • RCPtr() : RCPtr
  • RCVector() : RCVector
  • ReadMapping() : ReadMapping
  • reducedCount : EquivalenceResult, CombinableResult
  • redundantLODRanges : RedundantLODRangesResult
  • redundantLODs : RedundantLODRangesResult
  • RegVal() : RegVal
  • release() : RCObject_AutoPtr, RayIntersectTraverser
  • releaseCachedData() : VertexAttributeSet
  • releaseDeviceAbstractionLinkData() : DALDataCreator, DALHost
  • releaseImagePixels() : TextureImage
  • releaseInterface : PlugInServer
  • reload() : TextureLoader
  • reloadImagePixels() : TextureImage
  • removeAsParentFrom() : Node
  • removeAttribute() : StateVariant, StateSet, StatePass
  • removeAttributeByObjectCode() : StateVariant, StateSet, StatePass
  • removeCallback() : CallbackServer
  • removeCamera() : Scene
  • removeCameraAnimation() : Scene
  • removeChild() : Group
  • removeColumn() : MapMatrix
  • removeData() : VertexAttribute
  • removeGeometry() : GeoNode
  • removeHeadLight() : Camera
  • removeHints() : NodeHintsCullTraverser, Node
  • removeJoint() : Skin
  • removeKey() : KeyFramedAnimation
  • removeKeys() : KeyFramedAnimation
  • removeLightSource() : Group
  • removeMap() : MapMatrix, MapArray
  • removeMapObject() : MapList
  • removeMask() : Switch
  • removeOnDestroyCallback() : RCObject
  • removeOwner() : OwnedObject
  • removePass() : StateVariant, StateSet
  • removePrimitiveSet() : Shape
  • removeRef() : RCObject, BaseRenderElement
  • removeStep() : KeyFramedAnimation, FramedAnimation
  • removeSteps() : FramedAnimation
  • removeVariant() : StateSet
  • removeVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • renderAlphaTestAttribute() : RenderTraverser, GLTraverser
  • RenderArea() : RenderArea
  • renderBegin() : RenderTraverser, GLTraverser
  • renderBillboard() : RenderTraverser
  • renderBlendAttribute() : RenderTraverser, GLTraverser
  • renderCgFx() : RenderTraverser
  • renderDepthAttribute() : RenderTraverser, GLTraverser
  • renderDirectedLight() : RenderTraverser, GLTraverser
  • RenderElement() : RenderElement
  • RenderElementCompareBackToFront() : RenderElementCompareBackToFront
  • RenderElementCompareFrontToBack() : RenderElementCompareFrontToBack
  • renderEnd() : RenderTraverser, GLTraverser
  • renderFaceAttribute() : RenderTraverser, GLTraverser
  • renderHighlightBox() : RenderTraverser, GLTraverser
  • renderHighlightEdges() : RenderTraverser, GLTraverser
  • renderLightingAttribute() : RenderTraverser, GLTraverser
  • renderLineAttribute() : RenderTraverser, GLTraverser
  • renderLines() : RenderTraverser, GLTraverser
  • renderLineStrips() : RenderTraverser, GLTraverser
  • renderMaterial() : RenderTraverser, GLTraverser
  • renderObject() : RenderTraverser
  • renderParallelCamera() : RenderTraverser, GLTraverser
  • renderPerspectiveCamera() : RenderTraverser, GLTraverser
  • renderPointAttribute() : RenderTraverser, GLTraverser
  • renderPointLight() : RenderTraverser, GLTraverser
  • renderPoints() : RenderTraverser, GLTraverser
  • renderQuadMeshes() : RenderTraverser, GLTraverser
  • renderQuads() : RenderTraverser, GLTraverser
  • renderQuadStrips() : RenderTraverser, GLTraverser
  • renderScene() : RenderArea, GLWinRenderArea
  • renderSkinnedTriangles() : RenderTraverser, GLTraverser
  • renderSpotLight() : RenderTraverser, GLTraverser
  • renderStatePass() : RenderTraverser, GLTraverser
  • RenderTechnique : RenderTraverser
  • renderTextureAttribute() : RenderTraverser, GLTraverser
  • renderTextureAttributeItem() : RenderTraverser, GLTraverser
  • renderTransform() : RenderTraverser
  • RenderTraverser() : RenderTraverser
  • renderTriangles() : RenderTraverser, GLTraverser
  • renderTriFans() : RenderTraverser, GLTraverser
  • renderTriStrips() : RenderTraverser, GLTraverser
  • renderUnlitColorAttribute() : RenderTraverser, GLTraverser
  • replaceChild() : Group
  • replaceDrawable() : GeoNode
  • replaceKey() : KeyFramedAnimation
  • replaceKeys() : KeyFramedAnimation
  • replaceLightSource() : Group
  • replaceMap() : MapMatrix, MapArray
  • replaceMapObject() : MapList
  • replacePass() : StateVariant, StateSet
  • replaceStateSet() : GeoNode
  • replaceStep() : KeyFramedAnimation, FramedAnimation, Animation
  • replaceSteps() : FramedAnimation
  • replaceVariant() : StateSet
  • replaceVariantKey() : StateSet
  • requestHWFSAA() : RenderArea
  • requestStereoSupport() : RenderArea
  • reserved : NBFHeader
  • reserveKeys() : KeyFramedAnimation
  • reserveSteps() : FramedAnimation
  • reset() : RCObject_AutoPtr, WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • resetButtonState() : MouseInput
  • resetKeyState() : KeyInput
  • resetLightValues() : CgFxEffect
  • resetMaterialValues() : CgFxEffect
  • resetPass() : CgFxEffect
  • resetPositions() : MouseInput
  • resetSceneValues() : CgFxEffect
  • resolution : VolLoader::FileInfo
  • root : NBFScene
  • ROTATE : TrackballTransformManipulator
  • rotate() : TrackballTransformManipulator, TrackballCameraManipulator, Camera
  • rotateX() : Camera
  • ROTATEXN : TrackballCameraManipulator
  • ROTATEXP : TrackballCameraManipulator
  • rotateY() : Camera
  • ROTATEYN : TrackballCameraManipulator
  • ROTATEYP : TrackballCameraManipulator
  • rotateZ() : Camera
  • ROTATEZN : TrackballCameraManipulator
  • ROTATEZP : TrackballCameraManipulator
  • rotationAxis : NBFBillboard
  • RT_EFFECTED : RenderTraverser
  • RT_SHADED : RenderTraverser
  • RT_TEXTURED : RenderTraverser
  • RT_UNLIT : RenderTraverser

- s -

  • samplers : NBFCgFx
  • save() : TextureSaver, SceneSaver, VolSaver, OBJSaver, NVSGSaver, NBFSaver, ILTexSaver
  • scale() : TextureImage
  • scaleOrientation : trafo_t
  • scaleToPowerOfTwo() : TextureImage
  • scaling : trafo_t
  • Scene() : Scene
  • scene : NBFHeader
  • search() : SearchTraverser
  • SearchTraverser() : SearchTraverser
  • secondLastModified : NBFHeader
  • set() : Validated
  • setActive() : Switch
  • setActiveMask() : Switch
  • setActiveVariantKey() : StateSet
  • setAlignment() : MapMatrix, MapArray, Billboard
  • setAlphaFunction() : AlphaTestAttribute
  • setAmbientColor() : Scene, Material, LightSource
  • setAnimating() : ViewState
  • setAnimation() : Bone, LightSource, FlipbookAnimation, AnimatedVertexAttributeSet, AnimatedTransform
  • setAnimationFrame() : SkinnedTriangles
  • setAnnotation() : Object
  • setAntiAliasing() : PointAttribute, LineAttribute
  • setAppTraverser() : RenderArea
  • setAspectRatio() : Camera
  • setAttenuation() : SpotLight, PointLight
  • setAutoClipPlanes() : Camera
  • setBackColor() : Scene
  • setBackImage() : Scene
  • setBalanceTargets() : BalanceTraverser
  • setBaseClassSearch() : SearchTraverser
  • setBindShapeMatrix() : Skin
  • setBlendFunctions() : BlendAttribute
  • setBoolParameterValue() : CgFxEffect
  • setBorderColor() : TextureAttributeItem
  • setCallback() : PlugIn
  • setCamClipping() : RayIntersectTraverser
  • setCamera() : ViewState
  • setCameraAnimation() : AnimationManipulator
  • setCameraHeightAboveTerrain() : WalkCameraManipulator
  • setCenter() : LOD, Trafo, Spherent
  • setClassName() : SearchTraverser
  • setClipPlane() : RenderTraverser, GLTraverser, Group
  • setCollectRenderElements() : RenderTraverser
  • setColor() : UnlitColorAttribute, HighlightEdges, HighlightBox
  • setColors() : VertexAttributeSet
  • setCombineTargets() : CombineTraverser
  • setCreaseAngle() : SmoothTraverser
  • setCreationFlags() : TextureImage
  • setCullMode() : FaceAttribute
  • setCullTree() : ViewState
  • setCurrentStep() : LinearInterpolatedAnimation
  • setCurrentTechnique() : CgFxEffect
  • setCutoffAngle() : SpotLight
  • setData() : VolumeBrick, VertexAttribute
  • setDepthFunction() : DepthAttribute
  • setDepthTestingEnabled() : DepthAttribute
  • setDepthWritingEnabled() : DepthAttribute
  • setDiffuseColor() : Material, LightSource
  • setDirection() : SpotLight, DirectedLight, Camera
  • setDoFJitters() : ViewState
  • setDrawable() : HighlightObject
  • setEliminateTargets() : EliminateTraverser
  • setEmissiveColor() : Material
  • setEnabled() : VertexAttributeSet, LightSource, LightingAttribute
  • setEnabledDuringMultiSampleAlpha() : AlphaTestAttribute
  • setEnvColor() : TextureAttributeItem
  • setEnvMode() : TextureAttributeItem
  • setEnvScale() : TextureAttributeItem
  • setEpsilon() : VertexUnifyTraverser, UnifyTraverser
  • setFaceCulling() : RenderTraverser
  • setFaceCullingOverwrite() : RenderTraverser
  • setFaceMode() : RenderTraverser, FaceAttribute
  • setFaceModeOverwrite() : RenderTraverser
  • setFaces() : Triangles, Quads
  • setFalloffExponent() : SpotLight
  • setFarDistance() : Camera
  • setFieldOfView() : PerspectiveCamera
  • setFILE() : NVSGSaveTraverser
  • setFileName() : NBFSaveTraverser
  • setFileNames() : VolumeNode
  • setFloatParameterValue() : CgFxEffect
  • setFocusDistance() : PerspectiveCamera, Camera
  • setFogCoords() : VertexAttributeSet
  • setFrameNumber() : Scene
  • setFrontClipPlane() : VolumeNode, VolumeBrick
  • setFSAAJitters() : ViewState
  • setGeometryCacheTechnique() : RenderTraverser, GLTraverser
  • setHints() : NodeHintsCullTraverser, Node
  • setHSensitivity() : WalkCameraManipulator, FlightCameraManipulator
  • setIdentity() : Trafo
  • setIgnoreNames() : OptimizeTraverser
  • setImageData() : TextureImage
  • setInactive() : Switch
  • setIndices() : IndependentPrimitiveSet
  • setInfluenceData() : Skin
  • setIntensity() : LightSource
  • setIntParameterValue() : CgFxEffect
  • setInverse() : Bone
  • setJittersCombineMethod() : ViewState
  • setJitterTechnique() : RenderTraverser
  • setLightAmbientValue() : CgFxEffect
  • setLightConstantAttenuationValue() : CgFxEffect
  • setLightDiffuseValue() : CgFxEffect
  • setLightDirectionValue() : CgFxEffect
  • setLightLinearAttenuationValue() : CgFxEffect
  • setLightPositionValue() : CgFxEffect
  • setLightQuadraticAttenuationValue() : CgFxEffect
  • setLightSpecularValue() : CgFxEffect
  • setLightSpotCutoffValue() : CgFxEffect
  • setLightSpotExponentValue() : CgFxEffect
  • setLineAntiAliasing() : RenderTraverser
  • setLineWidth() : RenderTraverser, HighlightEdges, HighlightBox
  • setLocalViewer() : GLTraverser
  • setLODRangeScale() : ViewState
  • SetLogCallback() : NVNVB
  • setMagFilterMode() : TextureAttributeItem
  • setMap() : MapElement
  • setMapData() : Map
  • setMapList() : ViewState
  • setMasterShader() : VolumeBrick
  • setMaterialAmbientValue() : CgFxEffect
  • setMaterialDiffuseValue() : CgFxEffect
  • setMaterialEmissionValue() : CgFxEffect
  • setMaterialShininessValue() : CgFxEffect
  • setMaterialSpecularValue() : CgFxEffect
  • setMatrix() : Bone, Trafo
  • setMaximalNumberOfChildren() : BalanceTraverser
  • setMaximalNumberOfVertices() : BalanceTraverser
  • setMeshes() : MeshedPrimitiveSet
  • setMinFilterMode() : TextureAttributeItem
  • setMinimalLengths() : StrippingTraverser
  • setName() : Object
  • setNearDistance() : Camera
  • setNormal() : Planent
  • setNormalize() : AnimatedVertexAttributeSet
  • setNormalizeEnabled() : VertexAttributeSet
  • setNormals() : VertexAttributeSet
  • setObjectName() : SearchTraverser
  • setObjectPointer() : SearchTraverser
  • setOcclusionCullID() : RenderElement
  • setOcclusionCulling() : RenderTraverser
  • setOffset() : Planent
  • setOITMaxPasses() : RenderTraverser, GLTraverser
  • setOITTechnique() : RenderTraverser, GLTraverser
  • setOITThreshold() : RenderTraverser
  • setOpacity() : Material
  • setOrientation() : TextureAttributeItem, SpotLight, MapArray, DirectedLight, Camera, Trafo
  • setOverlapSize() : VolumeTexture
  • setParameterValueAsFloat() : CgFxEffect
  • setPlugInCallback() : NBFSaveTraverser
  • setPlugInFileFilter : PlugInServer
  • setPointAntiAliasing() : RenderTraverser
  • setPointSize() : RenderTraverser
  • setPolygonOffset() : FaceAttribute
  • setPosition() : SpotLight, PointLight, MapObject, Camera
  • setProgramProfile() : CgFxEffect
  • setRadius() : Spherent
  • setRangeLock() : LOD
  • setRanges() : LOD
  • setRay() : RayIntersectTraverser
  • setRelation() : MapObject
  • setRenderArea() : Manipulator
  • setRenderTechnique() : RenderTraverser
  • setRenderTraverser() : RenderArea
  • setRootNode() : Scene
  • setRotationAxis() : Billboard
  • setSamplerTextureGPUFormat() : CgFxEffect
  • setSamplerTextureImage() : CgFxEffect
  • setScaleOrientation() : Trafo
  • setScaling() : TextureAttributeItem, Trafo
  • setScene() : RenderArea, Traverser
  • setSceneAmbientValue() : CgFxEffect
  • setSceneData() : RenderArea
  • setSceneFrameNumberValue() : CgFxEffect
  • setScreenSize() : WalkCameraManipulator
  • setSecondaryColors() : VertexAttributeSet
  • setSegments() : Lines
  • setSeparateSpecularColor() : GLTraverser
  • setShader() : VolumeNode
  • setShadowCasting() : LightSource
  • setShadowMapIntensity() : RenderTraverser
  • setShadowMapSize() : RenderTraverser, GLTraverser
  • setShadowTechnique() : RenderTraverser, GLTraverser
  • setSize() : Trackball, PointAttribute
  • setSkin() : PrimitiveSet
  • setSkinningProcessor() : AppTraverser
  • setSkinningType() : Skin
  • setSkins() : SkinnedTriangles
  • setSliceThickness() : VolumeTexture
  • setSortingPolicy() : RenderTraverser
  • setSpacing() : MapMatrix, MapArray
  • setSpecularColor() : Material, LightSource
  • setSpecularExponent() : Material
  • setSpeed() : WalkCameraManipulator, FlightCameraManipulator
  • setSpeedIncreaseFactor() : WalkCameraManipulator, FlightCameraManipulator
  • setStateMachine() : CgFxContext
  • setStepsPerUnit() : WRLLoader
  • setStereo() : ViewState
  • setStereoAutomaticEyeDistanceAdjustment() : ViewState
  • setStereoAutomaticEyeDistanceFactor() : ViewState
  • setStereoEyeDistance() : ViewState
  • setStippleFactor() : LineAttribute
  • setStipplePattern() : LineAttribute
  • setStringParameterValue() : CgFxEffect
  • setStrips() : StrippedPrimitiveSet
  • setSubImagePixels() : TextureImage
  • setTargetDistance() : ViewState
  • setTexCoords() : VertexAttributeSet
  • setTexGenLinearPlane() : TextureAttributeItem
  • setTexGenMode() : TextureAttributeItem
  • setTextureGenericGPUFormat() : GLTraverser
  • setTextureGPUFormat() : TextureImage
  • setTextureImage() : TextureAttributeItem
  • setTextureSizeLimit() : RenderTraverser, GLTraverser
  • setTextureTarget() : TextureAttributeItem
  • setThreshold() : AlphaTestAttribute
  • setThrowExceptionOnError() : PlugInCallback
  • setTrafo() : Transform, AnimatedTransform
  • setTransformPath() : TransformManipulator
  • setTransforms() : RenderTraverser, GLTraverser
  • setTransformValue() : CgFxEffect
  • setTranslation() : TextureAttributeItem, Trafo
  • setTransparencyTechnique() : RenderTraverser, GLTraverser
  • setTraversalDirection() : MapMatrix, MapArray
  • setTwoSidedLighting() : RenderTraverser, FaceAttribute
  • setTwoSidedLightingOverwrite() : RenderTraverser
  • setUnifyTargets() : UnifyTraverser
  • setUpVector() : Camera
  • setUserData() : Object
  • setUserID() : DALData
  • setVertexAttributeIndex() : NormalizeTraverser
  • setVertexAttributeSet() : PrimitiveSet
  • setVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • setVertices() : VertexAttributeSet
  • setViewportSize() : GLMFCRAWnd, RenderArea, GLWinRenderArea, RayIntersectTraverser, ViewState
  • setViewState() : RenderArea, Traverser
  • setViewToClip() : TransformStack
  • setVoxelLimitFraction() : VolumeNode
  • setVSensitivity() : FlightCameraManipulator
  • setWeight() : Bone
  • setWidth() : LineAttribute
  • setWindowOffset() : Camera
  • setWindowRegion() : Camera
  • setWindowSize() : Camera
  • setWorldToView() : TransformStack
  • setWorldUpVector() : WalkCameraManipulator, FlightCameraManipulator
  • setWrapMode() : TextureAttributeItem
  • shader : NBFVolumeNode
  • ShadowTechnique : RenderTraverser
  • Shape() : Shape
  • SharedModelViewTraverser() : SharedModelViewTraverser
  • SharedTraverser() : SharedTraverser
  • shareLists() : GLWinRenderArea
  • shininess : NVSGMaterial
  • shortStrippedCount : ShortStrippedResult
  • shortStrippedNumber : ShortStrippedResult
  • signature : NBFHeader
  • singleChildCount : SingleChildResult
  • size : NBFPointAttribute, vertexAttrib_t
  • Skin() : Skin
  • skin : NBFPrimitiveSet
  • SkinnedTriangles() : SkinnedTriangles
  • skinningType : NBFSkin
  • skins : NBFSkinnedTriangles
  • SmoothTraverser() : SmoothTraverser
  • SortingPolicy : RenderTraverser
  • source : NBFCgFx
  • sourceFunction : NBFBlendAttribute
  • sourceObject : NBFObject
  • SP_DEPTH : RenderTraverser
  • SP_NONE : RenderTraverser
  • SP_STATE : RenderTraverser
  • specular : NVSGMaterial, NVSGLight
  • specularColor : NBFLightSource
  • speed : NBFAnimation
  • Spherent() : Spherent
  • spotCutoff : NVSGLight
  • spotExponent : NVSGLight
  • SpotLight() : SpotLight
  • ST_NONE : RenderTraverser
  • ST_SHADOW_MAP : RenderTraverser
  • stateAttribs : NBFStatePass
  • StateAttribute() : StateAttribute
  • StatePass() : StatePass
  • statePasses : NBFStateVariant
  • StateSet() : StateSet
  • stateSet : geometrySet_t
  • StateVariant() : StateVariant
  • stereoAutomaticFactor : NBFViewState
  • stereoEyeDistance : NBFViewState
  • stereoReverseEyes() : ViewState
  • stippleFactor : NBFLineAttribute
  • stipplePattern : NBFLineAttribute
  • storeDeviceAbstractionLinkData() : DALHost
  • storeIntersection() : RayIntersectTraverser
  • str : tweak_t
  • StrippedPrimitiveSet() : StrippedPrimitiveSet
  • StrippingTraverser() : StrippingTraverser
  • strips : NBFStrippedPrimitiveSet
  • swapData() : VertexAttribute
  • swapVertexData() : VertexAttributeSet
  • swinging : NBFAnimation
  • Switch() : Switch
  • SwitchMask : Switch
  • SWMRSync() : SWMRSync
  • systemHints : NBFNode
  • systemSpecificErrorCode : PlugInCallback::FileMappingFailedInfo, PlugInCallback::FileAccessFailedInfo

- t -

  • targetDistance : NBFViewState
  • testEntry() : MemFunTbl
  • texAttribItem : texBinding_t
  • texBorderColor : NBFTextureAttributeItem
  • texCoords : texCoordSet_t
  • texEnvColor : NBFTextureAttributeItem
  • texEnvMode : NBFTextureAttributeItem
  • texEnvScale : NBFTextureAttributeItem
  • texGenMode : NBFTextureAttributeItem
  • texGenPlane : NBFTextureAttributeItem
  • texImg : NBFTextureAttributeItem, sampler_t
  • texTarget : NBFTextureAttributeItem
  • TextureAttribute() : TextureAttribute
  • TextureAttributeItem() : TextureAttributeItem
  • TextureAttributeItemData() : TextureAttributeItemData
  • TextureGPUFormat : TextureImage
  • TextureImage() : TextureImage
  • texUnit : texBinding_t
  • texWrapR : NBFTextureAttributeItem
  • texWrapS : NBFTextureAttributeItem
  • texWrapT : NBFTextureAttributeItem
  • theAllocator : IAllocator
  • threshold : NBFAlphaTestAttribute
  • tilt() : WalkCameraManipulator
  • TILT : WalkCameraManipulator
  • toggleStereo() : ViewState
  • token : PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::EmptyTokenInfo
  • Trace() : Trace
  • Trackball() : Trackball
  • TrackballCameraManipulator() : TrackballCameraManipulator
  • TrackballTransformManipulator() : TrackballTransformManipulator
  • trafo : NBFTextureAttributeItem, NBFTransform
  • Trafo() : Trafo
  • TRAFO_MODEL : CgFxEffect
  • TRAFO_MODELI : CgFxEffect
  • TRAFO_MODELINVERSE : CgFxEffect
  • TRAFO_MODELINVERSETRANSPOSE : CgFxEffect
  • TRAFO_MODELIT : CgFxEffect
  • TRAFO_MODELT : CgFxEffect
  • TRAFO_MODELTRANSPOSE : CgFxEffect
  • TRAFO_MODELVIEW : CgFxEffect
  • TRAFO_MODELVIEWI : CgFxEffect
  • TRAFO_MODELVIEWINVERSE : CgFxEffect
  • TRAFO_MODELVIEWINVERSETRANSPOSE : CgFxEffect
  • TRAFO_MODELVIEWIT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTION : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONI : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONINVERSE : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONINVERSETRANSPOSE : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONIT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONTRANSPOSE : CgFxEffect
  • TRAFO_MODELVIEWT : CgFxEffect
  • TRAFO_MODELVIEWTRANSPOSE : CgFxEffect
  • TRAFO_PROJECTION : CgFxEffect
  • TRAFO_PROJECTIONI : CgFxEffect
  • TRAFO_PROJECTIONINVERSE : CgFxEffect
  • TRAFO_PROJECTIONINVERSETRANSPOSE : CgFxEffect
  • TRAFO_PROJECTIONIT : CgFxEffect
  • TRAFO_PROJECTIONT : CgFxEffect
  • TRAFO_PROJECTIONTRANSPOSE : CgFxEffect
  • TRAFO_UNKNOWN : CgFxEffect
  • TRAFO_VIEW : CgFxEffect
  • TRAFO_VIEWI : CgFxEffect
  • TRAFO_VIEWINVERSE : CgFxEffect
  • TRAFO_VIEWINVERSETRANSPOSE : CgFxEffect
  • TRAFO_VIEWIT : CgFxEffect
  • TRAFO_VIEWT : CgFxEffect
  • TRAFO_VIEWTRANSPOSE : CgFxEffect
  • TRAFO_WORLD : CgFxEffect
  • TRAFO_WORLDI : CgFxEffect
  • TRAFO_WORLDINVERSE : CgFxEffect
  • TRAFO_WORLDINVERSETRANSPOSE : CgFxEffect
  • TRAFO_WORLDIT : CgFxEffect
  • TRAFO_WORLDT : CgFxEffect
  • TRAFO_WORLDTRANSPOSE : CgFxEffect
  • TRAFO_WORLDVIEW : CgFxEffect
  • TRAFO_WORLDVIEWI : CgFxEffect
  • TRAFO_WORLDVIEWINVERSE : CgFxEffect
  • TRAFO_WORLDVIEWINVERSETRANSPOSE : CgFxEffect
  • TRAFO_WORLDVIEWIT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTION : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONI : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONINVERSE : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONINVERSETRANSPOSE : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONIT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONTRANSPOSE : CgFxEffect
  • TRAFO_WORLDVIEWT : CgFxEffect
  • TRAFO_WORLDVIEWTRANSPOSE : CgFxEffect
  • trafos : NBFTrafoAnimation
  • Transform() : Transform
  • TransformElement() : TransformElement
  • TransformManipulator() : TransformManipulator
  • TransformStack() : TransformStack
  • TransformType : CgFxEffect
  • translate() : WalkCameraManipulator
  • TRANSLATE : WalkCameraManipulator
  • translation : trafo_t
  • TransparencyTechnique : RenderTraverser
  • transparentBegin() : RenderTraverser, GLTraverser
  • transparentEnd() : RenderTraverser, GLTraverser
  • traverseCamera() : ExclusiveTraverser, SharedTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser
  • traverseGeoNode() : Traverser
  • traverseGroup() : Traverser
  • traverseHighlightObject() : ExclusiveTraverser, SharedTraverser
  • traverseLight() : ExclusiveTraverser, SharedTraverser, RenderTraverser
  • traverseMapList() : Traverser
  • traverseObject() : Traverser
  • traversePrimitiveSet() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, RenderTraverser, CullTraverser, AppTraverser, ExtractGeometryTraverser
  • Traverser() : Traverser
  • traverseShape() : Traverser
  • traverseStatePass() : Traverser
  • traverseStateVariant() : Traverser
  • traverseTextureAttribute() : Traverser
  • traverseVolumeNode() : Traverser
  • Triangles() : Triangles
  • TriangulateTraverser() : TriangulateTraverser
  • TriFans() : TriFans
  • triggerRedraw() : GLMFCRAWnd, RenderArea, GLWinRenderArea
  • TriStrips() : TriStrips
  • truncate() : Path
  • TT_BLENDED : RenderTraverser
  • TT_MULTISAMPLE : RenderTraverser
  • TT_NONE : RenderTraverser
  • TT_ORDER_INDEPENDENT : RenderTraverser
  • TT_SORTED_BLENDED : RenderTraverser
  • TT_STIPPLED : RenderTraverser
  • tweaks : NBFCgFx, tweak_t
  • twoSidedLighting : NBFFaceAttribute
  • type : tweak_t, vertexAttrib_t, NVSGTexImageFmt, GLTexImageFmt

- u -

  • unbindTextureAttributeItem() : TextureAttribute
  • UnifyTarget : UnifyTraverser
  • UnifyTraverser() : UnifyTraverser
  • UnlitColorAttribute() : UnlitColorAttribute
  • unloadPrograms() : CgFx
  • unlock() : CgFxContext
  • unlockExclusive() : SWMRSync
  • unlockObject() : ExclusiveTraverser, SharedTraverser, Traverser
  • unlockScene() : ExclusiveTraverser, SharedTraverser, Traverser
  • unlockShared() : SWMRSync
  • unlockViewState() : ExclusiveTraverser, SharedTraverser, Traverser, ExclusiveModelViewTraverser, SharedModelViewTraverser
  • unmapOffset() : PLYLoader, NBFLoader
  • update() : Boxnt
  • updateFrame() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, Manipulator, FlightCameraManipulator, AnimationManipulator
  • updateMatrices() : TransformElement
  • UPIID() : UPIID
  • UPITID() : UPITID
  • uploadHint : NVSGTexImageFmt, GLTexImageFmt
  • upVector : NBFCamera
  • userHints : NBFNode
  • usrFmt : NVSGTexImageFmt, GLTexImageFmt
  • UT_GEONODE : UnifyTraverser
  • UT_GROUP : UnifyTraverser
  • UT_LOD : UnifyTraverser
  • UT_PRIMITIVE_SET : UnifyTraverser
  • UT_STATE_ATTRIBUTE : UnifyTraverser
  • UT_STATE_PASS : UnifyTraverser
  • UT_STATE_SET : UnifyTraverser
  • UT_STATE_VARIANT : UnifyTraverser
  • UT_TEXTURE_ATTRIBUTE_ITEM : UnifyTraverser
  • UT_TRAFO_ANIMATION : UnifyTraverser
  • UT_VERTEX_ATTRIBUTE_SET : UnifyTraverser
  • UT_VERTICES : UnifyTraverser

- v -

  • validate() : Validated
  • validateCurrentTechnique() : CgFxEffect
  • Validated() : Validated
  • validateIncarnation() : VolumeNode, TextureAttribute, StateVariant, StateSet, StatePass, SkinnedTriangles, Shape, PrimitiveSet, Object, Node, MapList, LightSource, HighlightBox, Group, GeoNode, FlipbookAnimation, Drawable, Camera, AnimatedVertexAttributeSet, AnimatedTransform
  • value : PlugInCallback::InvalidValueInfo
  • value0 : PlugInCallback::IncompatibleValueInfo
  • value0Name : PlugInCallback::IncompatibleValueInfo
  • value1 : PlugInCallback::IncompatibleValueInfo
  • value1Name : PlugInCallback::IncompatibleValueInfo
  • valueName : PlugInCallback::InvalidValueInfo
  • valueType : PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo
  • variant : keyVariant_t
  • vattribs : NBFVertexAttributeSet
  • vdata : vertexAttrib_t
  • Vecnt() : Vecnt
  • verifyCreator() : DALData
  • vertex : skin_t
  • VertexAttribute() : VertexAttribute
  • VertexAttributeSet() : VertexAttributeSet
  • vertexAttributeSet : NBFPrimitiveSet
  • VertexUnifyTraverser() : VertexUnifyTraverser
  • vertices : VNVector
  • viewState : NBFHeader
  • ViewState() : ViewState
  • VolLoader() : VolLoader
  • VolSaver() : VolSaver
  • VolumeBrick() : VolumeBrick
  • volumeName : NBFVolumeNode
  • VolumeNode() : VolumeNode
  • VolumeTexture() : VolumeTexture
  • voxelLimitFraction : NBFVolumeNode

- w -

  • walk() : WalkCameraManipulator
  • WALKBACKWARD : WalkCameraManipulator
  • WalkCameraManipulator() : WalkCameraManipulator
  • WALKFORWARD : WalkCameraManipulator
  • wasRenderInterrupted() : RenderArea
  • wasTraversalInterrupted() : Traverser
  • weight : bone_t
  • weights : NBFSkin
  • WGLBindSwapBarrierNV : GLContext
  • WGLBindTexImage : GLContext
  • WGLChoosePixelFormat : GLContext
  • WGLCreateAffinityDC : GLContext
  • WGLCreateContext : GLContext
  • WGLCreatePbuffer : GLContext
  • WGLDeleteContext : GLContext
  • WGLDeleteDC : GLContext
  • WGLDestroyPbuffer : GLContext
  • WGLEnumGpuDevices : GLContext
  • WGLEnumGpus : GLContext
  • WGLEnumGpusFromAffinityDC : GLContext
  • WGLGetCurrentContext : GLContext
  • WGLGetCurrentDC : GLContext
  • WGLGetPbufferDC : GLContext
  • WGLJoinSwapGroupNV : GLContext
  • WGLQueryFrameCountNV : GLContext
  • WGLQueryMaxSwapGroupsNV : GLContext
  • WGLQueryPbuffer : GLContext
  • WGLQuerySwapGroupNV : GLContext
  • WGLReleasePbufferDC : GLContext
  • WGLReleaseTexImage : GLContext
  • WGLResetFrameCountNV : GLContext
  • width : NBFLineAttribute, texImage_t, meshSet_t
  • windowOffset : NBFCamera
  • windowSize : NBFCamera
  • writeAccess : RCIPtr, RCPtr
  • WriteMapping() : WriteMapping
  • WRLLoadTraverser() : WRLLoadTraverser

- y -

  • yearLastModified : NBFHeader

- z -

  • zoom() : Camera

- ~ -

  • ~Allocator() : Allocator
  • ~AlphaTestAttribute() : AlphaTestAttribute
  • ~AnalyzeResult() : AnalyzeResult
  • ~AnalyzeTraverser() : AnalyzeTraverser
  • ~AnimatedTransform() : AnimatedTransform
  • ~AnimatedVertexAttributeSet() : AnimatedVertexAttributeSet
  • ~Animation() : Animation
  • ~AnimationManipulator() : AnimationManipulator
  • ~AppTraverser() : AppTraverser
  • ~BalanceTraverser() : BalanceTraverser
  • ~BaseRenderElement() : BaseRenderElement
  • ~Billboard() : Billboard
  • ~BlendAttribute() : BlendAttribute
  • ~Bone() : Bone
  • ~CallbackServer() : CallbackServer
  • ~Camera() : Camera
  • ~CgFx() : CgFx
  • ~CgFxContext() : CgFxContext
  • ~CgFxEffect() : CgFxEffect
  • ~ChangeCallback() : ChangeCallback
  • ~CombineTraverser() : CombineTraverser
  • ~CullData() : CullData
  • ~CullTraverser() : CullTraverser
  • ~DepthAttribute() : DepthAttribute
  • ~DestrippingTraverser() : DestrippingTraverser
  • ~DirectedLight() : DirectedLight
  • ~Drawable() : Drawable
  • ~EliminateTraverser() : EliminateTraverser
  • ~EmptyResult() : EmptyResult
  • ~EquivalenceResult() : EquivalenceResult
  • ~ExclusiveModelViewTraverser() : ExclusiveModelViewTraverser
  • ~ExclusiveTraverser() : ExclusiveTraverser
  • ~ExtractGeometryTraverser() : ExtractGeometryTraverser
  • ~FaceAttribute() : FaceAttribute
  • ~FileMapping() : FileMapping
  • ~FixedAllocator() : FixedAllocator
  • ~FlightCameraManipulator() : FlightCameraManipulator
  • ~FlipbookAnimation() : FlipbookAnimation
  • ~FramedAnimation() : FramedAnimation
  • ~FrustumCullTraverser() : FrustumCullTraverser
  • ~GeoNode() : GeoNode
  • ~GLFunctions() : GLFunctions
  • ~GLMFCRAWnd() : GLMFCRAWnd
  • ~GLObjects() : GLObjects
  • ~GLTraverser() : GLTraverser
  • ~GLUploadTraverser() : GLUploadTraverser
  • ~GLWinRenderArea() : GLWinRenderArea
  • ~GPUSkinningProcessor() : GPUSkinningProcessor
  • ~Group() : Group
  • ~HighlightEdges() : HighlightEdges
  • ~HighlightElement() : HighlightElement
  • ~HighlightObject() : HighlightObject
  • ~IAllocator() : IAllocator
  • ~IdentityResult() : IdentityResult
  • ~IdentityToGroupTraverser() : IdentityToGroupTraverser
  • ~ILTexLoader() : ILTexLoader
  • ~IndependentPrimitiveSet() : IndependentPrimitiveSet
  • ~Intersection() : Intersection
  • ~KeyFramedAnimation() : KeyFramedAnimation
  • ~KeyInput() : KeyInput
  • ~LightingAttribute() : LightingAttribute
  • ~LightsElement() : LightsElement
  • ~LightSource() : LightSource
  • ~LinearInterpolatedAnimation() : LinearInterpolatedAnimation
  • ~LineAttribute() : LineAttribute
  • ~Lines() : Lines
  • ~LineStrips() : LineStrips
  • ~LOD() : LOD
  • ~Manipulator() : Manipulator
  • ~Map() : Map
  • ~MapArray() : MapArray
  • ~MapElement() : MapElement
  • ~MapList() : MapList
  • ~MapMatrix() : MapMatrix
  • ~MapObject() : MapObject
  • ~Material() : Material
  • ~MeshedPrimitiveSet() : MeshedPrimitiveSet
  • ~MissingResult() : MissingResult
  • ~MouseInput() : MouseInput
  • ~NBFLoader() : NBFLoader
  • ~Node() : Node
  • ~NodeHintsCullTraverser() : NodeHintsCullTraverser
  • ~NormalizeTraverser() : NormalizeTraverser
  • ~NullNormalsResult() : NullNormalsResult
  • ~NVBLoader() : NVBLoader
  • ~NVBLoadTraverser() : NVBLoadTraverser
  • ~Object() : Object
  • ~OptimizeTraverser() : OptimizeTraverser
  • ~OwnedObject() : OwnedObject
  • ~ParallelCamera() : ParallelCamera
  • ~Path() : Path
  • ~PerspectiveCamera() : PerspectiveCamera
  • ~PlugInCallback() : PlugInCallback
  • ~PointAttribute() : PointAttribute
  • ~PointLight() : PointLight
  • ~Points() : Points
  • ~PrimitiveAttribute() : PrimitiveAttribute
  • ~PrimitiveSet() : PrimitiveSet
  • ~QuadMeshes() : QuadMeshes
  • ~Quads() : Quads
  • ~QuadStrips() : QuadStrips
  • ~RayIntersectTraverser() : RayIntersectTraverser
  • ~RCIPtr() : RCIPtr
  • ~RCObject() : RCObject
  • ~RCObject_AutoPtr() : RCObject_AutoPtr
  • ~RCPtr() : RCPtr
  • ~ReadMapping() : ReadMapping
  • ~RedundantLODRangesResult() : RedundantLODRangesResult
  • ~RegVal() : RegVal
  • ~RenderArea() : RenderArea
  • ~RenderElement() : RenderElement
  • ~RenderTraverser() : RenderTraverser
  • ~Scene() : Scene
  • ~SceneLoader() : SceneLoader
  • ~SceneSaver() : SceneSaver
  • ~SearchTraverser() : SearchTraverser
  • ~Shape() : Shape
  • ~SharedModelViewTraverser() : SharedModelViewTraverser
  • ~SharedTraverser() : SharedTraverser
  • ~SingleChildResult() : SingleChildResult
  • ~Skin() : Skin
  • ~SkinnedTriangles() : SkinnedTriangles
  • ~SmoothTraverser() : SmoothTraverser
  • ~SpotLight() : SpotLight
  • ~StateAttribute() : StateAttribute
  • ~StatePass() : StatePass
  • ~StateSet() : StateSet
  • ~StateVariant() : StateVariant
  • ~StrippedPrimitiveSet() : StrippedPrimitiveSet
  • ~StrippingTraverser() : StrippingTraverser
  • ~Switch() : Switch
  • ~SWMRSync() : SWMRSync
  • ~TextureAttribute() : TextureAttribute
  • ~TextureAttributeItem() : TextureAttributeItem
  • ~TextureImage() : TextureImage
  • ~TextureLoader() : TextureLoader
  • ~TextureSaver() : TextureSaver
  • ~Trace() : Trace
  • ~Trackball() : Trackball
  • ~TrackballCameraManipulator() : TrackballCameraManipulator
  • ~TrackballTransformManipulator() : TrackballTransformManipulator
  • ~Transform() : Transform
  • ~TransformManipulator() : TransformManipulator
  • ~Traverser() : Traverser
  • ~Triangles() : Triangles
  • ~TriangulateTraverser() : TriangulateTraverser
  • ~TriFans() : TriFans
  • ~TriStrips() : TriStrips
  • ~UnifyTraverser() : UnifyTraverser
  • ~UnlitColorAttribute() : UnlitColorAttribute
  • ~VertexAttribute() : VertexAttribute
  • ~VertexAttributeSet() : VertexAttributeSet
  • ~VertexUnifyTraverser() : VertexUnifyTraverser
  • ~ViewState() : ViewState
  • ~VolLoader() : VolLoader
  • ~VolSaver() : VolSaver
  • ~VolumeBrick() : VolumeBrick
  • ~VolumeNode() : VolumeNode
  • ~VolumeTexture() : VolumeTexture
  • ~WalkCameraManipulator() : WalkCameraManipulator
  • ~WriteMapping() : WriteMapping
  • ~WRLLoadTraverser() : WRLLoadTraverser
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions

  • Alignment : Billboard
  • CgFxStateMachineEnum : CgFxContext
  • GeometryCacheTechnique : RenderTraverser
  • ISType : RayIntersectTraverser
  • JitterCombineTechnique : ViewState
  • JitterTechnique : RenderTraverser
  • NodeHints : Node
  • OITTechnique : RenderTraverser
  • PIC_ERROR : PlugInCallback
  • PIC_TYPE_ID : PlugInCallback
  • PIC_WARNING : PlugInCallback
  • PixelDataType : Image
  • PixelFormat : Image
  • ProgramIOType : CgFxEffect
  • RenderTechnique : RenderTraverser
  • ShadowTechnique : RenderTraverser
  • SortingPolicy : RenderTraverser
  • TextureGPUFormat : TextureImage
  • TransformType : CgFxEffect
  • TransparencyTechnique : RenderTraverser
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions
_ | b | c | e | f | g | i | j | n | o | p | r | s | t | u

- _ -

  • _BSFAR : RayIntersectTraverser
  • _BSNEAR : RayIntersectTraverser
  • _BSNEARFAR : RayIntersectTraverser
  • _BSTANGENT : RayIntersectTraverser
  • _CONTROL_KEY : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator
  • _LEFT_MOUSE_BTN : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • _MIDDLE_MOUSE_BTN : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • _NO_BTN_KEY : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • _NONE : RayIntersectTraverser
  • _S_KEY : WalkCameraManipulator, FlightCameraManipulator
  • _SHIFT_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _W_KEY : WalkCameraManipulator, FlightCameraManipulator
  • _X_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _Y_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _Z_KEY : TrackballCameraManipulator

- b -

  • BA_AXIS : Billboard
  • BA_SCREEN : Billboard
  • BA_VIEWER : Billboard
  • BT_CHILDREN : BalanceTraverser
  • BT_VERTICES : BalanceTraverser

- c -

  • CGFX_STATE_MACHINE_GL : CgFxContext
  • CGFX_STATE_MACHINE_INVALID : CgFxContext
  • CT_GEONODE : CombineTraverser
  • CT_LOD : CombineTraverser
  • CT_LOD_RANGES : CombineTraverser
  • CT_PRIMITIVE_SET : CombineTraverser
  • CT_TRANSFORM : CombineTraverser

- e -

  • ET_GROUP : EliminateTraverser
  • ET_LOD : EliminateTraverser
  • ET_STATE_PASS : EliminateTraverser
  • ET_STATE_SET : EliminateTraverser
  • ET_STATE_VARIANT : EliminateTraverser
  • ET_TEXTURE_ATTRIBUTE : EliminateTraverser
  • ET_TEXTURE_ATTRIBUTE_ITEM : EliminateTraverser

- f -

  • F_IMAGE_STREAM : TextureImage
  • F_NO_IMAGE_CREATION : TextureImage
  • F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD : TextureImage
  • F_SCALE_FILTER_BELL : TextureImage
  • F_SCALE_FILTER_BOX : TextureImage
  • F_SCALE_FILTER_BSPLINE : TextureImage
  • F_SCALE_FILTER_LANCZOS3 : TextureImage
  • F_SCALE_FILTER_TRIANGLE : TextureImage
  • F_SCALE_POT_ABOVE : TextureImage
  • F_SCALE_POT_BELOW : TextureImage
  • F_SCALE_POT_NEAREST : TextureImage

- g -

  • GCT_DL : RenderTraverser
  • GCT_NONE : RenderTraverser
  • GCT_VBO : RenderTraverser

- i -

  • IMG_ALPHA : Image
  • IMG_BGR : Image
  • IMG_BGRA : Image
  • IMG_BYTE : Image
  • IMG_COLOR_INDEX : Image
  • IMG_DEPTH_COMPONENT : Image
  • IMG_DEPTH_STENCIL : Image
  • IMG_FLOAT16 : Image
  • IMG_FLOAT32 : Image
  • IMG_INT : Image
  • IMG_LUMINANCE : Image
  • IMG_LUMINANCE_ALPHA : Image
  • IMG_NUM_FORMATS : Image
  • IMG_NUM_TYPES : Image
  • IMG_RGB : Image
  • IMG_RGBA : Image
  • IMG_SHORT : Image
  • IMG_UNKNOWN_FORMAT : Image
  • IMG_UNKNOWN_TYPE : Image
  • IMG_UNSIGNED_BYTE : Image
  • IMG_UNSIGNED_INT : Image
  • IMG_UNSIGNED_INT_10F_11F_11F : Image
  • IMG_UNSIGNED_INT_24_8 : Image
  • IMG_UNSIGNED_INT_2_10_10_10 : Image
  • IMG_UNSIGNED_INT_5_9_9_9 : Image
  • IMG_UNSIGNED_SHORT : Image

- j -

  • JCT_CROSS_PRODUCT : ViewState
  • JCT_HIGHER_PASS : ViewState
  • JCT_NONE : ViewState
  • JT_ACCUM : RenderTraverser
  • JT_FBO : RenderTraverser
  • JT_NONE : RenderTraverser
  • JT_PBUFFER : RenderTraverser
  • JT_READ_PIXELS : RenderTraverser

- n -

  • NH_CULL_ALWAYS : Node
  • NH_CULL_MASK : Node
  • NH_CULL_NEVER : Node
  • NH_CUSTOM_BITS : Node
  • NH_MODIFY_FREQUENCY_HIGH : Node
  • NH_MODIFY_FREQUENCY_LOW : Node
  • NH_MODIFY_FREQUENCY_MASK : Node
  • NH_NO_SHADOW_CASTER : Node
  • NH_NO_SHADOW_RECEIVER : Node
  • NH_OVERLAY : Node
  • NH_RESERVED_BITS : Node
  • NVSG_MULTISAMPLE : RenderArea
  • NVSG_STEREO : RenderArea

- o -

  • OT_FBO : RenderTraverser
  • OT_PBUFFER : RenderTraverser
  • OT_TEXTURE : RenderTraverser

- p -

  • PROGRAM_IO_FRAGMENT : CgFxEffect
  • PROGRAM_IO_LINE : CgFxEffect
  • PROGRAM_IO_LINE_ADJ : CgFxEffect
  • PROGRAM_IO_POINT : CgFxEffect
  • PROGRAM_IO_TRIANGLE : CgFxEffect
  • PROGRAM_IO_TRIANGLE_ADJ : CgFxEffect
  • PROGRAM_IO_VERTEX : CgFxEffect

- r -

  • RT_EFFECTED : RenderTraverser
  • RT_SHADED : RenderTraverser
  • RT_TEXTURED : RenderTraverser
  • RT_UNLIT : RenderTraverser

- s -

  • SP_DEPTH : RenderTraverser
  • SP_NONE : RenderTraverser
  • SP_STATE : RenderTraverser
  • ST_NONE : RenderTraverser
  • ST_SHADOW_MAP : RenderTraverser

- t -

  • TRAFO_MODEL : CgFxEffect
  • TRAFO_MODELI : CgFxEffect
  • TRAFO_MODELINVERSE : CgFxEffect
  • TRAFO_MODELINVERSETRANSPOSE : CgFxEffect
  • TRAFO_MODELIT : CgFxEffect
  • TRAFO_MODELT : CgFxEffect
  • TRAFO_MODELTRANSPOSE : CgFxEffect
  • TRAFO_MODELVIEW : CgFxEffect
  • TRAFO_MODELVIEWI : CgFxEffect
  • TRAFO_MODELVIEWINVERSE : CgFxEffect
  • TRAFO_MODELVIEWINVERSETRANSPOSE : CgFxEffect
  • TRAFO_MODELVIEWIT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTION : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONI : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONINVERSE : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONINVERSETRANSPOSE : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONIT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONTRANSPOSE : CgFxEffect
  • TRAFO_MODELVIEWT : CgFxEffect
  • TRAFO_MODELVIEWTRANSPOSE : CgFxEffect
  • TRAFO_PROJECTION : CgFxEffect
  • TRAFO_PROJECTIONI : CgFxEffect
  • TRAFO_PROJECTIONINVERSE : CgFxEffect
  • TRAFO_PROJECTIONINVERSETRANSPOSE : CgFxEffect
  • TRAFO_PROJECTIONIT : CgFxEffect
  • TRAFO_PROJECTIONT : CgFxEffect
  • TRAFO_PROJECTIONTRANSPOSE : CgFxEffect
  • TRAFO_UNKNOWN : CgFxEffect
  • TRAFO_VIEW : CgFxEffect
  • TRAFO_VIEWI : CgFxEffect
  • TRAFO_VIEWINVERSE : CgFxEffect
  • TRAFO_VIEWINVERSETRANSPOSE : CgFxEffect
  • TRAFO_VIEWIT : CgFxEffect
  • TRAFO_VIEWT : CgFxEffect
  • TRAFO_VIEWTRANSPOSE : CgFxEffect
  • TRAFO_WORLD : CgFxEffect
  • TRAFO_WORLDI : CgFxEffect
  • TRAFO_WORLDINVERSE : CgFxEffect
  • TRAFO_WORLDINVERSETRANSPOSE : CgFxEffect
  • TRAFO_WORLDIT : CgFxEffect
  • TRAFO_WORLDT : CgFxEffect
  • TRAFO_WORLDTRANSPOSE : CgFxEffect
  • TRAFO_WORLDVIEW : CgFxEffect
  • TRAFO_WORLDVIEWI : CgFxEffect
  • TRAFO_WORLDVIEWINVERSE : CgFxEffect
  • TRAFO_WORLDVIEWINVERSETRANSPOSE : CgFxEffect
  • TRAFO_WORLDVIEWIT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTION : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONI : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONINVERSE : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONINVERSETRANSPOSE : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONIT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONTRANSPOSE : CgFxEffect
  • TRAFO_WORLDVIEWT : CgFxEffect
  • TRAFO_WORLDVIEWTRANSPOSE : CgFxEffect
  • TT_BLENDED : RenderTraverser
  • TT_MULTISAMPLE : RenderTraverser
  • TT_NONE : RenderTraverser
  • TT_ORDER_INDEPENDENT : RenderTraverser
  • TT_SORTED_BLENDED : RenderTraverser
  • TT_STIPPLED : RenderTraverser

- u -

  • UT_GEONODE : UnifyTraverser
  • UT_GROUP : UnifyTraverser
  • UT_LOD : UnifyTraverser
  • UT_PRIMITIVE_SET : UnifyTraverser
  • UT_STATE_ATTRIBUTE : UnifyTraverser
  • UT_STATE_PASS : UnifyTraverser
  • UT_STATE_SET : UnifyTraverser
  • UT_STATE_VARIANT : UnifyTraverser
  • UT_TEXTURE_ATTRIBUTE_ITEM : UnifyTraverser
  • UT_TRAFO_ANIMATION : UnifyTraverser
  • UT_VERTEX_ATTRIBUTE_SET : UnifyTraverser
  • UT_VERTICES : UnifyTraverser
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions
a | b | c | d | e | f | g | h | i | k | l | m | n | o | p | q | r | s | t | u | v | w | z | ~

- a -

  • activateClipPlane() : Group
  • addAsParentTo() : Node
  • addAttribute() : StateVariant, StateSet, StatePass
  • addCallback() : CallbackServer
  • addCamera() : Scene
  • addCameraAnimation() : Scene
  • addChild() : Group, CullData
  • addClipPlane() : Group
  • addEmptyColumn() : MapMatrix
  • addEntry() : MemFunTbl
  • addGeometry() : GeoNode
  • addHeadLight() : Camera
  • addHighlightObject() : HighlightElement
  • addHints() : NodeHintsCullTraverser, Node
  • addImage() : TextureImage
  • addItem() : SearchTraverser
  • addJoint() : Skin
  • addKey() : KeyFramedAnimation
  • addKeys() : KeyFramedAnimation
  • addLight() : LightsElement
  • addLightSource() : Group
  • addMap() : MapMatrix, MapArray
  • addMapObject() : MapList
  • addMask() : Switch
  • addObjectHandler() : ExclusiveTraverser, SharedTraverser
  • addObjectRenderer() : RenderTraverser
  • addOnDestroyCallback() : RCObject
  • addOwner() : OwnedObject
  • addPass() : StateVariant, StateSet
  • addPrimitiveSet() : RenderElement, Shape
  • addRef() : RCObject, BaseRenderElement
  • addStep() : FramedAnimation
  • addSteps() : FramedAnimation
  • addVariant() : StateSet
  • advanceAnimation() : ViewState
  • alloc() : Allocator, FixedAllocator, Chunk, NBFSaveTraverser
  • Allocator() : Allocator
  • AlphaTestAttribute() : AlphaTestAttribute
  • AnalyzeTraverser() : AnalyzeTraverser
  • AnimatedTransform() : AnimatedTransform
  • AnimatedVertexAttributeSet() : AnimatedVertexAttributeSet
  • Animation() : Animation
  • AnimationManipulator() : AnimationManipulator
  • apply() : Trackball, Traverser
  • applyPass() : CgFxEffect
  • AppTraverser() : AppTraverser
  • assertInvalidBoundingSphere() : Node
  • assignCustomLightToEffectLight() : RenderTraverser
  • assignDirectedLightToEffectLight() : RenderTraverser, GLTraverser
  • assignPointLightToEffectLight() : RenderTraverser, GLTraverser
  • assignSpotLightToEffectLight() : RenderTraverser, GLTraverser
  • attachHighlightObject() : Drawable
  • attachWindow() : GLWinRenderArea

- b -

  • balance() : CullData
  • BalanceTraverser() : BalanceTraverser
  • BaseRenderElement() : BaseRenderElement
  • beginEdit() : Handle< T, NullType >
  • beginOcclusionCullQuery() : RenderTraverser, GLTraverser
  • beginRead() : Handle< T, NullType >
  • Billboard() : Billboard
  • bindTextureAttributeItem() : TextureAttribute
  • BlendAttribute() : BlendAttribute
  • blocksAvailable() : Chunk
  • Bone() : Bone
  • Boxnt() : Boxnt

- c -

  • calcNearFarDistances() : Camera
  • calculateBoundingBox() : VolumeNode, Transform, Switch, StrippedPrimitiveSet, Shape, Node, MeshedPrimitiveSet, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, Drawable
  • calculateBoundingSphere() : VolumeNode, Transform, Switch, StrippedPrimitiveSet, Shape, Node, MeshedPrimitiveSet, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, Drawable
  • calculateTangentSpace() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • calculatingStorageRequirements() : NBFSaveTraverser
  • callback() : PlugIn
  • CallbackServer() : CallbackServer
  • Camera() : Camera
  • CgFx() : CgFx
  • CgFxContext() : CgFxContext
  • CgFxEffect() : CgFxEffect
  • ChangeCallback() : ChangeCallback
  • changed() : ChangeCallback, CallbackServer
  • checkClipPlanes() : RayIntersectTraverser
  • checkIntersection() : RayIntersectTraverser
  • Chunk() : Chunk
  • clear() : MapList, MapArray
  • clearCullTree() : ViewState
  • clearGeometries() : GeoNode
  • clearHeadLights() : Camera
  • clearRenderLists() : RenderTraverser
  • clearTexCoords() : GeoNode
  • ClipPlanesElement() : ClipPlanesElement
  • clone() : CullData, Handle< T, Handle< U, V > >, Handle< T, NullType >, Intersection
  • CombineTraverser() : CombineTraverser
  • compileProgram() : CgFxEffect
  • containsAnimation() : VertexAttributeSet, SkinnedTriangles, Scene, PrimitiveSet, Node, Drawable, AnimatedVertexAttributeSet
  • containsCgFx() : StateVariant, StateSet, StatePass, Scene, Node
  • containsHints() : Node
  • containsLight() : Scene, Node
  • containsLOD() : Node
  • containsTransparentGeometry() : Scene, Node
  • containsVolumeNode() : Node
  • convert2DToCubeMap() : TextureImage
  • convertPixelFormat() : TextureImage
  • CPUSkinningProcessor() : CPUSkinningProcessor
  • createFromFile() : TextureImage, CgFx, CgFxEffect
  • createFromLump() : CgFx, CgFxEffect
  • createImage() : TextureImage
  • createMipmaps() : TextureImage
  • createNewRenderAreaID() : RenderArea
  • createOcclusionCullID() : RenderTraverser, GLTraverser
  • createTextureImageHandle() : TextureLoader, VolLoader
  • cullCode() : NodeHintsCullTraverser, FrustumCullTraverser, CullTraverser
  • CullData() : CullData
  • CullTraverser() : CullTraverser

- d -

  • DALData() : DALData
  • deactivateClipPlane() : Group
  • dealloc() : Allocator, FixedAllocator, Chunk, NBFSaveTraverser
  • decrementJointCount() : Transform
  • decrementMipmapUseCount() : TextureImage
  • deleteThis() : PlugIn, DALData, VolSaver, OBJSaver, NVSGSaver, NBFSaver, ILTexSaver, WRLLoader, VolLoader, PLYLoader, NVSGLoader, NVBLoader, NBFLoader, ILTexLoader
  • demandUpload() : TextureImage
  • DepthAttribute() : DepthAttribute
  • DestrippingTraverser() : DestrippingTraverser
  • destroy() : GLMFCRAWnd, RenderArea, GLWinRenderArea
  • destroyOcclusionCullID() : RenderTraverser, GLTraverser
  • determineActiveBricks() : VolumeNode
  • determineAnimationContainment() : Node, Group, GeoNode, FlipbookAnimation, AnimatedTransform
  • determineCgFxContainment() : VolumeNode, Switch, Node, Group, GeoNode
  • determineCullCode() : PerspectiveCamera, ParallelCamera, Camera
  • determineHintsContainment() : Switch, Node, Group
  • determineLightContainment() : Switch, Node, Group
  • determineLODContainment() : Switch, Node, LOD, Group
  • determineTransparencyContainment() : VolumeNode, Switch, Node, Group, GeoNode
  • determineVolumeNodeContainment() : VolumeNode, Switch, Node, Group
  • DirectedLight() : DirectedLight
  • disableHWFSAA() : GLWinRenderArea
  • doApply() : VertexUnifyTraverser, UnifyTraverser, ExclusiveTraverser, SharedTraverser, Traverser, SmoothTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, OptimizeTraverser, NormalizeTraverser, GLUploadTraverser, GLTraverser, FrustumCullTraverser, EliminateTraverser, DestrippingTraverser, CullTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • dolly() : TrackballTransformManipulator, TrackballCameraManipulator
  • doRender() : RenderTraverser, GLUploadTraverser, GLTraverser
  • Drawable() : Drawable
  • dumpIntersectionList() : RayIntersectTraverser

- e -

  • effectChanged() : VolumeNode
  • EliminateTraverser() : EliminateTraverser
  • enableHWFSAA() : GLWinRenderArea
  • endEdit() : Handle< T, NullType >
  • EndImport() : NVNVB
  • endOcclusionCullQuery() : RenderTraverser, GLTraverser
  • endRead() : Handle< T, NullType >
  • enterCS() : Object
  • evaluateAnimation() : SkinnedTriangles
  • evaluateCullTree() : Traverser
  • ExclusiveModelViewTraverser() : ExclusiveModelViewTraverser
  • ExclusiveTraverser() : ExclusiveTraverser
  • ExtractGeometryTraverser() : ExtractGeometryTraverser

- f -

  • FaceAttribute() : FaceAttribute
  • FileMapping() : FileMapping
  • findTerrainPosition() : WalkCameraManipulator
  • finishUpload() : TextureImage
  • FixedAllocator() : FixedAllocator
  • FlightCameraManipulator() : FlightCameraManipulator
  • FlipbookAnimation() : FlipbookAnimation
  • fly() : FlightCameraManipulator
  • forcePixelFormat() : GLWinRenderArea
  • forceTraversal() : AppTraverser
  • format() : TraceFunctor, Log
  • FramedAnimation() : FramedAnimation
  • freeMemory() : Chunk
  • FrustumCullTraverser() : FrustumCullTraverser

- g -

  • generateNormals() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • generateTexCoords() : VertexAttributeSet, GeoNode
  • GeoNode() : GeoNode
  • get() : Validated, RCObject_AutoPtr
  • getActive() : Switch
  • getActiveBricks() : VolumeNode
  • getActiveMask() : Switch
  • getActiveVariant() : StateSet
  • getActiveVariantKey() : StateSet
  • getAlignment() : MapMatrix, MapArray, Billboard
  • getAlphaFunction() : AlphaTestAttribute
  • getAmbientColor() : Scene, Material, LightSource
  • getAnalysis() : AnalyzeTraverser
  • getAnimation() : Bone, LightSource, FlipbookAnimation, AnimatedVertexAttributeSet, AnimatedTransform
  • getAnnotation() : Object
  • getAnnotationName() : CgFxEffect
  • getAnnotationTypeString() : CgFxEffect
  • getAnnotationValueSize() : CgFxEffect
  • getAppTraverser() : RenderArea
  • getArrayParameterElement() : CgFxEffect
  • getAspectRatio() : RenderArea, Camera
  • getAttenuation() : SpotLight, PointLight
  • getAttribute() : StateVariant, StateSet, StatePass
  • getAttributeByObjectCode() : StateVariant, StateSet, StatePass
  • getAttributeIndex() : StateVariant, StateSet, StatePass
  • getBackColor() : Scene
  • getBackFaceMode() : FaceAttribute
  • getBackImage() : Scene
  • getBalanceTargets() : BalanceTraverser
  • getBindShapeMatrix() : Skin
  • getBoolAnnotationValue() : CgFxEffect
  • getBoolParameterValue() : CgFxEffect
  • getBoolPassStateValue() : CgFxEffect
  • getBoolSamplerStateValue() : CgFxEffect
  • getBorderColor() : TextureAttributeItem
  • getBoundingBox() : Node, HighlightObject, Drawable
  • getBoundingSphere() : Node, HighlightObject, Drawable
  • getBrickBox() : VolumeBrick
  • getBrickData() : VolumeBrick
  • getBricksOverallSize() : VolumeNode
  • getBrickTextureSize() : VolumeNode
  • getButtonState() : MouseInput
  • getBytesPerPixel() : TextureImage
  • getBytesPerPlane() : TextureImage
  • getBytesPerScanLine() : TextureImage
  • getCamera() : ViewState, Scene
  • getCameraAnimation() : Scene
  • getCameraHeightAboveTerrain() : WalkCameraManipulator
  • getCenter() : LOD, Trafo, Spherent
  • getChild() : Group, CullData
  • getChildPositions() : Group
  • getClipPlane() : ClipPlanesElement, Group
  • getClipPlanes() : RenderElement, HighlightElement
  • getClipToModel() : TransformStack
  • getClipToView() : TransformStack
  • getCollectRenderElements() : RenderTraverser
  • getColor() : UnlitColorAttribute, HighlightEdges, HighlightBox
  • getColors() : VertexAttributeSet
  • getCombineTargets() : CombineTraverser
  • getContainmentFlags() : Node
  • getContainmentValidFlags() : Node
  • getContext() : CgFxEffect
  • getCounts() : Skin
  • getCreationFlags() : TextureImage
  • getCullCode() : CullData
  • getCullTraverser() : RenderArea
  • getCullTree() : ViewState
  • getCurrentCgFx() : RenderTraverser
  • getCurrentChild() : FlipbookAnimation
  • getCurrentDelta() : ViewState
  • getCurrentHints() : CullTraverser
  • getCurrentHintsContainment() : CullTraverser
  • getCurrentTechnique() : CgFxEffect
  • getCurrentTick() : ViewState
  • getCurrentValue() : LinearInterpolatedAnimation, KeyFramedAnimation, FramedAnimation, Animation
  • getCurrentX() : MouseInput
  • getCurrentY() : MouseInput
  • getCutoffAngle() : SpotLight
  • getData() : VertexAttribute, Map
  • getDataID() : VertexAttributeSet, TextureAttributeItem, StrippedPrimitiveSet, SkinnedTriangles, Object, MeshedPrimitiveSet, Material, IndependentPrimitiveSet, CgFx
  • getDepth() : TextureImage
  • getDepthFunction() : DepthAttribute
  • getDestinationFunction() : BlendAttribute
  • getDeviceAbstractionLinkData() : DALHost
  • getDiffuseColor() : Material, LightSource
  • getDirection() : SpotLight, DirectedLight, Camera
  • getDisplay() : GLContext
  • getDist() : Intersection
  • getDoFJitters() : ViewState
  • getDrawable() : Intersection, HighlightObject, GeoNode
  • getEffect() : CgFx
  • getEliminateTargets() : EliminateTraverser
  • getEmissiveColor() : Material
  • getEnabled() : LightingAttribute
  • getEnabledDuringMultiSampleAlpha() : AlphaTestAttribute
  • getEntrySize() : MapMatrix, MapArray
  • getEnvColor() : TextureAttributeItem
  • getEnvMode() : TextureAttributeItem
  • getEnvScale() : TextureAttributeItem
  • getEpsilon() : UnifyTraverser
  • getErrorMessage() : NVSGException
  • getFaceMode() : RenderTraverser
  • getFaces() : Triangles, Quads
  • getFalloffExponent() : SpotLight
  • getFarDistance() : Camera
  • getFieldOfView() : PerspectiveCamera
  • getFileInfo() : VolLoader
  • getFileName() : TextureImage, CgFxEffect
  • getFirstItem() : TextureAttribute
  • getFirstMaskIterator() : Switch
  • getFirstVariantIterator() : StateSet
  • getFloatAnnotationValue() : CgFxEffect
  • getFloatParameterValue() : CgFxEffect
  • getFloatPassStateValue() : CgFxEffect
  • getFloatSamplerStateValue() : CgFxEffect
  • getFocusDistance() : Camera
  • getFogCoords() : VertexAttributeSet
  • getFormat() : TextureImage
  • getFragmentProgram() : CgFxEffect
  • getFrameNumber() : Scene
  • getFrameValue() : Animation
  • getFromHead() : Path
  • getFromTail() : Path
  • getFrontClipPlane() : VolumeNode
  • getFrontFaceMode() : FaceAttribute
  • getFrontPlane() : VolumeBrick
  • getFSAAJitters() : ViewState
  • getGeometryCacheTechnique() : RenderTraverser
  • getGeometryProgram() : CgFxEffect
  • getGroup() : LightsElement, ClipPlanesElement
  • getHead() : Path
  • getHeadLight() : Camera
  • getHeight() : TextureImage, Map
  • getHigherLevelObjectCode() : Object
  • getHighlightObject() : HighlightElement, Drawable
  • getHints() : NodeHintsCullTraverser, Node
  • getHintsContainment() : Node
  • getHSensitivity() : WalkCameraManipulator, FlightCameraManipulator
  • getIgnoreNames() : OptimizeTraverser
  • getIncarnation() : ViewState, Object
  • getIndexOfMap() : MapMatrix, MapArray
  • getIndices() : Skin, IndependentPrimitiveSet
  • getIntAnnotationValue() : CgFxEffect
  • getIntensity() : LightSource
  • getIntersections() : RayIntersectTraverser
  • getIntParameterValue() : CgFxEffect
  • getIntPassStateValue() : CgFxEffect
  • getIntSamplerStateValue() : CgFxEffect
  • getInverse() : LightSource, Trafo
  • getInverseBindMatrix() : Skin
  • getInverseProjection() : PerspectiveCamera, ParallelCamera, Camera
  • getIsp() : Intersection
  • getJitters() : ViewState
  • getJittersCombineMethod() : ViewState
  • getJitterTechnique() : RenderTraverser
  • getJoint() : Skin
  • getKey() : KeyFramedAnimation
  • getKeyState() : KeyInput
  • getKeyStep() : KeyFramedAnimation
  • getKeySteps() : KeyFramedAnimation
  • getKeyValue() : KeyFramedAnimation
  • getKeyValues() : KeyFramedAnimation
  • getLastError() : FileMapping
  • getLastMaskIterator() : Switch
  • getLastRecentlyUsedDeviceAbstractionLinkData() : DALHost
  • getLastVariantIterator() : StateSet
  • getLastX() : MouseInput
  • getLastY() : MouseInput
  • getLength() : Path
  • getLight() : LightsElement, CgFxEffect
  • getLightAmbientValue() : CgFxEffect
  • getLightByName() : CgFxEffect
  • getLightBySemantic() : CgFxEffect
  • getLightConstantAttenuationValue() : CgFxEffect
  • getLightDiffuseValue() : CgFxEffect
  • getLightDirectionValue() : CgFxEffect
  • getLightLinearAttenuationValue() : CgFxEffect
  • getLightPositionValue() : CgFxEffect
  • getLightQuadraticAttenuationValue() : CgFxEffect
  • getLights() : RenderElement
  • getLightSource() : Group
  • getLightSpecularValue() : CgFxEffect
  • getLightSpotCutoffValue() : CgFxEffect
  • getLightSpotExponentValue() : CgFxEffect
  • getLineWidth() : RenderTraverser, HighlightEdges, HighlightBox
  • getLODRangeScale() : ViewState
  • getLODToUse() : LOD
  • getLower() : Boxnt
  • getLowerLeft() : MapObject
  • getMagFilterMode() : TextureAttributeItem
  • getMap() : MapMatrix, MapElement, MapArray
  • getMapList() : ViewState
  • getMapObject() : MapList
  • getMaskKey() : Switch
  • getMaterial() : CgFxEffect
  • getMaterialAmbientValue() : CgFxEffect
  • getMaterialDiffuseValue() : CgFxEffect
  • getMaterialEmissionValue() : CgFxEffect
  • getMaterialShininessValue() : CgFxEffect
  • getMaterialSpecularValue() : CgFxEffect
  • getMatrix() : TextureAttributeItem, Bone, Trafo
  • getMaximalNumberOfChildren() : BalanceTraverser
  • getMaximalNumberOfVertices() : BalanceTraverser
  • getMeshes() : MeshedPrimitiveSet
  • getMinFilterMode() : TextureAttributeItem
  • getMinimalLengths() : StrippingTraverser
  • getMipmapUseCount() : TextureImage
  • getModelToClip() : TransformStack
  • getModelToView() : TransformStack
  • getModelToWorld() : TransformStack, TransformElement, LightsElement, ClipPlanesElement
  • getModelToWorldMatrix() : Path
  • getName() : Object
  • getNearDistance() : Camera
  • getNearest() : RayIntersectTraverser
  • getNextItem() : TextureAttribute
  • getNextMaskIterator() : Switch
  • getNextVariantIterator() : StateSet
  • getNormal() : Planent
  • getNormalize() : AnimatedVertexAttributeSet
  • getNormalizeFlags() : AnimatedVertexAttributeSet
  • getNormals() : VertexAttributeSet
  • getNumberOfActive() : Switch
  • getNumberOfActiveClipPlanes() : Group
  • getNumberOfAnnotationValueComponents() : CgFxEffect
  • getNumberOfArrayParameterElements() : CgFxEffect
  • getNumberOfAttributes() : StateVariant, StateSet, StatePass
  • getNumberOfBytes() : TextureImage
  • getNumberOfCameraAnimations() : Scene
  • getNumberOfCameras() : Scene
  • getNumberOfChildren() : Group, CullData
  • getNumberOfClipPlanes() : ClipPlanesElement, Group
  • getNumberOfColors() : VertexAttributeSet
  • getNumberOfColumns() : MapMatrix
  • getNumberOfCullTraverser() : RenderArea
  • getNumberOfDoFJitters() : ViewState
  • getNumberOfDrawables() : GeoNode
  • getNumberOfFaces() : Triangles, Quads
  • getNumberOfFogCoords() : VertexAttributeSet
  • getNumberOfFSAAJitters() : ViewState
  • getNumberOfGeometries() : GeoNode
  • getNumberOfHeadLights() : Camera
  • getNumberOfHighlightObjects() : HighlightElement
  • getNumberOfImages() : TextureImage
  • getNumberOfIndices() : IndependentPrimitiveSet
  • getNumberOfInfluences() : Skin
  • getNumberOfIntersections() : RayIntersectTraverser
  • getNumberOfItems() : TextureAttribute
  • getNumberOfJitters() : ViewState
  • getNumberOfJoints() : Skin
  • getNumberOfKeys() : KeyFramedAnimation
  • getNumberOfLights() : LightsElement, CgFxEffect
  • getNumberOfLightSources() : Group
  • getNumberOfMapObjects() : MapList
  • getNumberOfMaps() : MapMatrix, MapArray
  • getNumberOfMasks() : Switch
  • getNumberOfMeshes() : MeshedPrimitiveSet
  • getNumberOfMipmaps() : TextureImage
  • getNumberOfNormals() : VertexAttributeSet
  • getNumberOfOwners() : OwnedObject
  • getNumberOfParameterAnnotations() : CgFxEffect
  • getNumberOfParameterValueComponents() : CgFxEffect
  • getNumberOfParents() : Node
  • getNumberOfPassAnnotations() : CgFxEffect
  • getNumberOfPasses() : StateVariant, StateSet, CgFxEffect
  • getNumberOfPassStateValueComponents() : CgFxEffect
  • getNumberOfPrimitiveSets() : RenderElement, Shape
  • getNumberOfProgramParameters() : CgFxEffect
  • getNumberOfProgramSamplers() : CgFxEffect
  • getNumberOfRanges() : LOD
  • getNumberOfSamplers() : CgFxEffect
  • getNumberOfSamplerStateValueComponents() : CgFxEffect
  • getNumberOfSecondaryColors() : VertexAttributeSet
  • getNumberOfSegments() : Lines
  • getNumberOfSkins() : SkinnedTriangles
  • getNumberOfStrips() : StrippedPrimitiveSet
  • getNumberOfStructParameterMembers() : CgFxEffect
  • getNumberOfTechniqueAnnotations() : CgFxEffect
  • getNumberOfTechniques() : CgFxEffect
  • getNumberOfTexCoords() : VertexAttributeSet
  • getNumberOfTransforms() : CgFxEffect
  • getNumberOfTweakables() : CgFxEffect
  • getNumberOfVariants() : StateSet
  • getNumberOfVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • getNumberOfVertices() : VertexAttributeSet
  • getObjectCode() : Object
  • getOcclusionCullID() : RenderElement
  • getOcclusionCullResult() : RenderTraverser, GLTraverser
  • getOffset() : Planent
  • getOffsets() : Skin
  • getOITMaxPasses() : RenderTraverser
  • getOITTechnique() : RenderTraverser
  • getOITThreshold() : RenderTraverser
  • getOpacity() : Material
  • getOrientation() : TextureAttributeItem, SpotLight, MapArray, DirectedLight, Camera, Trafo
  • getOverlapSize() : VolumeTexture
  • getOwner() : OwnedObject
  • getParameterAnnotation() : CgFxEffect
  • getParameterAnnotationByName() : CgFxEffect
  • getParameterByName() : CgFxEffect
  • getParameterBySemantic() : CgFxEffect
  • getParameterName() : CgFxEffect
  • getParameterSemantic() : CgFxEffect
  • getParameterTypeString() : CgFxEffect
  • getParameterValueAsFloat() : CgFxEffect
  • getParameterValueSize() : CgFxEffect
  • getParent() : TransformElement, Node
  • getPass() : StateVariant, StateSet, CgFxEffect
  • getPassAnnotation() : CgFxEffect
  • getPassAnnotationByName() : CgFxEffect
  • getPassByName() : CgFxEffect
  • getPassName() : CgFxEffect
  • getPath() : Intersection
  • getPaths() : SearchTraverser
  • getPickRay() : PerspectiveCamera, ParallelCamera, Camera
  • getPixels() : TextureImage
  • getPlugInterfaceType() : UPIID
  • getPlugSpecificIDString() : UPIID
  • getPointSize() : RenderTraverser
  • getPolygonOffsetFactor() : FaceAttribute
  • getPolygonOffsetUnits() : FaceAttribute
  • getPosition() : SpotLight, PointLight, MapObject, Camera
  • getPrimitiveIndex() : Intersection
  • getPrimitiveSet() : RenderElement, Shape
  • getProblems() : RenderArea
  • getProgramInputType() : CgFxEffect
  • getProgramOutputType() : CgFxEffect
  • getProgramParameter() : CgFxEffect
  • getProgramProfile() : CgFxEffect
  • getProgramSampler() : CgFxEffect
  • getProjection() : PerspectiveCamera, ParallelCamera, Camera
  • getPtr() : Vecnt, Matnnt
  • getRadius() : Spherent
  • getRangeLock() : LOD
  • getRanges() : LOD
  • getRasterOffsetX() : RenderTraverser
  • getRasterOffsetY() : RenderTraverser
  • getRefCnt() : BaseRenderElement
  • getRelation() : MapObject
  • getRenderTechnique() : RenderTraverser
  • getRenderTraverser() : RenderArea
  • getResults() : SearchTraverser
  • getRootNode() : Scene
  • getRotationAxis() : Billboard
  • getSampler() : CgFxEffect
  • getSamplerByName() : CgFxEffect
  • getSamplerByTextureParameterName() : CgFxEffect
  • getSamplerTexture() : CgFxEffect
  • getSamplerTextureFileName() : CgFxEffect
  • getSamplerTextureGPUFormat() : CgFxEffect
  • getSamplerTextureImage() : CgFxEffect
  • getSamplerTextureTarget() : CgFxEffect
  • getScaleOrientation() : Trafo
  • getScaling() : TextureAttributeItem, Trafo
  • getScene() : RenderArea, CgFxEffect
  • getSceneAmbientValue() : CgFxEffect
  • getSceneFrameNumberValue() : CgFxEffect
  • getSecondaryColors() : VertexAttributeSet
  • getSegments() : Lines
  • getShader() : VolumeNode
  • getShadowMapIntensity() : RenderTraverser
  • getShadowMapSize() : RenderTraverser
  • getShadowTechnique() : RenderTraverser
  • getSize() : Trackball, PointAttribute, MapObject, MapMatrix, MapElement, MapArray
  • getSizeOfColors() : VertexAttributeSet
  • getSizeOfTexCoords() : VertexAttributeSet
  • getSizeOfVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • getSkin() : PrimitiveSet
  • getSkinningProcessor() : AppTraverser
  • getSkinningType() : Skin
  • getSkins() : SkinnedTriangles
  • getSliceThickness() : VolumeTexture
  • getSortingPolicy() : RenderTraverser
  • getSourceCode() : CgFxEffect
  • getSourceFunction() : BlendAttribute
  • getSpacing() : MapMatrix, MapArray
  • getSpecularColor() : Material, LightSource
  • getSpecularExponent() : Material
  • getSpeed() : WalkCameraManipulator, FlightCameraManipulator
  • getSpeedIncreaseFactor() : WalkCameraManipulator, FlightCameraManipulator
  • getSquaredDistance() : RenderElement
  • getStackDepth() : TransformStack
  • getStartX() : MouseInput
  • getStartY() : MouseInput
  • getStateMachine() : CgFxContext
  • getStateSet() : GeoNode
  • getStateVariant() : RenderElement, VolumeBrick
  • getStepsPerUnit() : WRLLoader
  • getStepValue() : LinearInterpolatedAnimation, KeyFramedAnimation, FramedAnimation, Animation
  • getStepValues() : FramedAnimation
  • getStereoAutomaticEyeDistanceFactor() : ViewState
  • getStereoEyeDistance() : ViewState
  • getStippleFactor() : LineAttribute
  • getStipplePattern() : LineAttribute
  • getStringAnnotationValue() : CgFxEffect
  • getStringParameterValue() : CgFxEffect
  • getStrips() : StrippedPrimitiveSet
  • getStructParameterMember() : CgFxEffect
  • getStructParameterMemberByName() : CgFxEffect
  • getSubImagePixels() : TextureImage
  • getSuccess() : NBFSaveTraverser
  • getSupportWidth() : Lanczos3Filter, BSplineFilter, BellFilter, TriangleFilter, BoxFilter, ScaleFilter
  • getSwitchMask() : Switch
  • getTail() : Path
  • getTargetDistance() : ViewState
  • getTechnique() : CgFxEffect
  • getTechniqueAnnotation() : CgFxEffect
  • getTechniqueAnnotationByName() : CgFxEffect
  • getTechniqueByName() : CgFxEffect
  • getTechniqueIndex() : CgFxEffect
  • getTechniqueName() : CgFxEffect
  • getTexCoords() : VertexAttributeSet
  • getTexGenLinearPlane() : TextureAttributeItem
  • getTexGenMode() : TextureAttributeItem
  • getTextureAttributeItem() : TextureAttribute
  • getTextureFileName() : TextureAttributeItem
  • getTextureGenericGPUFormat() : GLTraverser
  • getTextureGPUFormat() : TextureImage
  • getTextureImage() : TextureAttributeItem
  • getTextureSizeLimit() : RenderTraverser
  • getTextureTarget() : TextureAttributeItem
  • getThreshold() : AlphaTestAttribute
  • getTopBrickTextureName() : VolumeNode
  • getTopLevelBrick() : VolumeNode
  • getTotalNumberOfBytes() : TextureImage
  • getTotalNumberOfIndices() : Skin
  • getTrafo() : Transform, Billboard, AnimatedTransform
  • getTransform() : TransformElement, RenderElement, HighlightElement, CgFxEffect
  • getTransformationMatrix() : LightSource
  • getTransformPath() : TransformManipulator
  • getTransformType() : CgFxEffect
  • getTranslation() : TextureAttributeItem, Trafo
  • getTransparencyTechnique() : RenderTraverser
  • getTraversalDirection() : MapMatrix, MapArray
  • getTreeModified() : OptimizeTraverser
  • getTweakable() : CgFxEffect
  • getTweakableByName() : CgFxEffect
  • getTweakableBySemantic() : CgFxEffect
  • getType() : TextureImage
  • getTypeOfColors() : VertexAttributeSet
  • getTypeOfFogCoords() : VertexAttributeSet
  • getTypeOfSecondaryColors() : VertexAttributeSet
  • getTypeOfTexCoords() : VertexAttributeSet
  • getTypeOfVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • getUnifyTargets() : UnifyTraverser
  • getUnpackAlignment() : TextureImage
  • getUpper() : Boxnt
  • getUpVector() : Camera
  • getUserData() : Object
  • getUserID() : DALData
  • getVariant() : StateSet
  • getVariantKey() : StateSet
  • getVersion() : GLFunctions
  • getVertexAttributeIndex() : NormalizeTraverser
  • getVertexAttributeSet() : PrimitiveSet
  • getVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • getVertexDataBytes() : VertexAttribute
  • getVertexDataCount() : VertexAttribute
  • getVertexDataSize() : VertexAttribute
  • getVertexDataType() : VertexAttribute
  • getVertexIndices() : Intersection
  • getVertexProgram() : CgFxEffect
  • getVertices() : VertexAttributeSet, HighlightBox
  • getViewportHeight() : RenderArea, ViewState
  • getViewportWidth() : RenderArea, ViewState
  • getViewState() : RenderArea
  • getViewToClip() : TransformStack
  • getViewToModel() : TransformStack
  • getViewToWorld() : TransformStack
  • getViewToWorldMatrix() : Camera
  • getVolumeTextureName() : VolumeNode
  • getVolumeTextureSize() : VolumeNode
  • getVoxelLimitFraction() : VolumeNode
  • getVSensitivity() : FlightCameraManipulator
  • getWeight() : Bone
  • getWeights() : Skin
  • getWidth() : TextureImage, Map, LineAttribute
  • getWindowOffset() : Camera
  • getWindowRegion() : Camera
  • getWindowSize() : Camera
  • getWorldIntersection() : RayIntersectTraverser
  • getWorldToModel() : TransformStack, TransformElement, LightsElement
  • getWorldToView() : TransformStack
  • getWorldToViewMatrix() : Camera
  • getWorldUpVector() : WalkCameraManipulator, FlightCameraManipulator
  • getWrapMode() : TextureAttributeItem
  • GLFunctions() : GLFunctions
  • GLObjects() : GLObjects
  • GLTraverser() : GLTraverser
  • GLUploadTraverser() : GLUploadTraverser
  • GLWinRenderArea() : GLWinRenderArea
  • GPUSkinningProcessor() : GPUSkinningProcessor
  • Group() : Group

- h -

  • handleAlphaTestAttribute() : ExclusiveTraverser, SharedTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleAnimatedQuads() : VertexUnifyTraverser
  • handleAnimatedTransform() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, IdentityToGroupTraverser, EliminateTraverser, CombineTraverser, BalanceTraverser, AppTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleAnimatedVertexAttributeSet() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, StrippingTraverser, SearchTraverser, RenderTraverser, NormalizeTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleBillboard() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, IdentityToGroupTraverser, EliminateTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleBlendAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleCgFx() : ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleDepthAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleDirectedLight() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFaceAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFlipbookAnimation() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, EliminateTraverser, CullTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedIndexAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedTrafoAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedVertexAttributeAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NormalizeTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleGeoNode() : UnifyTraverser, TriangulateTraverser, ExclusiveTraverser, SharedTraverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, EliminateTraverser, DestrippingTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleGroup() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, IdentityToGroupTraverser, EliminateTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleHighlightBox() : ExclusiveTraverser, SharedTraverser
  • handleHighlightEdges() : ExclusiveTraverser, SharedTraverser
  • handleLightingAttribute() : ExclusiveTraverser, SharedTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLinearInterpolatedTrafoAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLinearInterpolatedVertexAttributeAnimation() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NormalizeTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLineAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLines() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLineStrips() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, DestrippingTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLOD() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, IdentityToGroupTraverser, GLUploadTraverser, EliminateTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleMapArray() : ExclusiveTraverser, SharedTraverser, GLTraverser
  • handleMapElement() : ExclusiveTraverser, SharedTraverser, GLTraverser
  • handleMapList() : ExclusiveTraverser, SharedTraverser, GLTraverser
  • handleMapMatrix() : ExclusiveTraverser, SharedTraverser, GLTraverser
  • handleMaterial() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleParallelCamera() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePerspectiveCamera() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePointAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePointLight() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePoints() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuadMeshes() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuads() : UnifyTraverser, TriangulateTraverser, ExclusiveTraverser, SharedTraverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuadStrips() : UnifyTraverser, TriangulateTraverser, ExclusiveTraverser, SharedTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, DestrippingTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleShape() : ExclusiveTraverser, SharedTraverser, CullTraverser, AnalyzeTraverser
  • handleSkin() : ExclusiveTraverser, SharedTraverser, StrippingTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSkinnedTriangles() : VertexUnifyTraverser, UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSpotLight() : ExclusiveTraverser, SharedTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleStatePass() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, EliminateTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleStateSet() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, EliminateTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleStateVariant() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RenderTraverser, EliminateTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSwitch() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RayIntersectTraverser, IdentityToGroupTraverser, GLUploadTraverser, EliminateTraverser, CullTraverser, BalanceTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleTextureAttribute() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, EliminateTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTextureAttributeItem() : ExclusiveTraverser, SharedTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTransform() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, IdentityToGroupTraverser, EliminateTraverser, CullTraverser, CombineTraverser, BalanceTraverser, AppTraverser, AnalyzeTraverser, ExtractGeometryTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleTriangles() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleTriFans() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, DestrippingTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTriStrips() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, GLTraverser, DestrippingTraverser, CombineTraverser, BalanceTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleUnlitColorAttribute() : ExclusiveTraverser, SharedTraverser, SearchTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleVertexAttributeSet() : VertexUnifyTraverser, UnifyTraverser, ExclusiveTraverser, SharedTraverser, SearchTraverser, NormalizeTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleVolumeNode() : ExclusiveTraverser, SharedTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, CullTraverser, AppTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • hasChild() : Group
  • hasFaces() : Triangles, Quads
  • hasIndices() : IndependentPrimitiveSet
  • hasLightSource() : Group
  • hasMeshes() : MeshedPrimitiveSet
  • hasSegments() : Lines
  • hasStrips() : StrippedPrimitiveSet
  • hiddenBegin() : RenderTraverser, GLTraverser
  • hiddenEnd() : RenderTraverser, GLTraverser
  • highlightBegin() : RenderTraverser, GLTraverser
  • HighlightBox() : HighlightBox
  • HighlightEdges() : HighlightEdges
  • HighlightElement() : HighlightElement
  • highlightEnd() : RenderTraverser, GLTraverser
  • HighlightObject() : HighlightObject

- i -

  • IAllocator() : IAllocator
  • IdentityToGroupTraverser() : IdentityToGroupTraverser
  • Image() : Image
  • Incarnation() : Incarnation
  • incrementJointCount() : Transform
  • incrementMipmapUseCount() : TextureImage
  • IndependentPrimitiveSet() : IndependentPrimitiveSet
  • init() : GLMFCRAWnd, Log, FixedAllocator, RenderArea, GLWinRenderArea, Switch
  • initGL() : GLWinRenderArea
  • insertEmptyColumn() : MapMatrix
  • insertKey() : KeyFramedAnimation
  • insertMap() : MapMatrix, MapArray
  • insertMapObject() : MapList
  • instance() : Singleton
  • interruptRender() : RenderArea
  • interruptTraversal() : Traverser
  • intersectBox() : RayIntersectTraverser
  • Intersection() : Intersection
  • intersectLine() : RayIntersectTraverser
  • intersectPoint() : RayIntersectTraverser
  • intersectTriangle() : RayIntersectTraverser
  • invalidate() : Validated, Spherent
  • invalidateAnimationContainment() : PrimitiveSet, Node, LightSource, Drawable
  • invalidateBoundingVolumes() : VertexAttributeSet, Node, HighlightObject, Drawable
  • invalidateCaches() : Group
  • invalidateCgFxContainment() : StateVariant, StateSet, StatePass, Node
  • invalidateContainment() : StateVariant, StateSet, StatePass, StateAttribute, Node
  • invalidateHintsContainment() : Node
  • invalidateIncarnation() : OwnedObject, Object, Node, AnimatedVertexAttributeSet, AnimatedTransform
  • invalidateLightContainment() : Node
  • invalidateLODContainment() : Node
  • invalidateSquaredDistance() : RenderElement
  • invalidateTransparencyContainment() : StateVariant, StateSet, StatePass, StateAttribute, Node
  • invalidateVolumeNodeContainment() : Node
  • invert() : Matnnt
  • is1D() : TextureImage
  • is1DArray() : TextureImage
  • is2D() : TextureImage
  • is2DArray() : TextureImage
  • is3D() : TextureImage
  • isActive() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, Manipulator, FlightCameraManipulator, AnimationManipulator, VolumeNode, Switch
  • isAnimating() : ViewState
  • isAntiAliased() : PointAttribute, LineAttribute
  • isArrayParameter() : CgFxEffect
  • isAttenuated() : SpotLight, PointLight
  • isAutoClipPlanes() : Camera, NBFCamera
  • isAvailable() : GLFunctions
  • isBackFaceCulling() : RenderTraverser, FaceAttribute
  • isBoolAnnotation() : CgFxEffect
  • isBoolParameter() : CgFxEffect
  • isBoolPassState() : CgFxEffect
  • isBoolSamplerState() : CgFxEffect
  • isClipPlaneActive() : Group
  • isCompatible() : VertexAttributeSet, PrimitiveSet, KeyFramedAnimation, FramedAnimation, Animation, AnimatedVertexAttributeSet
  • isCompressed() : TextureImage
  • isCritical() : NVSGException
  • isCubeMap() : TextureImage
  • isDataShared() : VertexAttributeSet, TextureAttributeItem, StrippedPrimitiveSet, SkinnedTriangles, Object, MeshedPrimitiveSet, Material, IndependentPrimitiveSet, CgFx
  • isDepthTestingEnabled() : DepthAttribute
  • isDepthWritingEnabled() : DepthAttribute
  • isDolly() : TrackballTransformManipulator, TrackballCameraManipulator
  • isEachPassTransparent() : StateVariant
  • isEmpty() : Path
  • isEnabled() : Log, VertexAttributeSet, LightSource
  • isEquivalent() : VolumeNode, VertexAttributeSet, Transform, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, SpotLight, SkinnedTriangles, Skin, Shape, PrimitiveSet, PointLight, PointAttribute, Object, MeshedPrimitiveSet, Material, LOD, LineAttribute, LightSource, LightingAttribute, KeyFramedAnimation, IndependentPrimitiveSet, Group, GeoNode, FramedAnimation, FlipbookAnimation, FaceAttribute, DepthAttribute, CgFx, BlendAttribute, Billboard, Animation, AnimatedVertexAttributeSet, AnimatedTransform, AlphaTestAttribute
  • isExported() : GLFunctions
  • isFaceCullingOverwrite() : RenderTraverser
  • isFaceModeOverwrite() : RenderTraverser
  • isFixed() : TransformElement
  • isFixedPoint() : TextureImage
  • isFloatAnnotation() : CgFxEffect
  • isFloatingPoint() : TextureImage
  • isFloatParameter() : CgFxEffect
  • isFloatPassState() : CgFxEffect
  • isFloatSamplerState() : CgFxEffect
  • isFly() : FlightCameraManipulator
  • isFlyBackward() : FlightCameraManipulator
  • isFlyForward() : FlightCameraManipulator
  • isFromFile() : CgFxEffect
  • isFromLump() : CgFxEffect
  • isFrontFaceCulling() : RenderTraverser, FaceAttribute
  • isGeometryCacheTechniqueSupported() : RenderTraverser, GLTraverser
  • isHighlightPass() : RenderTraverser
  • isHWFSAAAvailable() : RenderArea
  • isHWFSAAEnabled() : GLWinRenderArea
  • isImageStream() : TextureImage
  • isInputProgramParameter() : CgFxEffect
  • isInsideBounds() : Chunk
  • isIntAnnotation() : CgFxEffect
  • isIntParameter() : CgFxEffect
  • isIntPassState() : CgFxEffect
  • isIntSamplerState() : CgFxEffect
  • isJitter() : ViewState
  • isJitterTechniqueSupported() : RenderTraverser, GLTraverser
  • isJoint() : Transform
  • isLeaf() : VolumeBrick
  • isLengthPreserving() : TransformElement
  • isLightArrayParameter() : CgFxEffect
  • isLightParameter() : CgFxEffect
  • isLineAntiAliasingEnabled() : RenderTraverser
  • isLocalViewerEnabled() : GLTraverser
  • isMaterialParameter() : CgFxEffect
  • isMatrix22Parameter() : CgFxEffect
  • isMatrix23Parameter() : CgFxEffect
  • isMatrix24Parameter() : CgFxEffect
  • isMatrix32Parameter() : CgFxEffect
  • isMatrix33Parameter() : CgFxEffect
  • isMatrix34Parameter() : CgFxEffect
  • isMatrix42Parameter() : CgFxEffect
  • isMatrix43Parameter() : CgFxEffect
  • isMatrix44Parameter() : CgFxEffect
  • isMipmapped() : TextureAttributeItem
  • isMipmapSamplerState() : CgFxEffect
  • isMirroring() : TransformElement
  • isNormalizeEnabled() : VertexAttributeSet
  • isOcclusionCulling() : RenderTraverser
  • isOcclusionCullingSupported() : RenderTraverser, GLTraverser
  • isOITTechniqueSupported() : RenderTraverser, GLTraverser
  • isOrbit() : TrackballCameraManipulator
  • isOutputProgramParameter() : CgFxEffect
  • isOverlayPass() : RenderTraverser
  • isPan() : TrackballTransformManipulator, TrackballCameraManipulator
  • isPointAntiAliasingEnabled() : RenderTraverser
  • isPolygonOffset() : FaceAttribute
  • isProgramCompiled() : CgFxEffect
  • isRangeLockEnabled() : LOD
  • isRenderTechniqueSupported() : RenderTraverser, GLTraverser
  • isRotate() : TrackballTransformManipulator, TrackballCameraManipulator
  • isSampler1DParameter() : CgFxEffect
  • isSampler2DParameter() : CgFxEffect
  • isSampler3DParameter() : CgFxEffect
  • isSamplerArrayParameter() : CgFxEffect
  • isSamplerCubeParameter() : CgFxEffect
  • isSamplerParameter() : CgFxEffect
  • isSamplerRectParameter() : CgFxEffect
  • isScalarParameter() : CgFxEffect
  • isSceneParameter() : CgFxEffect
  • isSeparateSpecularColorEnabled() : GLTraverser
  • isShadowCasting() : LightSource
  • isShadowTechniqueSupported() : RenderTraverser, GLTraverser
  • isShareable() : RCObject
  • isShared() : RCObject, NBFObject
  • isSkinningProcessorSupported() : AppTraverser
  • isSquaredDistanceValid() : RenderElement
  • isStereo() : ViewState, NBFViewState
  • isStereoAutomaticEyeDistanceAdjustment() : ViewState
  • isStereoAvailable() : RenderArea
  • isStereoReversedEyes() : ViewState
  • isStringAnnotation() : CgFxEffect
  • isStringParameter() : CgFxEffect
  • isStructParameter() : CgFxEffect
  • isSubjectToCull() : RenderElement
  • isSupported() : GPUSkinningProcessor, CPUSkinningProcessor
  • isTextureImageSamplerCompliant() : CgFxEffect
  • isTilt() : WalkCameraManipulator
  • isTransformParameter() : CgFxEffect
  • isTranslate() : WalkCameraManipulator
  • isTransparencyTechniqueSupported() : RenderTraverser, GLTraverser
  • isTransparent() : StateVariant, StateSet, StatePass, StateAttribute, LightingAttribute, CgFx, BlendAttribute, AlphaTestAttribute
  • isTransparentPass() : RenderTraverser, CgFxEffect
  • isTwoSidedLighting() : RenderTraverser, FaceAttribute
  • isTwoSidedLightingOverwrite() : RenderTraverser
  • isUnused() : Chunk
  • isUploadDemanded() : TextureImage
  • isValid() : Validated, FileMapping, CgFxEffect
  • isVector2Parameter() : CgFxEffect
  • isVector3Parameter() : CgFxEffect
  • isVector4Parameter() : CgFxEffect
  • isWalk() : WalkCameraManipulator
  • isWalkBackward() : WalkCameraManipulator
  • isWalkForward() : WalkCameraManipulator

- k -

  • keyDown() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, KeyInput, FlightCameraManipulator
  • KeyFramedAnimation() : KeyFramedAnimation
  • KeyInput() : KeyInput
  • keyUp() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, KeyInput, FlightCameraManipulator

- l -

  • lerp() : Trafo
  • LightingAttribute() : LightingAttribute
  • LightsElement() : LightsElement
  • LightSource() : LightSource
  • LinearInterpolatedAnimation() : LinearInterpolatedAnimation
  • LineAttribute() : LineAttribute
  • Lines() : Lines
  • LineStrips() : LineStrips
  • load() : TextureLoader, SceneLoader, WRLLoader, PLYLoader, NVSGLoader, NVNVB, NVBLoader, NBFLoader
  • loadCustomObject() : NBFLoader
  • lock() : CgFxContext
  • lockExclusive() : SWMRSync
  • lockObject() : ExclusiveTraverser, SharedTraverser, Traverser
  • lockScene() : ExclusiveTraverser, SharedTraverser, Traverser
  • lockShared() : SWMRSync
  • lockViewState() : ExclusiveTraverser, SharedTraverser, Traverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, GLUploadTraverser
  • LOD() : LOD
  • Log() : Log

- m -

  • makeCurrent() : GLWinRenderArea
  • Manipulator() : Manipulator
  • Map() : Map
  • MapArray() : MapArray
  • MapElement() : MapElement
  • mapIn() : WriteMapping, ReadMapping, FileMapping
  • MapList() : MapList
  • MapMatrix() : MapMatrix
  • MapObject() : MapObject
  • mapOffset() : PLYLoader, NBFLoader
  • mapOut() : FileMapping
  • markUnshareable() : RCObject
  • Material() : Material
  • Matnnt() : Matnnt
  • MemFunTbl() : MemFunTbl
  • MeshedPrimitiveSet() : MeshedPrimitiveSet
  • mirrorX() : TextureImage
  • mirrorY() : TextureImage
  • motionHandled() : MouseInput
  • mouseButtonDown() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, MouseInput, FlightCameraManipulator
  • mouseButtonUp() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, MouseInput, FlightCameraManipulator
  • MouseInput() : MouseInput
  • mouseMotion() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, MouseInput, FlightCameraManipulator
  • move() : Camera
  • moveX() : Camera
  • moveY() : Camera
  • moveZ() : Camera

- n -

  • NBFSaver() : NBFSaver
  • NBFSaveTraverser() : NBFSaveTraverser
  • needsTraversal() : AppTraverser
  • NewCamera() : NVNVB
  • NewController() : NVNVB
  • NewHelper() : NVNVB
  • NewLight() : NVNVB
  • NewMaterial() : NVNVB
  • NewMesh() : NVNVB
  • NewMotion() : NVNVB
  • NewScene() : NVNVB
  • NewShape() : NVNVB
  • NewTexture() : NVNVB
  • nextFrame() : AnimationManipulator
  • Node() : Node
  • NodeHintsCullTraverser() : NodeHintsCullTraverser
  • normalize() : Vecnt, Quatt
  • NormalizeTraverser() : NormalizeTraverser
  • NVBImportError() : NVNVB
  • NVBLoadTraverser() : NVBLoadTraverser
  • NVBLog() : NVNVB
  • NVSGException() : NVSGException
  • NVSGSaveTraverser() : NVSGSaveTraverser

- o -

  • Object() : Object
  • occlusionTest() : RenderTraverser
  • onDegenerateGeometry() : PlugInCallback
  • onEmptyToken() : PlugInCallback
  • OnEraseBkgnd() : GLMFCRAWnd
  • onError() : PlugInCallback
  • onFileAccessFailed() : PlugInCallback
  • onFileEmpty() : PlugInCallback
  • onFileMappingFailed() : PlugInCallback
  • onFileNotFound() : PlugInCallback
  • onFilesNotFound() : PlugInCallback
  • onIncompatibleFile() : PlugInCallback
  • onIncompatibleValues() : PlugInCallback
  • onInvalidFile() : PlugInCallback
  • onInvalidValue() : PlugInCallback
  • onLoad() : TextureLoader, VolLoader, ILTexLoader
  • OnPaint() : GLMFCRAWnd
  • onReleaseDAL() : DALDataCreator
  • onUndefinedToken() : PlugInCallback
  • onUnexpectedEndOfFile() : PlugInCallback
  • onUnexpectedToken() : PlugInCallback
  • onUnknownToken() : PlugInCallback
  • onUnLocalizedMessage() : PlugInCallback
  • onUnsupportedToken() : PlugInCallback
  • onWarning() : PlugInCallback
  • operator *() : RCObject_AutoPtr, RCIPtr, RCPtr
  • operator *=() : Vecnt, Quatt, Matnnt
  • operator CGcontext() : CgFxContext
  • operator const T &() : RegVal
  • operator delete() : IAllocator
  • operator new() : IAllocator
  • operator!=() : CullData, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VariantIterator
  • operator()() : TraceFunctor, traceFileConsoleOutput, traceFileDebugOutput, traceFileOutput, traceConsoleDebugOutput, traceConsoleOutput, traceDebugOutput, removeReference, addReference, RenderElementCompareStateAttributes, RenderElementCompareFrontToBack, RenderElementCompareBackToFront, Lanczos3Filter, BSplineFilter, BellFilter, TriangleFilter, BoxFilter, ScaleFilter, Bone, Spherent, Planent
  • operator+() : Incarnation
  • operator++() : Incarnation
  • operator+=() : Vecnt, Matnnt
  • operator-=() : Vecnt, Matnnt
  • operator->() : RCObject_AutoPtr, RCIPtr, RCPtr
  • operator/=() : Vecnt, Quatt, Matnnt
  • operator=() : RegVal, RCObject_AutoPtr, RCIPtr, RCPtr, RCObject, UPIID, MouseInput, KeyInput, Intersection, VolumeNode, VertexAttributeSet, VertexAttribute, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, StateAttribute, SpotLight, SkinnedTriangles, Bone, Skin, Shape, QuadStrips, Quads, QuadMeshes, PrimitiveSet, PrimitiveAttribute, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, OwnedObject, Object, Node, MeshedPrimitiveSet, Material, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, LightSource, LightingAttribute, KeyFramedAnimation, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FlipbookAnimation, FaceAttribute, Drawable, DirectedLight, DepthAttribute, CgFx, Camera, BlendAttribute, Billboard, Animation, AnimatedVertexAttributeSet, AnimatedTransform, AlphaTestAttribute, Vecnt, Trafo, Quatt
  • operator==() : CullData, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VNVector, VariantIterator, Bone, Trafo
  • operator[]() : MemFunTbl, VolumeBrick, Face, Vecnt, Quatt, Matnnt
  • OptimizeTraverser() : OptimizeTraverser
  • orbit() : TrackballCameraManipulator, Camera
  • orbitX() : Camera
  • orbitY() : Camera
  • orbitZ() : Camera
  • orthonormalize() : Vecnt
  • overlayBegin() : RenderTraverser, GLTraverser
  • overlayEnd() : RenderTraverser, GLTraverser
  • OwnedObject() : OwnedObject
  • ownersBegin() : OwnedObject
  • ownersEnd() : OwnedObject

- p -

  • PADDING() : NBFPointAttribute, NBFLineAttribute, NBFLightingAttribute, NBFFaceAttribute, NBFDepthAttribute, NBFCgFx, NBFBlendAttribute, NBFAlphaTestAttribute, NBFStateSet, NBFSpotLight, NBFLightSource, NBFAnimatedTransform, NBFFlipbookAnimation, NBFTransform, NBFBillboard, NBFSwitch, NBFLOD, NBFNode, NBFCamera, NBFFramedAnimation, NBFAnimation, NBFVertexAttributeAnimation, NBFTrafoAnimation, NBFIndexAnimation, NBFObject, NBFViewState, NBFHeader, texImage_t
  • pan() : TrackballTransformManipulator, TrackballCameraManipulator
  • ParallelCamera() : ParallelCamera
  • Path() : Path
  • PerspectiveCamera() : PerspectiveCamera
  • pickMap() : MapObject, MapMatrix, MapList, MapElement, MapArray
  • Planent() : Planent
  • PlugInCallback() : PlugInCallback
  • PointAttribute() : PointAttribute
  • PointLight() : PointLight
  • Points() : Points
  • pop() : Path
  • popCullTraverser() : RenderArea
  • popModelToWorld() : TransformStack
  • postAddChild() : Switch, Group
  • postApply() : Traverser, IdentityToGroupTraverser, CullTraverser
  • postRemoveChild() : Switch, Group
  • postTraverseDrawables() : Traverser, RenderTraverser
  • postTraverseGroup() : Traverser, RenderTraverser, RayIntersectTraverser
  • postTraverseTransform() : RenderTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, FrustumCullTraverser, AppTraverser, ExtractGeometryTraverser
  • preAddChild() : Group
  • preApply() : Traverser, NVSGSaveTraverser
  • preCalculateFileSize() : NBFSaveTraverser
  • PreCreateWindow() : GLMFCRAWnd
  • preRemoveChild() : Group
  • preTraverseDrawables() : Traverser, RenderTraverser, CombineTraverser
  • preTraverseGroup() : Traverser, RenderTraverser, RayIntersectTraverser
  • preTraverseTransform() : RenderTraverser, RayIntersectTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser, FrustumCullTraverser, AppTraverser, ExtractGeometryTraverser
  • previousFrame() : AnimationManipulator
  • PrimitiveAttribute() : PrimitiveAttribute
  • PrimitiveSet() : PrimitiveSet
  • primitiveSetsBegin() : RenderTraverser, GLTraverser
  • primitiveSetsEnd() : RenderTraverser, GLTraverser
  • ProblemInfo() : ProblemInfo
  • process() : GPUSkinningProcessor, CPUSkinningProcessor
  • projectOntoTBSphere() : Trackball
  • pseudoAlloc() : NBFSaveTraverser
  • push() : Path
  • pushCullTraverser() : RenderArea
  • pushModelToWorld() : TransformStack

- q -

  • QuadMeshes() : QuadMeshes
  • Quads() : Quads
  • QuadStrips() : QuadStrips
  • Quatt() : Quatt

- r -

  • RayIntersectTraverser() : RayIntersectTraverser
  • RCIPtr() : RCIPtr
  • RCObject() : RCObject
  • RCObject_AutoPtr() : RCObject_AutoPtr
  • RCPtr() : RCPtr
  • RCVector() : RCVector
  • ReadMapping() : ReadMapping
  • RegVal() : RegVal
  • release() : RCObject_AutoPtr, RayIntersectTraverser
  • releaseCachedData() : VertexAttributeSet
  • releaseDeviceAbstractionLinkData() : DALDataCreator, DALHost
  • releaseImagePixels() : TextureImage
  • reload() : TextureLoader
  • reloadImagePixels() : TextureImage
  • removeAsParentFrom() : Node
  • removeAttribute() : StateVariant, StateSet, StatePass
  • removeAttributeByObjectCode() : StateVariant, StateSet, StatePass
  • removeCallback() : CallbackServer
  • removeCamera() : Scene
  • removeCameraAnimation() : Scene
  • removeChild() : Group
  • removeColumn() : MapMatrix
  • removeData() : VertexAttribute
  • removeGeometry() : GeoNode
  • removeHeadLight() : Camera
  • removeHints() : NodeHintsCullTraverser, Node
  • removeJoint() : Skin
  • removeKey() : KeyFramedAnimation
  • removeKeys() : KeyFramedAnimation
  • removeLightSource() : Group
  • removeMap() : MapMatrix, MapArray
  • removeMapObject() : MapList
  • removeMask() : Switch
  • removeOnDestroyCallback() : RCObject
  • removeOwner() : OwnedObject
  • removePass() : StateVariant, StateSet
  • removePrimitiveSet() : Shape
  • removeRef() : RCObject, BaseRenderElement
  • removeStep() : KeyFramedAnimation, FramedAnimation
  • removeSteps() : FramedAnimation
  • removeVariant() : StateSet
  • removeVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • renderAlphaTestAttribute() : RenderTraverser, GLTraverser
  • RenderArea() : RenderArea
  • renderBegin() : RenderTraverser, GLTraverser
  • renderBillboard() : RenderTraverser
  • renderBlendAttribute() : RenderTraverser, GLTraverser
  • renderCgFx() : RenderTraverser
  • renderDepthAttribute() : RenderTraverser, GLTraverser
  • renderDirectedLight() : RenderTraverser, GLTraverser
  • RenderElement() : RenderElement
  • RenderElementCompareBackToFront() : RenderElementCompareBackToFront
  • RenderElementCompareFrontToBack() : RenderElementCompareFrontToBack
  • renderEnd() : RenderTraverser, GLTraverser
  • renderFaceAttribute() : RenderTraverser, GLTraverser
  • renderHighlightBox() : RenderTraverser, GLTraverser
  • renderHighlightEdges() : RenderTraverser, GLTraverser
  • renderLightingAttribute() : RenderTraverser, GLTraverser
  • renderLineAttribute() : RenderTraverser, GLTraverser
  • renderLines() : RenderTraverser, GLTraverser
  • renderLineStrips() : RenderTraverser, GLTraverser
  • renderMaterial() : RenderTraverser, GLTraverser
  • renderObject() : RenderTraverser
  • renderParallelCamera() : RenderTraverser, GLTraverser
  • renderPerspectiveCamera() : RenderTraverser, GLTraverser
  • renderPointAttribute() : RenderTraverser, GLTraverser
  • renderPointLight() : RenderTraverser, GLTraverser
  • renderPoints() : RenderTraverser, GLTraverser
  • renderQuadMeshes() : RenderTraverser, GLTraverser
  • renderQuads() : RenderTraverser, GLTraverser
  • renderQuadStrips() : RenderTraverser, GLTraverser
  • renderScene() : RenderArea, GLWinRenderArea
  • renderSkinnedTriangles() : RenderTraverser, GLTraverser
  • renderSpotLight() : RenderTraverser, GLTraverser
  • renderStatePass() : RenderTraverser, GLTraverser
  • renderTextureAttribute() : RenderTraverser, GLTraverser
  • renderTextureAttributeItem() : RenderTraverser, GLTraverser
  • renderTransform() : RenderTraverser
  • RenderTraverser() : RenderTraverser
  • renderTriangles() : RenderTraverser, GLTraverser
  • renderTriFans() : RenderTraverser, GLTraverser
  • renderTriStrips() : RenderTraverser, GLTraverser
  • renderUnlitColorAttribute() : RenderTraverser, GLTraverser
  • replaceChild() : Group
  • replaceDrawable() : GeoNode
  • replaceKey() : KeyFramedAnimation
  • replaceKeys() : KeyFramedAnimation
  • replaceLightSource() : Group
  • replaceMap() : MapMatrix, MapArray
  • replaceMapObject() : MapList
  • replacePass() : StateVariant, StateSet
  • replaceStateSet() : GeoNode
  • replaceStep() : KeyFramedAnimation, FramedAnimation, Animation
  • replaceSteps() : FramedAnimation
  • replaceVariant() : StateSet
  • replaceVariantKey() : StateSet
  • requestHWFSAA() : RenderArea
  • requestStereoSupport() : RenderArea
  • reserveKeys() : KeyFramedAnimation
  • reserveSteps() : FramedAnimation
  • reset() : RCObject_AutoPtr, WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • resetButtonState() : MouseInput
  • resetKeyState() : KeyInput
  • resetLightValues() : CgFxEffect
  • resetMaterialValues() : CgFxEffect
  • resetPass() : CgFxEffect
  • resetPositions() : MouseInput
  • resetSceneValues() : CgFxEffect
  • rotate() : TrackballTransformManipulator, TrackballCameraManipulator, Camera
  • rotateX() : Camera
  • rotateY() : Camera
  • rotateZ() : Camera

- s -

  • save() : TextureSaver, SceneSaver, VolSaver, OBJSaver, NVSGSaver, NBFSaver, ILTexSaver
  • scale() : TextureImage
  • scaleToPowerOfTwo() : TextureImage
  • Scene() : Scene
  • search() : SearchTraverser
  • SearchTraverser() : SearchTraverser
  • set() : Validated
  • setActive() : Switch
  • setActiveMask() : Switch
  • setActiveVariantKey() : StateSet
  • setAlignment() : MapMatrix, MapArray, Billboard
  • setAlphaFunction() : AlphaTestAttribute
  • setAmbientColor() : Scene, Material, LightSource
  • setAnimating() : ViewState
  • setAnimation() : Bone, LightSource, FlipbookAnimation, AnimatedVertexAttributeSet, AnimatedTransform
  • setAnimationFrame() : SkinnedTriangles
  • setAnnotation() : Object
  • setAntiAliasing() : PointAttribute, LineAttribute
  • setAppTraverser() : RenderArea
  • setAspectRatio() : Camera
  • setAttenuation() : SpotLight, PointLight
  • setAutoClipPlanes() : Camera
  • setBackColor() : Scene
  • setBackImage() : Scene
  • setBalanceTargets() : BalanceTraverser
  • setBaseClassSearch() : SearchTraverser
  • setBindShapeMatrix() : Skin
  • setBlendFunctions() : BlendAttribute
  • setBoolParameterValue() : CgFxEffect
  • setBorderColor() : TextureAttributeItem
  • setCallback() : PlugIn
  • setCamClipping() : RayIntersectTraverser
  • setCamera() : ViewState
  • setCameraAnimation() : AnimationManipulator
  • setCameraHeightAboveTerrain() : WalkCameraManipulator
  • setCenter() : LOD, Trafo, Spherent
  • setClassName() : SearchTraverser
  • setClipPlane() : RenderTraverser, GLTraverser, Group
  • setCollectRenderElements() : RenderTraverser
  • setColor() : UnlitColorAttribute, HighlightEdges, HighlightBox
  • setColors() : VertexAttributeSet
  • setCombineTargets() : CombineTraverser
  • setCreaseAngle() : SmoothTraverser
  • setCreationFlags() : TextureImage
  • setCullMode() : FaceAttribute
  • setCullTree() : ViewState
  • setCurrentStep() : LinearInterpolatedAnimation
  • setCurrentTechnique() : CgFxEffect
  • setCutoffAngle() : SpotLight
  • setData() : VolumeBrick, VertexAttribute
  • setDepthFunction() : DepthAttribute
  • setDepthTestingEnabled() : DepthAttribute
  • setDepthWritingEnabled() : DepthAttribute
  • setDiffuseColor() : Material, LightSource
  • setDirection() : SpotLight, DirectedLight, Camera
  • setDoFJitters() : ViewState
  • setDrawable() : HighlightObject
  • setEliminateTargets() : EliminateTraverser
  • setEmissiveColor() : Material
  • setEnabled() : VertexAttributeSet, LightSource, LightingAttribute
  • setEnabledDuringMultiSampleAlpha() : AlphaTestAttribute
  • setEnvColor() : TextureAttributeItem
  • setEnvMode() : TextureAttributeItem
  • setEnvScale() : TextureAttributeItem
  • setEpsilon() : VertexUnifyTraverser, UnifyTraverser
  • setFaceCulling() : RenderTraverser
  • setFaceCullingOverwrite() : RenderTraverser
  • setFaceMode() : RenderTraverser, FaceAttribute
  • setFaceModeOverwrite() : RenderTraverser
  • setFaces() : Triangles, Quads
  • setFalloffExponent() : SpotLight
  • setFarDistance() : Camera
  • setFieldOfView() : PerspectiveCamera
  • setFILE() : NVSGSaveTraverser
  • setFileName() : NBFSaveTraverser
  • setFileNames() : VolumeNode
  • setFloatParameterValue() : CgFxEffect
  • setFocusDistance() : PerspectiveCamera, Camera
  • setFogCoords() : VertexAttributeSet
  • setFrameNumber() : Scene
  • setFrontClipPlane() : VolumeNode, VolumeBrick
  • setFSAAJitters() : ViewState
  • setGeometryCacheTechnique() : RenderTraverser, GLTraverser
  • setHints() : NodeHintsCullTraverser, Node
  • setHSensitivity() : WalkCameraManipulator, FlightCameraManipulator
  • setIdentity() : Trafo
  • setIgnoreNames() : OptimizeTraverser
  • setImageData() : TextureImage
  • setInactive() : Switch
  • setIndices() : IndependentPrimitiveSet
  • setInfluenceData() : Skin
  • setIntensity() : LightSource
  • setIntParameterValue() : CgFxEffect
  • setInverse() : Bone
  • setJittersCombineMethod() : ViewState
  • setJitterTechnique() : RenderTraverser
  • setLightAmbientValue() : CgFxEffect
  • setLightConstantAttenuationValue() : CgFxEffect
  • setLightDiffuseValue() : CgFxEffect
  • setLightDirectionValue() : CgFxEffect
  • setLightLinearAttenuationValue() : CgFxEffect
  • setLightPositionValue() : CgFxEffect
  • setLightQuadraticAttenuationValue() : CgFxEffect
  • setLightSpecularValue() : CgFxEffect
  • setLightSpotCutoffValue() : CgFxEffect
  • setLightSpotExponentValue() : CgFxEffect
  • setLineAntiAliasing() : RenderTraverser
  • setLineWidth() : RenderTraverser, HighlightEdges, HighlightBox
  • setLocalViewer() : GLTraverser
  • setLODRangeScale() : ViewState
  • SetLogCallback() : NVNVB
  • setMagFilterMode() : TextureAttributeItem
  • setMap() : MapElement
  • setMapData() : Map
  • setMapList() : ViewState
  • setMasterShader() : VolumeBrick
  • setMaterialAmbientValue() : CgFxEffect
  • setMaterialDiffuseValue() : CgFxEffect
  • setMaterialEmissionValue() : CgFxEffect
  • setMaterialShininessValue() : CgFxEffect
  • setMaterialSpecularValue() : CgFxEffect
  • setMatrix() : Bone, Trafo
  • setMaximalNumberOfChildren() : BalanceTraverser
  • setMaximalNumberOfVertices() : BalanceTraverser
  • setMeshes() : MeshedPrimitiveSet
  • setMinFilterMode() : TextureAttributeItem
  • setMinimalLengths() : StrippingTraverser
  • setName() : Object
  • setNearDistance() : Camera
  • setNormal() : Planent
  • setNormalize() : AnimatedVertexAttributeSet
  • setNormalizeEnabled() : VertexAttributeSet
  • setNormals() : VertexAttributeSet
  • setObjectName() : SearchTraverser
  • setObjectPointer() : SearchTraverser
  • setOcclusionCullID() : RenderElement
  • setOcclusionCulling() : RenderTraverser
  • setOffset() : Planent
  • setOITMaxPasses() : RenderTraverser, GLTraverser
  • setOITTechnique() : RenderTraverser, GLTraverser
  • setOITThreshold() : RenderTraverser
  • setOpacity() : Material
  • setOrientation() : TextureAttributeItem, SpotLight, MapArray, DirectedLight, Camera, Trafo
  • setOverlapSize() : VolumeTexture
  • setParameterValueAsFloat() : CgFxEffect
  • setPlugInCallback() : NBFSaveTraverser
  • setPointAntiAliasing() : RenderTraverser
  • setPointSize() : RenderTraverser
  • setPolygonOffset() : FaceAttribute
  • setPosition() : SpotLight, PointLight, MapObject, Camera
  • setProgramProfile() : CgFxEffect
  • setRadius() : Spherent
  • setRangeLock() : LOD
  • setRanges() : LOD
  • setRay() : RayIntersectTraverser
  • setRelation() : MapObject
  • setRenderArea() : Manipulator
  • setRenderTechnique() : RenderTraverser
  • setRenderTraverser() : RenderArea
  • setRootNode() : Scene
  • setRotationAxis() : Billboard
  • setSamplerTextureGPUFormat() : CgFxEffect
  • setSamplerTextureImage() : CgFxEffect
  • setScaleOrientation() : Trafo
  • setScaling() : TextureAttributeItem, Trafo
  • setScene() : RenderArea, Traverser
  • setSceneAmbientValue() : CgFxEffect
  • setSceneData() : RenderArea
  • setSceneFrameNumberValue() : CgFxEffect
  • setScreenSize() : WalkCameraManipulator
  • setSecondaryColors() : VertexAttributeSet
  • setSegments() : Lines
  • setSeparateSpecularColor() : GLTraverser
  • setShader() : VolumeNode
  • setShadowCasting() : LightSource
  • setShadowMapIntensity() : RenderTraverser
  • setShadowMapSize() : RenderTraverser, GLTraverser
  • setShadowTechnique() : RenderTraverser, GLTraverser
  • setSize() : Trackball, PointAttribute
  • setSkin() : PrimitiveSet
  • setSkinningProcessor() : AppTraverser
  • setSkinningType() : Skin
  • setSkins() : SkinnedTriangles
  • setSliceThickness() : VolumeTexture
  • setSortingPolicy() : RenderTraverser
  • setSpacing() : MapMatrix, MapArray
  • setSpecularColor() : Material, LightSource
  • setSpecularExponent() : Material
  • setSpeed() : WalkCameraManipulator, FlightCameraManipulator
  • setSpeedIncreaseFactor() : WalkCameraManipulator, FlightCameraManipulator
  • setStateMachine() : CgFxContext
  • setStepsPerUnit() : WRLLoader
  • setStereo() : ViewState
  • setStereoAutomaticEyeDistanceAdjustment() : ViewState
  • setStereoAutomaticEyeDistanceFactor() : ViewState
  • setStereoEyeDistance() : ViewState
  • setStippleFactor() : LineAttribute
  • setStipplePattern() : LineAttribute
  • setStringParameterValue() : CgFxEffect
  • setStrips() : StrippedPrimitiveSet
  • setSubImagePixels() : TextureImage
  • setTargetDistance() : ViewState
  • setTexCoords() : VertexAttributeSet
  • setTexGenLinearPlane() : TextureAttributeItem
  • setTexGenMode() : TextureAttributeItem
  • setTextureGenericGPUFormat() : GLTraverser
  • setTextureGPUFormat() : TextureImage
  • setTextureImage() : TextureAttributeItem
  • setTextureSizeLimit() : RenderTraverser, GLTraverser
  • setTextureTarget() : TextureAttributeItem
  • setThreshold() : AlphaTestAttribute
  • setThrowExceptionOnError() : PlugInCallback
  • setTrafo() : Transform, AnimatedTransform
  • setTransformPath() : TransformManipulator
  • setTransforms() : RenderTraverser, GLTraverser
  • setTransformValue() : CgFxEffect
  • setTranslation() : TextureAttributeItem, Trafo
  • setTransparencyTechnique() : RenderTraverser, GLTraverser
  • setTraversalDirection() : MapMatrix, MapArray
  • setTwoSidedLighting() : RenderTraverser, FaceAttribute
  • setTwoSidedLightingOverwrite() : RenderTraverser
  • setUnifyTargets() : UnifyTraverser
  • setUpVector() : Camera
  • setUserData() : Object
  • setUserID() : DALData
  • setVertexAttributeIndex() : NormalizeTraverser
  • setVertexAttributeSet() : PrimitiveSet
  • setVertexData() : VertexAttributeSet, AnimatedVertexAttributeSet
  • setVertices() : VertexAttributeSet
  • setViewportSize() : GLMFCRAWnd, RenderArea, GLWinRenderArea, RayIntersectTraverser, ViewState
  • setViewState() : RenderArea, Traverser
  • setViewToClip() : TransformStack
  • setVoxelLimitFraction() : VolumeNode
  • setVSensitivity() : FlightCameraManipulator
  • setWeight() : Bone
  • setWidth() : LineAttribute
  • setWindowOffset() : Camera
  • setWindowRegion() : Camera
  • setWindowSize() : Camera
  • setWorldToView() : TransformStack
  • setWorldUpVector() : WalkCameraManipulator, FlightCameraManipulator
  • setWrapMode() : TextureAttributeItem
  • Shape() : Shape
  • SharedModelViewTraverser() : SharedModelViewTraverser
  • SharedTraverser() : SharedTraverser
  • shareLists() : GLWinRenderArea
  • Skin() : Skin
  • SkinnedTriangles() : SkinnedTriangles
  • SmoothTraverser() : SmoothTraverser
  • Spherent() : Spherent
  • SpotLight() : SpotLight
  • StateAttribute() : StateAttribute
  • StatePass() : StatePass
  • StateSet() : StateSet
  • StateVariant() : StateVariant
  • stereoReverseEyes() : ViewState
  • storeDeviceAbstractionLinkData() : DALHost
  • storeIntersection() : RayIntersectTraverser
  • StrippedPrimitiveSet() : StrippedPrimitiveSet
  • StrippingTraverser() : StrippingTraverser
  • swapData() : VertexAttribute
  • swapVertexData() : VertexAttributeSet
  • Switch() : Switch
  • SWMRSync() : SWMRSync

- t -

  • testEntry() : MemFunTbl
  • TextureAttribute() : TextureAttribute
  • TextureAttributeItem() : TextureAttributeItem
  • TextureAttributeItemData() : TextureAttributeItemData
  • TextureImage() : TextureImage
  • tilt() : WalkCameraManipulator
  • toggleStereo() : ViewState
  • Trace() : Trace
  • Trackball() : Trackball
  • TrackballCameraManipulator() : TrackballCameraManipulator
  • TrackballTransformManipulator() : TrackballTransformManipulator
  • Trafo() : Trafo
  • Transform() : Transform
  • TransformElement() : TransformElement
  • TransformManipulator() : TransformManipulator
  • TransformStack() : TransformStack
  • translate() : WalkCameraManipulator
  • transparentBegin() : RenderTraverser, GLTraverser
  • transparentEnd() : RenderTraverser, GLTraverser
  • traverseCamera() : ExclusiveTraverser, SharedTraverser, ExclusiveModelViewTraverser, SharedModelViewTraverser
  • traverseGeoNode() : Traverser
  • traverseGroup() : Traverser
  • traverseHighlightObject() : ExclusiveTraverser, SharedTraverser
  • traverseLight() : ExclusiveTraverser, SharedTraverser, RenderTraverser
  • traverseMapList() : Traverser
  • traverseObject() : Traverser
  • traversePrimitiveSet() : UnifyTraverser, ExclusiveTraverser, SharedTraverser, RenderTraverser, CullTraverser, AppTraverser, ExtractGeometryTraverser
  • Traverser() : Traverser
  • traverseShape() : Traverser
  • traverseStatePass() : Traverser
  • traverseStateVariant() : Traverser
  • traverseTextureAttribute() : Traverser
  • traverseVolumeNode() : Traverser
  • Triangles() : Triangles
  • TriangulateTraverser() : TriangulateTraverser
  • TriFans() : TriFans
  • triggerRedraw() : GLMFCRAWnd, RenderArea, GLWinRenderArea
  • TriStrips() : TriStrips
  • truncate() : Path

- u -

  • unbindTextureAttributeItem() : TextureAttribute
  • UnifyTraverser() : UnifyTraverser
  • UnlitColorAttribute() : UnlitColorAttribute
  • unloadPrograms() : CgFx
  • unlock() : CgFxContext
  • unlockExclusive() : SWMRSync
  • unlockObject() : ExclusiveTraverser, SharedTraverser, Traverser
  • unlockScene() : ExclusiveTraverser, SharedTraverser, Traverser
  • unlockShared() : SWMRSync
  • unlockViewState() : ExclusiveTraverser, SharedTraverser, Traverser, ExclusiveModelViewTraverser, SharedModelViewTraverser
  • unmapOffset() : PLYLoader, NBFLoader
  • update() : Boxnt
  • updateFrame() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, Manipulator, FlightCameraManipulator, AnimationManipulator
  • updateMatrices() : TransformElement
  • UPIID() : UPIID
  • UPITID() : UPITID

- v -

  • validate() : Validated
  • validateCurrentTechnique() : CgFxEffect
  • Validated() : Validated
  • validateIncarnation() : VolumeNode, TextureAttribute, StateVariant, StateSet, StatePass, SkinnedTriangles, Shape, PrimitiveSet, Object, Node, MapList, LightSource, HighlightBox, Group, GeoNode, FlipbookAnimation, Drawable, Camera, AnimatedVertexAttributeSet, AnimatedTransform
  • Vecnt() : Vecnt
  • verifyCreator() : DALData
  • VertexAttribute() : VertexAttribute
  • VertexAttributeSet() : VertexAttributeSet
  • VertexUnifyTraverser() : VertexUnifyTraverser
  • ViewState() : ViewState
  • VolLoader() : VolLoader
  • VolSaver() : VolSaver
  • VolumeBrick() : VolumeBrick
  • VolumeNode() : VolumeNode
  • VolumeTexture() : VolumeTexture

- w -

  • walk() : WalkCameraManipulator
  • WalkCameraManipulator() : WalkCameraManipulator
  • wasRenderInterrupted() : RenderArea
  • wasTraversalInterrupted() : Traverser
  • WriteMapping() : WriteMapping
  • WRLLoadTraverser() : WRLLoadTraverser

- z -

  • zoom() : Camera

- ~ -

  • ~Allocator() : Allocator
  • ~AlphaTestAttribute() : AlphaTestAttribute
  • ~AnalyzeResult() : AnalyzeResult
  • ~AnalyzeTraverser() : AnalyzeTraverser
  • ~AnimatedTransform() : AnimatedTransform
  • ~AnimatedVertexAttributeSet() : AnimatedVertexAttributeSet
  • ~Animation() : Animation
  • ~AnimationManipulator() : AnimationManipulator
  • ~AppTraverser() : AppTraverser
  • ~BalanceTraverser() : BalanceTraverser
  • ~BaseRenderElement() : BaseRenderElement
  • ~Billboard() : Billboard
  • ~BlendAttribute() : BlendAttribute
  • ~Bone() : Bone
  • ~CallbackServer() : CallbackServer
  • ~Camera() : Camera
  • ~CgFx() : CgFx
  • ~CgFxContext() : CgFxContext
  • ~CgFxEffect() : CgFxEffect
  • ~ChangeCallback() : ChangeCallback
  • ~CombineTraverser() : CombineTraverser
  • ~CullData() : CullData
  • ~CullTraverser() : CullTraverser
  • ~DepthAttribute() : DepthAttribute
  • ~DestrippingTraverser() : DestrippingTraverser
  • ~DirectedLight() : DirectedLight
  • ~Drawable() : Drawable
  • ~EliminateTraverser() : EliminateTraverser
  • ~EmptyResult() : EmptyResult
  • ~EquivalenceResult() : EquivalenceResult
  • ~ExclusiveModelViewTraverser() : ExclusiveModelViewTraverser
  • ~ExclusiveTraverser() : ExclusiveTraverser
  • ~ExtractGeometryTraverser() : ExtractGeometryTraverser
  • ~FaceAttribute() : FaceAttribute
  • ~FileMapping() : FileMapping
  • ~FixedAllocator() : FixedAllocator
  • ~FlightCameraManipulator() : FlightCameraManipulator
  • ~FlipbookAnimation() : FlipbookAnimation
  • ~FramedAnimation() : FramedAnimation
  • ~FrustumCullTraverser() : FrustumCullTraverser
  • ~GeoNode() : GeoNode
  • ~GLFunctions() : GLFunctions
  • ~GLMFCRAWnd() : GLMFCRAWnd
  • ~GLObjects() : GLObjects
  • ~GLTraverser() : GLTraverser
  • ~GLUploadTraverser() : GLUploadTraverser
  • ~GLWinRenderArea() : GLWinRenderArea
  • ~GPUSkinningProcessor() : GPUSkinningProcessor
  • ~Group() : Group
  • ~HighlightEdges() : HighlightEdges
  • ~HighlightElement() : HighlightElement
  • ~HighlightObject() : HighlightObject
  • ~IAllocator() : IAllocator
  • ~IdentityResult() : IdentityResult
  • ~IdentityToGroupTraverser() : IdentityToGroupTraverser
  • ~ILTexLoader() : ILTexLoader
  • ~IndependentPrimitiveSet() : IndependentPrimitiveSet
  • ~Intersection() : Intersection
  • ~KeyFramedAnimation() : KeyFramedAnimation
  • ~KeyInput() : KeyInput
  • ~LightingAttribute() : LightingAttribute
  • ~LightsElement() : LightsElement
  • ~LightSource() : LightSource
  • ~LinearInterpolatedAnimation() : LinearInterpolatedAnimation
  • ~LineAttribute() : LineAttribute
  • ~Lines() : Lines
  • ~LineStrips() : LineStrips
  • ~LOD() : LOD
  • ~Manipulator() : Manipulator
  • ~Map() : Map
  • ~MapArray() : MapArray
  • ~MapElement() : MapElement
  • ~MapList() : MapList
  • ~MapMatrix() : MapMatrix
  • ~MapObject() : MapObject
  • ~Material() : Material
  • ~MeshedPrimitiveSet() : MeshedPrimitiveSet
  • ~MissingResult() : MissingResult
  • ~MouseInput() : MouseInput
  • ~NBFLoader() : NBFLoader
  • ~Node() : Node
  • ~NodeHintsCullTraverser() : NodeHintsCullTraverser
  • ~NormalizeTraverser() : NormalizeTraverser
  • ~NullNormalsResult() : NullNormalsResult
  • ~NVBLoader() : NVBLoader
  • ~NVBLoadTraverser() : NVBLoadTraverser
  • ~Object() : Object
  • ~OptimizeTraverser() : OptimizeTraverser
  • ~OwnedObject() : OwnedObject
  • ~ParallelCamera() : ParallelCamera
  • ~Path() : Path
  • ~PerspectiveCamera() : PerspectiveCamera
  • ~PlugInCallback() : PlugInCallback
  • ~PointAttribute() : PointAttribute
  • ~PointLight() : PointLight
  • ~Points() : Points
  • ~PrimitiveAttribute() : PrimitiveAttribute
  • ~PrimitiveSet() : PrimitiveSet
  • ~QuadMeshes() : QuadMeshes
  • ~Quads() : Quads
  • ~QuadStrips() : QuadStrips
  • ~RayIntersectTraverser() : RayIntersectTraverser
  • ~RCIPtr() : RCIPtr
  • ~RCObject() : RCObject
  • ~RCObject_AutoPtr() : RCObject_AutoPtr
  • ~RCPtr() : RCPtr
  • ~ReadMapping() : ReadMapping
  • ~RedundantLODRangesResult() : RedundantLODRangesResult
  • ~RegVal() : RegVal
  • ~RenderArea() : RenderArea
  • ~RenderElement() : RenderElement
  • ~RenderTraverser() : RenderTraverser
  • ~Scene() : Scene
  • ~SceneLoader() : SceneLoader
  • ~SceneSaver() : SceneSaver
  • ~SearchTraverser() : SearchTraverser
  • ~Shape() : Shape
  • ~SharedModelViewTraverser() : SharedModelViewTraverser
  • ~SharedTraverser() : SharedTraverser
  • ~SingleChildResult() : SingleChildResult
  • ~Skin() : Skin
  • ~SkinnedTriangles() : SkinnedTriangles
  • ~SmoothTraverser() : SmoothTraverser
  • ~SpotLight() : SpotLight
  • ~StateAttribute() : StateAttribute
  • ~StatePass() : StatePass
  • ~StateSet() : StateSet
  • ~StateVariant() : StateVariant
  • ~StrippedPrimitiveSet() : StrippedPrimitiveSet
  • ~StrippingTraverser() : StrippingTraverser
  • ~Switch() : Switch
  • ~SWMRSync() : SWMRSync
  • ~TextureAttribute() : TextureAttribute
  • ~TextureAttributeItem() : TextureAttributeItem
  • ~TextureImage() : TextureImage
  • ~TextureLoader() : TextureLoader
  • ~TextureSaver() : TextureSaver
  • ~Trace() : Trace
  • ~Trackball() : Trackball
  • ~TrackballCameraManipulator() : TrackballCameraManipulator
  • ~TrackballTransformManipulator() : TrackballTransformManipulator
  • ~Transform() : Transform
  • ~TransformManipulator() : TransformManipulator
  • ~Traverser() : Traverser
  • ~Triangles() : Triangles
  • ~TriangulateTraverser() : TriangulateTraverser
  • ~TriFans() : TriFans
  • ~TriStrips() : TriStrips
  • ~UnifyTraverser() : UnifyTraverser
  • ~UnlitColorAttribute() : UnlitColorAttribute
  • ~VertexAttribute() : VertexAttribute
  • ~VertexAttributeSet() : VertexAttributeSet
  • ~VertexUnifyTraverser() : VertexUnifyTraverser
  • ~ViewState() : ViewState
  • ~VolLoader() : VolLoader
  • ~VolSaver() : VolSaver
  • ~VolumeBrick() : VolumeBrick
  • ~VolumeNode() : VolumeNode
  • ~VolumeTexture() : VolumeTexture
  • ~WalkCameraManipulator() : WalkCameraManipulator
  • ~WriteMapping() : WriteMapping
  • ~WRLLoadTraverser() : WRLLoadTraverser
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions
a | c | g | l | o | q | r | s | w

- a -

  • addPlugInSearchPath : PlugInServer

- c -

  • calculateTangentSpace() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • clone() : CullData, Handle< T, Handle< U, V > >, Handle< T, NullType >, Intersection

- g -

  • generateNormals() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • generateTexCoords() : VertexAttributeSet, GeoNode
  • getInterface : PlugInServer
  • getPlugInSearchPath : PlugInServer
  • getPlugInterface : VolSaver, ILTexSaver, VolLoader, ILTexLoader
  • GLAccum : GLContext
  • GLActiveStencilFace : GLContext
  • GLActiveTexture : GLContext
  • GLActiveVarying : GLContext
  • GLAddSwapHintRect : GLContext
  • GLAlphaFunc : GLContext
  • GLAreProgramsResident : GLContext
  • GLAreTexturesResident : GLContext
  • GLArrayElement : GLContext
  • GLAttachObject : GLContext
  • GLAttachShader : GLContext
  • GLBegin : GLContext
  • GLBeginOcclusionQuery : GLContext
  • GLBeginQuery : GLContext
  • GLBeginTransformFeedback : GLContext
  • GLBindArraySet : GLContext
  • GLBindAttribLocation : GLContext
  • GLBindBuffer : GLContext
  • GLBindBufferBase : GLContext
  • GLBindBufferOffset : GLContext
  • GLBindBufferRange : GLContext
  • GLBindFragDataLocation : GLContext
  • GLBindFramebuffer : GLContext
  • GLBindProgram : GLContext
  • GLBindRenderbuffer : GLContext
  • GLBindTexture : GLContext
  • GLBitmap : GLContext
  • GLBlendColor : GLContext
  • GLBlendEquation : GLContext
  • GLBlendEquationSeparate : GLContext
  • GLBlendFunc : GLContext
  • GLBlendFuncSeparate : GLContext
  • GLBlitFramebuffer : GLContext
  • GLBufferData : GLContext
  • GLBufferSubData : GLContext
  • GLCallList : GLContext
  • GLCallLists : GLContext
  • GLCheckFramebufferStatus : GLContext
  • GLClampColor : GLContext
  • GLClear : GLContext
  • GLClearAccum : GLContext
  • GLClearColor : GLContext
  • GLClearColorIi : GLContext
  • GLClearColorIui : GLContext
  • GLClearDepth : GLContext
  • GLClearDepthd : GLContext
  • GLClearIndex : GLContext
  • GLClearStencil : GLContext
  • GLClientActiveTexture : GLContext
  • GLClipPlane : GLContext
  • GLColor3b : GLContext
  • GLColor3bv : GLContext
  • GLColor3d : GLContext
  • GLColor3dv : GLContext
  • GLColor3f : GLContext
  • GLColor3fv : GLContext
  • GLColor3h : GLContext
  • GLColor3hv : GLContext
  • GLColor3i : GLContext
  • GLColor3iv : GLContext
  • GLColor3s : GLContext
  • GLColor3sv : GLContext
  • GLColor3ub : GLContext
  • GLColor3ubv : GLContext
  • GLColor3ui : GLContext
  • GLColor3uiv : GLContext
  • GLColor3us : GLContext
  • GLColor3usv : GLContext
  • GLColor4b : GLContext
  • GLColor4bv : GLContext
  • GLColor4d : GLContext
  • GLColor4dv : GLContext
  • GLColor4f : GLContext
  • GLColor4fv : GLContext
  • GLColor4h : GLContext
  • GLColor4hv : GLContext
  • GLColor4i : GLContext
  • GLColor4iv : GLContext
  • GLColor4s : GLContext
  • GLColor4sv : GLContext
  • GLColor4ub : GLContext
  • GLColor4ubv : GLContext
  • GLColor4ui : GLContext
  • GLColor4uiv : GLContext
  • GLColor4us : GLContext
  • GLColor4usv : GLContext
  • GLColorMask : GLContext
  • GLColorMaskIndexed : GLContext
  • GLColorMaterial : GLContext
  • GLColorPointer : GLContext
  • GLColorSubTable : GLContext
  • GLColorTable : GLContext
  • GLColorTableParameterfv : GLContext
  • GLColorTableParameteriv : GLContext
  • GLCombinerInput : GLContext
  • GLCombinerOutput : GLContext
  • GLCombinerParameterf : GLContext
  • GLCombinerParameterfv : GLContext
  • GLCombinerParameteri : GLContext
  • GLCombinerParameteriv : GLContext
  • GLCombinerStageParameterfv : GLContext
  • GLCompileShader : GLContext
  • GLCompressedTexImage1D : GLContext
  • GLCompressedTexImage2D : GLContext
  • GLCompressedTexImage3D : GLContext
  • GLCompressedTexSubImage1D : GLContext
  • GLCompressedTexSubImage2D : GLContext
  • GLCompressedTexSubImage3D : GLContext
  • GLConvolutionFilter1D : GLContext
  • GLConvolutionFilter2D : GLContext
  • GLConvolutionParameterf : GLContext
  • GLConvolutionParameterfv : GLContext
  • GLConvolutionParameteri : GLContext
  • GLConvolutionParameteriv : GLContext
  • GLCopyColorSubTable : GLContext
  • GLCopyColorTable : GLContext
  • GLCopyConvolutionFilter1D : GLContext
  • GLCopyConvolutionFilter2D : GLContext
  • GLCopyPixels : GLContext
  • GLCopyTexImage1D : GLContext
  • GLCopyTexImage2D : GLContext
  • GLCopyTexSubImage1D : GLContext
  • GLCopyTexSubImage2D : GLContext
  • GLCopyTexSubImage3D : GLContext
  • GLCreateProgram : GLContext
  • GLCreateProgramObject : GLContext
  • GLCreateShader : GLContext
  • GLCreateShaderObject : GLContext
  • GLCullFace : GLContext
  • GLCullFaceLock : GLContext
  • GLCullFaceUnlock : GLContext
  • GLDeleteArraySets : GLContext
  • GLDeleteBuffers : GLContext
  • GLDeleteFences : GLContext
  • GLDeleteFramebuffers : GLContext
  • GLDeleteLists : GLContext
  • GLDeleteObject : GLContext
  • GLDeleteOcclusionQueries : GLContext
  • GLDeleteProgram : GLContext
  • GLDeletePrograms : GLContext
  • GLDeleteQueries : GLContext
  • GLDeleteRenderbuffers : GLContext
  • GLDeleteShader : GLContext
  • GLDeleteTextures : GLContext
  • GLDepthBounds : GLContext
  • GLDepthBoundsd : GLContext
  • GLDepthFunc : GLContext
  • GLDepthMask : GLContext
  • GLDepthRange : GLContext
  • GLDepthRanged : GLContext
  • GLDetachObject : GLContext
  • GLDetachShader : GLContext
  • GLDisable : GLContext
  • GLDisableAlphaTest : GLContext
  • GLDisableAutoNormal : GLContext
  • GLDisableBlend : GLContext
  • GLDisableClientState : GLContext
  • GLDisableClipPlane : GLContext
  • GLDisableColorArray : GLContext
  • GLDisableColorLogicOp : GLContext
  • GLDisableColorMaterial : GLContext
  • GLDisableCullFace : GLContext
  • GLDisableCullFaceLock : GLContext
  • GLDisableCullFaceUnlock : GLContext
  • GLDisableDepthTest : GLContext
  • GLDisableDither : GLContext
  • GLDisableFog : GLContext
  • GLDisableFogCoordinateArray : GLContext
  • GLDisableIndexed : GLContext
  • GLDisableLight : GLContext
  • GLDisableLighting : GLContext
  • GLDisableLightingLock : GLContext
  • GLDisableLightingUnlock : GLContext
  • GLDisableLineSmooth : GLContext
  • GLDisableLineStipple : GLContext
  • GLDisableLogicOp : GLContext
  • GLDisableNormalArray : GLContext
  • GLDisableNormalize : GLContext
  • GLDisablePointSmooth : GLContext
  • GLDisablePolygonOffsetFill : GLContext
  • GLDisablePolygonOffsetLine : GLContext
  • GLDisablePolygonOffsetPoint : GLContext
  • GLDisablePolygonSmooth : GLContext
  • GLDisablePolygonStipple : GLContext
  • GLDisableScissorTest : GLContext
  • GLDisableSecondaryColorArray : GLContext
  • GLDisableStencilTest : GLContext
  • GLDisableTexture : GLContext
  • GLDisableTextureCoordArray : GLContext
  • GLDisableTextureGen : GLContext
  • GLDisableVertexArray : GLContext
  • GLDisableVertexAttribArray : GLContext
  • GLDrawArrays : GLContext
  • GLDrawArraysInstanced : GLContext
  • GLDrawBuffer : GLContext
  • GLDrawBuffers : GLContext
  • GLDrawElements : GLContext
  • GLDrawElementsInstanced : GLContext
  • GLDrawPixels : GLContext
  • GLDrawRangeElements : GLContext
  • GLEdgeFlag : GLContext
  • GLEdgeFlagPointer : GLContext
  • GLEdgeFlagv : GLContext
  • GLEnable : GLContext
  • GLEnableAlphaTest : GLContext
  • GLEnableAutoNormal : GLContext
  • GLEnableBlend : GLContext
  • GLEnableClientState : GLContext
  • GLEnableClipPlane : GLContext
  • GLEnableColorArray : GLContext
  • GLEnableColorLogicOp : GLContext
  • GLEnableColorMaterial : GLContext
  • GLEnableCullFace : GLContext
  • GLEnableCullFaceLock : GLContext
  • GLEnableCullFaceUnlock : GLContext
  • GLEnableDepthTest : GLContext
  • GLEnableDither : GLContext
  • GLEnableFog : GLContext
  • GLEnableFogCoordinateArray : GLContext
  • GLEnableIndexed : GLContext
  • GLEnableLight : GLContext
  • GLEnableLighting : GLContext
  • GLEnableLineSmooth : GLContext
  • GLEnableLineStipple : GLContext
  • GLEnableLogicOp : GLContext
  • GLEnableNormalArray : GLContext
  • GLEnableNormalize : GLContext
  • GLEnablePointSmooth : GLContext
  • GLEnablePolygonOffsetFill : GLContext
  • GLEnablePolygonOffsetLine : GLContext
  • GLEnablePolygonOffsetPoint : GLContext
  • GLEnablePolygonSmooth : GLContext
  • GLEnablePolygonStipple : GLContext
  • GLEnableScissorTest : GLContext
  • GLEnableSecondaryColorArray : GLContext
  • GLEnableStencilTest : GLContext
  • GLEnableTexture : GLContext
  • GLEnableTextureCoordArray : GLContext
  • GLEnableTextureGen : GLContext
  • GLEnableVertexArray : GLContext
  • GLEnableVertexAttribArray : GLContext
  • GLEnd : GLContext
  • GLEndList : GLContext
  • GLEndOcclusionQuery : GLContext
  • GLEndQuery : GLContext
  • GLEndTransformFeedback : GLContext
  • GLEvalCoord1d : GLContext
  • GLEvalCoord1f : GLContext
  • GLEvalCoord2d : GLContext
  • GLEvalCoord2f : GLContext
  • GLEvalMesh1 : GLContext
  • GLEvalMesh2 : GLContext
  • GLEvalPoint1 : GLContext
  • GLEvalPoint2 : GLContext
  • GLExecuteProgram : GLContext
  • GLFeedbackBuffer : GLContext
  • GLFinalCombinerInput : GLContext
  • GLFinish : GLContext
  • GLFinishFence : GLContext
  • GLFlush : GLContext
  • GLFlushPixelDataRange : GLContext
  • GLFlushVertexArrayRange : GLContext
  • GLFogColor : GLContext
  • GLFogCoordd : GLContext
  • GLFogCoorddv : GLContext
  • GLFogCoordf : GLContext
  • GLFogCoordfv : GLContext
  • GLFogCoordh : GLContext
  • GLFogCoordhv : GLContext
  • GLFogCoordPointer : GLContext
  • GLFogDensity : GLContext
  • GLFogEnd : GLContext
  • GLFogf : GLContext
  • GLFogfv : GLContext
  • GLFogi : GLContext
  • GLFogiv : GLContext
  • GLFogMode : GLContext
  • GLFogStart : GLContext
  • GLFramebufferRenderbuffer : GLContext
  • GLFramebufferTexture : GLContext
  • GLFramebufferTexture1D : GLContext
  • GLFramebufferTexture2D : GLContext
  • GLFramebufferTexture3D : GLContext
  • GLFramebufferTextureFace : GLContext
  • GLFramebufferTextureLayer : GLContext
  • GLFrameTerminator : GLContext
  • GLFrontFace : GLContext
  • GLFrustum : GLContext
  • GLGenArraySets : GLContext
  • GLGenBuffers : GLContext
  • GLGenerateMipmap : GLContext
  • GLGenFences : GLContext
  • GLGenFramebuffers : GLContext
  • GLGenLists : GLContext
  • GLGenOcclusionQueries : GLContext
  • GLGenPrograms : GLContext
  • GLGenQueries : GLContext
  • GLGenRenderbuffers : GLContext
  • GLGenTextures : GLContext
  • GLGetActiveAttrib : GLContext
  • GLGetActiveUniform : GLContext
  • GLGetActiveVarying : GLContext
  • GLGetAttachedObjects : GLContext
  • GLGetAttachedShaders : GLContext
  • GLGetAttribLocation : GLContext
  • GLGetBooleanIndexedv : GLContext
  • GLGetBooleanv : GLContext
  • GLGetBufferParameteriv : GLContext
  • GLGetBufferPointerv : GLContext
  • GLGetBufferSubData : GLContext
  • GLGetClipPlane : GLContext
  • GLGetColorTable : GLContext
  • GLGetColorTableParameterfv : GLContext
  • GLGetColorTableParameteriv : GLContext
  • GLGetCombinerInputParameterfv : GLContext
  • GLGetCombinerInputParameteriv : GLContext
  • GLGetCombinerOutputParameterfv : GLContext
  • GLGetCombinerOutputParameteriv : GLContext
  • GLGetCombinerStageParameterfv : GLContext
  • GLGetCompressedTexImage : GLContext
  • GLGetConvolutionFilter : GLContext
  • GLGetConvolutionParameterfv : GLContext
  • GLGetConvolutionParameteriv : GLContext
  • GLGetDoublev : GLContext
  • GLGetFenceiv : GLContext
  • GLGetFinalCombinerInputParameterfv : GLContext
  • GLGetFinalCombinerInputParameteriv : GLContext
  • GLGetFloatv : GLContext
  • GLGetFragDataLocation : GLContext
  • GLGetFramebufferAttachmentParameteriv : GLContext
  • GLGetHandle : GLContext
  • GLGetHistogram : GLContext
  • GLGetHistogramParameterfv : GLContext
  • GLGetHistogramParameteriv : GLContext
  • GLGetInfoLog : GLContext
  • GLGetIntegerIndexedv : GLContext
  • GLGetIntegerv : GLContext
  • GLGetLightfv : GLContext
  • GLGetLightiv : GLContext
  • GLGetMapdv : GLContext
  • GLGetMapfv : GLContext
  • GLGetMapiv : GLContext
  • GLGetMaterialfv : GLContext
  • GLGetMaterialiv : GLContext
  • GLGetMaxTexCoords : GLContext
  • GLGetMaxTexImageUnits : GLContext
  • GLGetMaxTexUnits : GLContext
  • GLGetMinmax : GLContext
  • GLGetMinmaxParameterfv : GLContext
  • GLGetMinmaxParameteriv : GLContext
  • GLGetObjectParameterfv : GLContext
  • GLGetObjectParameteriv : GLContext
  • GLGetOcclusionQueryiv : GLContext
  • GLGetOcclusionQueryuiv : GLContext
  • GLGetPixelMapfv : GLContext
  • GLGetPixelMapuiv : GLContext
  • GLGetPixelMapusv : GLContext
  • GLGetPointerv : GLContext
  • GLGetPolygonStipple : GLContext
  • GLGetProgramEnvParameterdv : GLContext
  • GLGetProgramEnvParameterfv : GLContext
  • GLGetProgramEnvParameterIiv : GLContext
  • GLGetProgramEnvParameterIuiv : GLContext
  • GLGetProgramInfoLog : GLContext
  • GLGetProgramiv : GLContext
  • GLGetProgramLocalParameterdv : GLContext
  • GLGetProgramLocalParameterfv : GLContext
  • GLGetProgramLocalParameterIiv : GLContext
  • GLGetProgramLocalParameterIuiv : GLContext
  • GLGetProgramNamedParameterdv : GLContext
  • GLGetProgramNamedParameterfv : GLContext
  • GLGetProgramParameterdv : GLContext
  • GLGetProgramParameterfv : GLContext
  • GLGetProgramString : GLContext
  • GLGetQueryiv : GLContext
  • GLGetQueryObjecti64v : GLContext
  • GLGetQueryObjectiv : GLContext
  • GLGetQueryObjectui64v : GLContext
  • GLGetQueryObjectuiv : GLContext
  • GLGetRenderbufferParameteriv : GLContext
  • GLGetSeparableFilter : GLContext
  • GLGetShaderInfoLog : GLContext
  • GLGetShaderiv : GLContext
  • GLGetShaderSource : GLContext
  • GLGetString : GLContext
  • GLGetTexEnvfv : GLContext
  • GLGetTexEnviv : GLContext
  • GLGetTexGendv : GLContext
  • GLGetTexGenfv : GLContext
  • GLGetTexGeniv : GLContext
  • GLGetTexImage : GLContext
  • GLGetTexImageFmt : GLContext
  • GLGetTexLevelParameterfv : GLContext
  • GLGetTexLevelParameteriv : GLContext
  • GLGetTexParameterfv : GLContext
  • GLGetTexParameterIiv : GLContext
  • GLGetTexParameterIuiv : GLContext
  • GLGetTexParameteriv : GLContext
  • GLGetTexWrapMode : GLContext
  • GLGetTrackMatrixiv : GLContext
  • GLGetTransformFeedbackVarying : GLContext
  • GLGetUniformBufferSize : GLContext
  • GLGetUniformfv : GLContext
  • GLGetUniformiv : GLContext
  • GLGetUniformLocation : GLContext
  • GLGetUniformOffset : GLContext
  • GLGetUniformuiv : GLContext
  • GLGetVaryingLocation : GLContext
  • GLGetVersion : GLContext
  • GLGetVertexAttribdv : GLContext
  • GLGetVertexAttribfv : GLContext
  • GLGetVertexAttribIiv : GLContext
  • GLGetVertexAttribIuiv : GLContext
  • GLGetVertexAttribiv : GLContext
  • GLGetVertexAttribPointerv : GLContext
  • GLHint : GLContext
  • GLHistogram : GLContext
  • GLIndexd : GLContext
  • GLIndexf : GLContext
  • GLIndexi : GLContext
  • GLIndexMask : GLContext
  • GLIndexPointer : GLContext
  • GLIndexs : GLContext
  • GLIndexub : GLContext
  • GLInitNames : GLContext
  • GLInterleavedArrays : GLContext
  • GLIsArraySet : GLContext
  • GLIsBuffer : GLContext
  • GLIsEnabled : GLContext
  • GLIsEnabledAlphaTest : GLContext
  • GLIsEnabledAutoNormal : GLContext
  • GLIsEnabledBlend : GLContext
  • GLIsEnabledClipPlane : GLContext
  • GLIsEnabledColorLogicOp : GLContext
  • GLIsEnabledColorMaterial : GLContext
  • GLIsEnabledCullFace : GLContext
  • GLIsEnabledDepthTest : GLContext
  • GLIsEnabledDither : GLContext
  • GLIsEnabledFog : GLContext
  • GLIsEnabledIndexed : GLContext
  • GLIsEnabledLight : GLContext
  • GLIsEnabledLighting : GLContext
  • GLIsEnabledLineSmooth : GLContext
  • GLIsEnabledLineStipple : GLContext
  • GLIsEnabledLogicOp : GLContext
  • GLIsEnabledNormalize : GLContext
  • GLIsEnabledPointSmooth : GLContext
  • GLIsEnabledPolygonOffsetFill : GLContext
  • GLIsEnabledPolygonOffsetLine : GLContext
  • GLIsEnabledPolygonOffsetPoint : GLContext
  • GLIsEnabledPolygonSmooth : GLContext
  • GLIsEnabledPolygonStipple : GLContext
  • GLIsEnabledScissorTest : GLContext
  • GLIsEnabledStencilTest : GLContext
  • GLIsEnabledTexture : GLContext
  • GLIsEnabledTextureGen : GLContext
  • GLIsExtensionAvailable : GLContext
  • GLIsExtensionExported : GLContext
  • GLIsFence : GLContext
  • GLIsFramebuffer : GLContext
  • GLIsList : GLContext
  • GLIsOcclusionQuery : GLContext
  • GLIsProgram : GLContext
  • GLIsQuery : GLContext
  • GLIsRenderbuffer : GLContext
  • GLIsShader : GLContext
  • GLIsTexture : GLContext
  • GLLightAmbient : GLContext
  • GLLightConstantAttenuation : GLContext
  • GLLightDiffuse : GLContext
  • GLLightf : GLContext
  • GLLightfv : GLContext
  • GLLighti : GLContext
  • GLLightiv : GLContext
  • GLLightLinearAttenuation : GLContext
  • GLLightModelAmbient : GLContext
  • GLLightModelf : GLContext
  • GLLightModelfv : GLContext
  • GLLightModeli : GLContext
  • GLLightModeliv : GLContext
  • GLLightModelLocalViewer : GLContext
  • GLLightModelTwoSide : GLContext
  • GLLightModelTwoSideLock : GLContext
  • GLLightModelTwoSideUnlock : GLContext
  • GLLightPosition : GLContext
  • GLLightQuadraticAttenuation : GLContext
  • GLLightSpecular : GLContext
  • GLLightSpotCutoff : GLContext
  • GLLightSpotDirection : GLContext
  • GLLightSpotExponent : GLContext
  • GLLineStipple : GLContext
  • GLLineWidth : GLContext
  • GLLinkProgram : GLContext
  • GLListBase : GLContext
  • GLLoadIdentity : GLContext
  • GLLoadMatrixd : GLContext
  • GLLoadMatrixf : GLContext
  • GLLoadName : GLContext
  • GLLoadProgram : GLContext
  • GLLoadTransposedMatrixd : GLContext
  • GLLoadTransposeMatrixf : GLContext
  • GLLockArrays : GLContext
  • GLLogicOp : GLContext
  • GLMap1d : GLContext
  • GLMap1f : GLContext
  • GLMap2d : GLContext
  • GLMap2f : GLContext
  • GLMapBuffer : GLContext
  • GLMapGrid1d : GLContext
  • GLMapGrid1f : GLContext
  • GLMapGrid2d : GLContext
  • GLMapGrid2f : GLContext
  • GLMaterialAmbient : GLContext
  • GLMaterialAmbientBack : GLContext
  • GLMaterialAmbientFront : GLContext
  • GLMaterialAmbientFrontAndBack : GLContext
  • GLMaterialDiffuse : GLContext
  • GLMaterialDiffuseBack : GLContext
  • GLMaterialDiffuseFront : GLContext
  • GLMaterialDiffuseFrontAndBack : GLContext
  • GLMaterialEmission : GLContext
  • GLMaterialEmissionBack : GLContext
  • GLMaterialEmissionFront : GLContext
  • GLMaterialEmissionFrontAndBack : GLContext
  • GLMaterialf : GLContext
  • GLMaterialfv : GLContext
  • GLMateriali : GLContext
  • GLMaterialiv : GLContext
  • GLMaterialShininess : GLContext
  • GLMaterialShininessBack : GLContext
  • GLMaterialShininessFront : GLContext
  • GLMaterialShininessFrontAndBack : GLContext
  • GLMaterialSpecular : GLContext
  • GLMaterialSpecularBack : GLContext
  • GLMaterialSpecularFront : GLContext
  • GLMaterialSpecularFrontAndBack : GLContext
  • GLMatrixMode : GLContext
  • GLMinmax : GLContext
  • GLMultiDrawArrays : GLContext
  • GLMultiDrawElements : GLContext
  • GLMultiTexCoord1d : GLContext
  • GLMultiTexCoord1dv : GLContext
  • GLMultiTexCoord1f : GLContext
  • GLMultiTexCoord1fv : GLContext
  • GLMultiTexCoord1h : GLContext
  • GLMultiTexCoord1hv : GLContext
  • GLMultiTexCoord1i : GLContext
  • GLMultiTexCoord1iv : GLContext
  • GLMultiTexCoord1s : GLContext
  • GLMultiTexCoord1sv : GLContext
  • GLMultiTexCoord2d : GLContext
  • GLMultiTexCoord2dv : GLContext
  • GLMultiTexCoord2f : GLContext
  • GLMultiTexCoord2fv : GLContext
  • GLMultiTexCoord2h : GLContext
  • GLMultiTexCoord2hv : GLContext
  • GLMultiTexCoord2i : GLContext
  • GLMultiTexCoord2iv : GLContext
  • GLMultiTexCoord2s : GLContext
  • GLMultiTexCoord2sv : GLContext
  • GLMultiTexCoord3d : GLContext
  • GLMultiTexCoord3dv : GLContext
  • GLMultiTexCoord3f : GLContext
  • GLMultiTexCoord3fv : GLContext
  • GLMultiTexCoord3h : GLContext
  • GLMultiTexCoord3hv : GLContext
  • GLMultiTexCoord3i : GLContext
  • GLMultiTexCoord3iv : GLContext
  • GLMultiTexCoord3s : GLContext
  • GLMultiTexCoord3sv : GLContext
  • GLMultiTexCoord4d : GLContext
  • GLMultiTexCoord4dv : GLContext
  • GLMultiTexCoord4f : GLContext
  • GLMultiTexCoord4fv : GLContext
  • GLMultiTexCoord4h : GLContext
  • GLMultiTexCoord4hv : GLContext
  • GLMultiTexCoord4i : GLContext
  • GLMultiTexCoord4iv : GLContext
  • GLMultiTexCoord4s : GLContext
  • GLMultiTexCoord4sv : GLContext
  • GLMultiTexCoordPointer : GLContext
  • GLMultMatrixd : GLContext
  • GLMultMatrixf : GLContext
  • GLMultTransposeMatrixd : GLContext
  • GLMultTransposeMatrixf : GLContext
  • GLNewList : GLContext
  • GLNormal3b : GLContext
  • GLNormal3bv : GLContext
  • GLNormal3d : GLContext
  • GLNormal3dv : GLContext
  • GLNormal3f : GLContext
  • GLNormal3fv : GLContext
  • GLNormal3h : GLContext
  • GLNormal3hv : GLContext
  • GLNormal3i : GLContext
  • GLNormal3iv : GLContext
  • GLNormal3s : GLContext
  • GLNormal3sv : GLContext
  • GLNormalPointer : GLContext
  • GLOrtho : GLContext
  • GLPassThrough : GLContext
  • GLPixelDataRange : GLContext
  • GLPixelMapfv : GLContext
  • GLPixelMapuiv : GLContext
  • GLPixelMapusv : GLContext
  • GLPixelStoref : GLContext
  • GLPixelStorei : GLContext
  • GLPixelTransferf : GLContext
  • GLPixelTransferi : GLContext
  • GLPixelZoom : GLContext
  • GLPointParameterf : GLContext
  • GLPointParameterfv : GLContext
  • GLPointParameteri : GLContext
  • GLPointParameteriv : GLContext
  • GLPointSize : GLContext
  • GLPolygonMode : GLContext
  • GLPolygonModeBack : GLContext
  • GLPolygonModeFront : GLContext
  • GLPolygonModeFrontAndBack : GLContext
  • GLPolygonModeLock : GLContext
  • GLPolygonModeUnlock : GLContext
  • GLPolygonOffset : GLContext
  • GLPolygonStipple : GLContext
  • GLPopAttrib : GLContext
  • GLPopClientAttrib : GLContext
  • GLPopMatrix : GLContext
  • GLPopName : GLContext
  • GLPrimitiveRestart : GLContext
  • GLPrimitiveRestartIndex : GLContext
  • GLPrioritizeTextures : GLContext
  • GLProgramBufferParametersfv : GLContext
  • GLProgramBufferParametersIiv : GLContext
  • GLProgramBufferParametersIuiv : GLContext
  • GLProgramEnvParameter4d : GLContext
  • GLProgramEnvParameter4dv : GLContext
  • GLProgramEnvParameter4f : GLContext
  • GLProgramEnvParameter4fv : GLContext
  • GLProgramEnvParameterI4i : GLContext
  • GLProgramEnvParameterI4iv : GLContext
  • GLProgramEnvParameterI4ui : GLContext
  • GLProgramEnvParameterI4uiv : GLContext
  • GLProgramEnvParameters4fv : GLContext
  • GLProgramEnvParametersI4iv : GLContext
  • GLProgramEnvParametersI4uiv : GLContext
  • GLProgramLocalParameter4d : GLContext
  • GLProgramLocalParameter4dv : GLContext
  • GLProgramLocalParameter4f : GLContext
  • GLProgramLocalParameter4fv : GLContext
  • GLProgramLocalParameterI4i : GLContext
  • GLProgramLocalParameterI4iv : GLContext
  • GLProgramLocalParameterI4ui : GLContext
  • GLProgramLocalParameterI4uiv : GLContext
  • GLProgramLocalParameters4fv : GLContext
  • GLProgramLocalParametersI4iv : GLContext
  • GLProgramLocalParametersI4uiv : GLContext
  • GLProgramNamedParameter4d : GLContext
  • GLProgramNamedParameter4dv : GLContext
  • GLProgramNamedParameter4f : GLContext
  • GLProgramNamedParameter4fv : GLContext
  • GLProgramParameter4d : GLContext
  • GLProgramParameter4dv : GLContext
  • GLProgramParameter4f : GLContext
  • GLProgramParameter4fv : GLContext
  • GLProgramParameteri : GLContext
  • GLProgramParameters4dv : GLContext
  • GLProgramParameters4fv : GLContext
  • GLProgramString : GLContext
  • GLProgramVertexLimit : GLContext
  • GLPushAttrib : GLContext
  • GLPushClientAttrib : GLContext
  • GLPushMatrix : GLContext
  • GLPushName : GLContext
  • GLRasterPos2d : GLContext
  • GLRasterPos2f : GLContext
  • GLRasterPos2i : GLContext
  • GLRasterPos2s : GLContext
  • GLRasterPos3d : GLContext
  • GLRasterPos3f : GLContext
  • GLRasterPos3i : GLContext
  • GLRasterPos3s : GLContext
  • GLRasterPos4d : GLContext
  • GLRasterPos4f : GLContext
  • GLRasterPos4i : GLContext
  • GLRasterPos4s : GLContext
  • GLReadBuffer : GLContext
  • GLReadPixels : GLContext
  • GLRectd : GLContext
  • GLRectf : GLContext
  • GLRecti : GLContext
  • GLRects : GLContext
  • GLRenderbufferStorage : GLContext
  • GLRenderbufferStorageMultisample : GLContext
  • GLRenderbufferStorageMultisampleCoverage : GLContext
  • GLRenderMode : GLContext
  • GLRequestResidentPrograms : GLContext
  • GLResetAlphaFunc : GLContext
  • GLResetAlphaTest : GLContext
  • GLResetAutoNormal : GLContext
  • GLResetBlend : GLContext
  • GLResetBlendFunc : GLContext
  • GLResetBlendFuncSeparate : GLContext
  • GLResetClearColor : GLContext
  • GLResetClearDepth : GLContext
  • GLResetClearStencil : GLContext
  • GLResetClipPlane : GLContext
  • GLResetClipPlaneEquation : GLContext
  • GLResetColorLogicOp : GLContext
  • GLResetColorMask : GLContext
  • GLResetColorMaterial : GLContext
  • GLResetColorMaterialMode : GLContext
  • GLResetCullFace : GLContext
  • GLResetCullFaceMode : GLContext
  • GLResetDepthFunc : GLContext
  • GLResetDepthMask : GLContext
  • GLResetDepthRange : GLContext
  • GLResetDepthTest : GLContext
  • GLResetDither : GLContext
  • GLResetFog : GLContext
  • GLResetFogColor : GLContext
  • GLResetFogDensity : GLContext
  • GLResetFogEnd : GLContext
  • GLResetFogMode : GLContext
  • GLResetFogStart : GLContext
  • GLResetFrontFace : GLContext
  • GLResetHistogram : GLContext
  • GLResetLight : GLContext
  • GLResetLightAmbient : GLContext
  • GLResetLightConstantAttenuation : GLContext
  • GLResetLightDiffuse : GLContext
  • GLResetLighting : GLContext
  • GLResetLightLinearAttenuation : GLContext
  • GLResetLightModelAmbient : GLContext
  • GLResetLightModelLocalViewer : GLContext
  • GLResetLightModelTwoSide : GLContext
  • GLResetLightPosition : GLContext
  • GLResetLightQuadraticAttenuation : GLContext
  • GLResetLightSpecular : GLContext
  • GLResetLightSpotCutoff : GLContext
  • GLResetLightSpotDirection : GLContext
  • GLResetLightSpotExponent : GLContext
  • GLResetLineSmooth : GLContext
  • GLResetLineStipple : GLContext
  • GLResetLineStippleDefinition : GLContext
  • GLResetLineWidth : GLContext
  • GLResetLogicOp : GLContext
  • GLResetMaterialAmbientBack : GLContext
  • GLResetMaterialAmbientFront : GLContext
  • GLResetMaterialAmbientFrontAndBack : GLContext
  • GLResetMaterialDiffuseBack : GLContext
  • GLResetMaterialDiffuseFront : GLContext
  • GLResetMaterialDiffuseFrontAndBack : GLContext
  • GLResetMaterialEmissionBack : GLContext
  • GLResetMaterialEmissionFront : GLContext
  • GLResetMaterialEmissionFrontAndBack : GLContext
  • GLResetMaterialShininessBack : GLContext
  • GLResetMaterialShininessFront : GLContext
  • GLResetMaterialShininessFrontAndBack : GLContext
  • GLResetMaterialSpecularBack : GLContext
  • GLResetMaterialSpecularFront : GLContext
  • GLResetMaterialSpecularFrontAndBack : GLContext
  • GLResetMinmax : GLContext
  • GLResetNormalize : GLContext
  • GLResetPointSize : GLContext
  • GLResetPointSmooth : GLContext
  • GLResetPolygonModeBack : GLContext
  • GLResetPolygonModeFront : GLContext
  • GLResetPolygonModeFrontAndBack : GLContext
  • GLResetPolygonOffset : GLContext
  • GLResetPolygonOffsetFill : GLContext
  • GLResetPolygonOffsetLine : GLContext
  • GLResetPolygonOffsetPoint : GLContext
  • GLResetPolygonSmooth : GLContext
  • GLResetPolygonStipple : GLContext
  • GLResetScissor : GLContext
  • GLResetScissorTest : GLContext
  • GLResetShadeModel : GLContext
  • GLResetStencilFunc : GLContext
  • GLResetStencilMask : GLContext
  • GLResetStencilOp : GLContext
  • GLResetStencilTest : GLContext
  • GLResetTexture : GLContext
  • GLRotated : GLContext
  • GLRotatef : GLContext
  • GLSampleCoverage : GLContext
  • GLScaled : GLContext
  • GLScalef : GLContext
  • GLScissor : GLContext
  • GLSecondaryColor3b : GLContext
  • GLSecondaryColor3bv : GLContext
  • GLSecondaryColor3d : GLContext
  • GLSecondaryColor3dv : GLContext
  • GLSecondaryColor3f : GLContext
  • GLSecondaryColor3fv : GLContext
  • GLSecondaryColor3h : GLContext
  • GLSecondaryColor3hv : GLContext
  • GLSecondaryColor3i : GLContext
  • GLSecondaryColor3iv : GLContext
  • GLSecondaryColor3s : GLContext
  • GLSecondaryColor3sv : GLContext
  • GLSecondaryColor3ub : GLContext
  • GLSecondaryColor3ubv : GLContext
  • GLSecondaryColor3ui : GLContext
  • GLSecondaryColor3uiv : GLContext
  • GLSecondaryColor3us : GLContext
  • GLSecondaryColor3usv : GLContext
  • GLSecondaryColorPointer : GLContext
  • GLSelectBuffer : GLContext
  • GLSelectTexture : GLContext
  • GLSelectTextureCoordSet : GLContext
  • GLSeparableFilter2D : GLContext
  • GLSetFence : GLContext
  • GLSetWindowStereoMode : GLContext
  • GLShadeModel : GLContext
  • GLShaderSource : GLContext
  • GLStencilClearTag : GLContext
  • GLStencilFunc : GLContext
  • GLStencilFuncSeparate : GLContext
  • GLStencilMask : GLContext
  • GLStencilMaskSeparate : GLContext
  • GLStencilOp : GLContext
  • GLStencilOpSeparate : GLContext
  • GLStringMarker : GLContext
  • GLTestFence : GLContext
  • GLTexBuffer : GLContext
  • GLTexCoord1d : GLContext
  • GLTexCoord1dv : GLContext
  • GLTexCoord1f : GLContext
  • GLTexCoord1fv : GLContext
  • GLTexCoord1h : GLContext
  • GLTexCoord1hv : GLContext
  • GLTexCoord1i : GLContext
  • GLTexCoord1iv : GLContext
  • GLTexCoord1s : GLContext
  • GLTexCoord1sv : GLContext
  • GLTexCoord2d : GLContext
  • GLTexCoord2dv : GLContext
  • GLTexCoord2f : GLContext
  • GLTexCoord2fv : GLContext
  • GLTexCoord2h : GLContext
  • GLTexCoord2hv : GLContext
  • GLTexCoord2i : GLContext
  • GLTexCoord2iv : GLContext
  • GLTexCoord2s : GLContext
  • GLTexCoord2sv : GLContext
  • GLTexCoord3d : GLContext
  • GLTexCoord3dv : GLContext
  • GLTexCoord3f : GLContext
  • GLTexCoord3fv : GLContext
  • GLTexCoord3h : GLContext
  • GLTexCoord3hv : GLContext
  • GLTexCoord3i : GLContext
  • GLTexCoord3iv : GLContext
  • GLTexCoord3s : GLContext
  • GLTexCoord3sv : GLContext
  • GLTexCoord4d : GLContext
  • GLTexCoord4dv : GLContext
  • GLTexCoord4f : GLContext
  • GLTexCoord4fv : GLContext
  • GLTexCoord4h : GLContext
  • GLTexCoord4hv : GLContext
  • GLTexCoord4i : GLContext
  • GLTexCoord4iv : GLContext
  • GLTexCoord4s : GLContext
  • GLTexCoord4sv : GLContext
  • GLTexCoordPointer : GLContext
  • GLTexEnvf : GLContext
  • GLTexEnvfv : GLContext
  • GLTexEnvi : GLContext
  • GLTexEnviv : GLContext
  • GLTexGend : GLContext
  • GLTexGenf : GLContext
  • GLTexGenfv : GLContext
  • GLTexGeni : GLContext
  • GLTexImage1D : GLContext
  • GLTexImage2D : GLContext
  • GLTexImage3D : GLContext
  • GLTexParameterf : GLContext
  • GLTexParameterfv : GLContext
  • GLTexParameteri : GLContext
  • GLTexParameterIiv : GLContext
  • GLTexParameterIuiv : GLContext
  • GLTexParameteriv : GLContext
  • GLTexSubImage1D : GLContext
  • GLTexSubImage2D : GLContext
  • GLTexSubImage3D : GLContext
  • GLTextureBorderColor : GLContext
  • GLTextureEnvColor : GLContext
  • GLTextureEnvMode : GLContext
  • GLTextureMagFilter : GLContext
  • GLTextureMinFilter : GLContext
  • GLTextureWrapR : GLContext
  • GLTextureWrapS : GLContext
  • GLTextureWrapT : GLContext
  • GLTrackMatrix : GLContext
  • GLTransformFeedbackAttribs : GLContext
  • GLTransformFeedbackVaryings : GLContext
  • GLTranslated : GLContext
  • GLTranslatef : GLContext
  • GLUniform1f : GLContext
  • GLUniform1fv : GLContext
  • GLUniform1i : GLContext
  • GLUniform1iv : GLContext
  • GLUniform1ui : GLContext
  • GLUniform1uiv : GLContext
  • GLUniform2f : GLContext
  • GLUniform2fv : GLContext
  • GLUniform2i : GLContext
  • GLUniform2iv : GLContext
  • GLUniform2ui : GLContext
  • GLUniform2uiv : GLContext
  • GLUniform3f : GLContext
  • GLUniform3fv : GLContext
  • GLUniform3i : GLContext
  • GLUniform3iv : GLContext
  • GLUniform3ui : GLContext
  • GLUniform3uiv : GLContext
  • GLUniform4f : GLContext
  • GLUniform4fv : GLContext
  • GLUniform4i : GLContext
  • GLUniform4iv : GLContext
  • GLUniform4ui : GLContext
  • GLUniform4uiv : GLContext
  • GLUniformBuffer : GLContext
  • GLUniformMatrix2fv : GLContext
  • GLUniformMatrix2x3fv : GLContext
  • GLUniformMatrix2x4fv : GLContext
  • GLUniformMatrix3fv : GLContext
  • GLUniformMatrix3x2fv : GLContext
  • GLUniformMatrix3x4fv : GLContext
  • GLUniformMatrix4fv : GLContext
  • GLUniformMatrix4x2fv : GLContext
  • GLUniformMatrix4x3fv : GLContext
  • GLUnlockArrays : GLContext
  • GLUnmapBuffer : GLContext
  • GLUseProgram : GLContext
  • GLUseProgramObject : GLContext
  • GLValidateProgram : GLContext
  • GLValidBackBufferHint : GLContext
  • GLVertex2d : GLContext
  • GLVertex2dv : GLContext
  • GLVertex2f : GLContext
  • GLVertex2fv : GLContext
  • GLVertex2h : GLContext
  • GLVertex2hv : GLContext
  • GLVertex2i : GLContext
  • GLVertex2iv : GLContext
  • GLVertex2s : GLContext
  • GLVertex2sv : GLContext
  • GLVertex3d : GLContext
  • GLVertex3dv : GLContext
  • GLVertex3f : GLContext
  • GLVertex3fv : GLContext
  • GLVertex3h : GLContext
  • GLVertex3hv : GLContext
  • GLVertex3i : GLContext
  • GLVertex3iv : GLContext
  • GLVertex3s : GLContext
  • GLVertex3sv : GLContext
  • GLVertex4d : GLContext
  • GLVertex4dv : GLContext
  • GLVertex4f : GLContext
  • GLVertex4fv : GLContext
  • GLVertex4h : GLContext
  • GLVertex4hv : GLContext
  • GLVertex4i : GLContext
  • GLVertex4iv : GLContext
  • GLVertex4s : GLContext
  • GLVertex4sv : GLContext
  • GLVertexArrayRange : GLContext
  • GLVertexAttrib1d : GLContext
  • GLVertexAttrib1dv : GLContext
  • GLVertexAttrib1f : GLContext
  • GLVertexAttrib1fv : GLContext
  • GLVertexAttrib1h : GLContext
  • GLVertexAttrib1hv : GLContext
  • GLVertexAttrib1s : GLContext
  • GLVertexAttrib1sv : GLContext
  • GLVertexAttrib2d : GLContext
  • GLVertexAttrib2dv : GLContext
  • GLVertexAttrib2f : GLContext
  • GLVertexAttrib2fv : GLContext
  • GLVertexAttrib2h : GLContext
  • GLVertexAttrib2hv : GLContext
  • GLVertexAttrib2s : GLContext
  • GLVertexAttrib2sv : GLContext
  • GLVertexAttrib3d : GLContext
  • GLVertexAttrib3dv : GLContext
  • GLVertexAttrib3f : GLContext
  • GLVertexAttrib3fv : GLContext
  • GLVertexAttrib3h : GLContext
  • GLVertexAttrib3hv : GLContext
  • GLVertexAttrib3s : GLContext
  • GLVertexAttrib3sv : GLContext
  • GLVertexAttrib4bv : GLContext
  • GLVertexAttrib4d : GLContext
  • GLVertexAttrib4dv : GLContext
  • GLVertexAttrib4f : GLContext
  • GLVertexAttrib4fv : GLContext
  • GLVertexAttrib4h : GLContext
  • GLVertexAttrib4hv : GLContext
  • GLVertexAttrib4iv : GLContext
  • GLVertexAttrib4Nbv : GLContext
  • GLVertexAttrib4Niv : GLContext
  • GLVertexAttrib4Nsv : GLContext
  • GLVertexAttrib4Nub : GLContext
  • GLVertexAttrib4Nubv : GLContext
  • GLVertexAttrib4Nuiv : GLContext
  • GLVertexAttrib4Nusv : GLContext
  • GLVertexAttrib4s : GLContext
  • GLVertexAttrib4sv : GLContext
  • GLVertexAttrib4ub : GLContext
  • GLVertexAttrib4ubv : GLContext
  • GLVertexAttrib4uiv : GLContext
  • GLVertexAttrib4usv : GLContext
  • GLVertexAttribI1i : GLContext
  • GLVertexAttribI1iv : GLContext
  • GLVertexAttribI1ui : GLContext
  • GLVertexAttribI1uiv : GLContext
  • GLVertexAttribI2i : GLContext
  • GLVertexAttribI2iv : GLContext
  • GLVertexAttribI2ui : GLContext
  • GLVertexAttribI2uiv : GLContext
  • GLVertexAttribI3i : GLContext
  • GLVertexAttribI3iv : GLContext
  • GLVertexAttribI3ui : GLContext
  • GLVertexAttribI3uiv : GLContext
  • GLVertexAttribI4bv : GLContext
  • GLVertexAttribI4i : GLContext
  • GLVertexAttribI4iv : GLContext
  • GLVertexAttribI4sv : GLContext
  • GLVertexAttribI4ubv : GLContext
  • GLVertexAttribI4ui : GLContext
  • GLVertexAttribI4uiv : GLContext
  • GLVertexAttribI4usv : GLContext
  • GLVertexAttribIPointer : GLContext
  • GLVertexAttribPointer : GLContext
  • GLVertexAttribPointerNV : GLContext
  • GLVertexAttribs1dvNV : GLContext
  • GLVertexAttribs1fvNV : GLContext
  • GLVertexAttribs1hv : GLContext
  • GLVertexAttribs1svNV : GLContext
  • GLVertexAttribs2dvNV : GLContext
  • GLVertexAttribs2fvNV : GLContext
  • GLVertexAttribs2hv : GLContext
  • GLVertexAttribs2svNV : GLContext
  • GLVertexAttribs3dvNV : GLContext
  • GLVertexAttribs3fvNV : GLContext
  • GLVertexAttribs3hv : GLContext
  • GLVertexAttribs3svNV : GLContext
  • GLVertexAttribs4dvNV : GLContext
  • GLVertexAttribs4fvNV : GLContext
  • GLVertexAttribs4hv : GLContext
  • GLVertexAttribs4svNV : GLContext
  • GLVertexAttribs4ubvNV : GLContext
  • GLVertexPointer : GLContext
  • GLViewport : GLContext
  • GLWindowBackBufferHint : GLContext
  • GLWindowPos2d : GLContext
  • GLWindowPos2dv : GLContext
  • GLWindowPos2f : GLContext
  • GLWindowPos2fv : GLContext
  • GLWindowPos2i : GLContext
  • GLWindowPos2iv : GLContext
  • GLWindowPos2s : GLContext
  • GLWindowPos2sv : GLContext
  • GLWindowPos3d : GLContext
  • GLWindowPos3dv : GLContext
  • GLWindowPos3f : GLContext
  • GLWindowPos3fv : GLContext
  • GLWindowPos3i : GLContext
  • GLWindowPos3iv : GLContext
  • GLWindowPos3s : GLContext
  • GLWindowPos3sv : GLContext
  • GLXCreateContext : GLContext
  • GLXDestroyContext : GLContext
  • GLXGetCurrentContext : GLContext
  • GLXGetCurrentDrawable : GLContext

- l -

  • lerp() : Trafo

- o -

  • operator!= : CullData, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VariantIterator
  • operator< : UPIID, UPITID
  • operator== : CullData, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VNVector, VariantIterator, Bone, Trafo

- q -

  • queryInterfaceType : PlugInServer

- r -

  • releaseInterface : PlugInServer

- s -

  • setPlugInFileFilter : PlugInServer

- w -

  • WGLBindSwapBarrierNV : GLContext
  • WGLBindTexImage : GLContext
  • WGLChoosePixelFormat : GLContext
  • WGLCreateAffinityDC : GLContext
  • WGLCreateContext : GLContext
  • WGLCreatePbuffer : GLContext
  • WGLDeleteContext : GLContext
  • WGLDeleteDC : GLContext
  • WGLDestroyPbuffer : GLContext
  • WGLEnumGpuDevices : GLContext
  • WGLEnumGpus : GLContext
  • WGLEnumGpusFromAffinityDC : GLContext
  • WGLGetCurrentContext : GLContext
  • WGLGetCurrentDC : GLContext
  • WGLGetPbufferDC : GLContext
  • WGLJoinSwapGroupNV : GLContext
  • WGLQueryFrameCountNV : GLContext
  • WGLQueryMaxSwapGroupsNV : GLContext
  • WGLQueryPbuffer : GLContext
  • WGLQuerySwapGroupNV : GLContext
  • WGLReleasePbufferDC : GLContext
  • WGLReleaseTexImage : GLContext
  • WGLResetFrameCountNV : GLContext
  • writeAccess : RCIPtr, RCPtr
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions

  • ConstOwnerIterator : OwnedObject
  • iterator : SearchTraverser
  • MaskIterator : Switch
  • MaskKey : Switch
  • NonConstMaskIterator : Switch
  • OwnerIterator : OwnedObject
  • SwitchMask : Switch
  • theAllocator : IAllocator
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions
a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | y

- a -

  • active : plane_t
  • activeKey : NBFStateSet
  • activeMaskKey : NBFSwitch
  • alignment : NBFBillboard
  • alphaFunction : NBFAlphaTestAttribute
  • ambient : NVSGScene, NVSGMaterial, NVSGLight
  • ambientColor : NBFLightSource, NBFScene
  • animation : NBFLightSource, NBFAnimatedTransform, NBFFlipbookAnimation, bone_t
  • animations : NBFAnimatedVertexAttributeSet
  • annotation : NBFNode
  • antiAliasing : NBFPointAttribute, NBFLineAttribute
  • AREAOFPEACE : WalkCameraManipulator, FlightCameraManipulator
  • attenuation : NBFSpotLight, NBFPointLight
  • attribs : NBFVertexAttributeAnimation

- b -

  • backAmbientColor : NBFMaterial
  • backColor : NBFScene
  • backDiffuseColor : NBFMaterial
  • backEmissiveColor : NBFMaterial
  • backFaceMode : NBFFaceAttribute
  • backImg : NBFScene
  • backOpacity : NBFMaterial
  • backSpecularColor : NBFMaterial
  • backSpecularExponent : NBFMaterial
  • bindings : NBFTextureAttribute
  • bindShapeMatrix : NBFSkin
  • bones : skin_t
  • bricksName : NBFVolumeNode
  • byteOrder : NBFHeader

- c -

  • camera : NBFViewState
  • cameraAnimations : NBFScene
  • cameras : NBFScene
  • castShadow : NBFLightSource
  • center : NBFLOD, trafo_t
  • chars : sstr_t, str_t
  • children : NBFGroup, switchMask_t
  • clipPlanes : NBFGroup
  • color : NBFUnlitColorAttribute
  • combinableCount : CombinableResult
  • combineMethod : NBFViewState
  • compressedFmt : NVSGTexImageFmt
  • constantAttenuation : NVSGLight
  • context : PlugInCallback::InvalidFileInfo, PlugInCallback::IncompatibleFileInfo, PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo, PlugInCallback::EmptyTokenInfo
  • coordDim : texCoordSet_t
  • counts : NBFSkin
  • cullMode : NBFFaceAttribute
  • currTech : NBFCgFx
  • cutoffAngle : NBFSpotLight

- d -

  • dataType : texImage_t
  • dayLastModified : NBFHeader
  • DECREASESPEED : WalkCameraManipulator, FlightCameraManipulator
  • denormalizedNormalsCount : DenormalizedNormalsResult
  • denormalizedNormalsNumber : DenormalizedNormalsResult
  • depth : texImage_t
  • depthFunction : NBFDepthAttribute
  • depthTestingEnabled : NBFDepthAttribute
  • depthWritingEnabled : NBFDepthAttribute
  • destinationFunction : NBFBlendAttribute
  • detectedVersion : PlugInCallback::IncompatibleFileInfo
  • diffuse : NVSGMaterial, NVSGLight
  • diffuseColor : NBFLightSource
  • direction : NVSGLight, NBFSpotLight, NBFDirectedLight, NBFCamera
  • dofJitters : NBFViewState
  • DOLLY1 : TrackballTransformManipulator
  • DOLLY2 : TrackballTransformManipulator, TrackballCameraManipulator
  • drawables : geometrySet_t

- e -

  • emission : NVSGMaterial
  • emptyCount : EmptyResult
  • enabled : NBFLightingAttribute, NBFLightSource
  • enabledMSAlpha : NBFAlphaTestAttribute
  • enableFlags : NBFVertexAttributeSet
  • encountered : PlugInCallback::UnexpectedTokenInfo
  • equivalentCount : EquivalenceResult
  • expected : PlugInCallback::UnexpectedTokenInfo
  • expectedVersion : PlugInCallback::IncompatibleFileInfo

- f -

  • falloffExponent : NBFSpotLight
  • farDist : NBFCamera
  • file : PlugInCallback::InvalidFileInfo, PlugInCallback::IncompatibleFileInfo, PlugInCallback::FileAccessFailedInfo, texImage_t
  • fixedPtFmt : NVSGTexImageFmt
  • flags : texImage_t
  • floatFmt : NVSGTexImageFmt
  • floats : tweak_t
  • FLYBACKWARD : FlightCameraManipulator
  • FLYFORWARD : FlightCameraManipulator
  • focusDist : NBFCamera
  • forward : NBFAnimation
  • frameNumber : NVSGScene
  • fromFile : NBFCgFx
  • frontAmbientColor : NBFMaterial
  • frontDiffuseColor : NBFMaterial
  • frontEmissiveColor : NBFMaterial
  • frontFaceMode : NBFFaceAttribute
  • frontOpacity : NBFMaterial
  • frontSpecularColor : NBFMaterial
  • frontSpecularExponent : NBFMaterial
  • fsaaJitters : NBFViewState

- g -

  • geometrySets : NBFGeoNode

- h -

  • headLights : NBFCamera
  • height : texImage_t, meshSet_t
  • hourLastModified : NBFHeader

- i -

  • identityCount : IdentityResult
  • INCREASESPEED : WalkCameraManipulator, FlightCameraManipulator
  • indices : NBFIndependentPrimitiveSet, NBFSkin, NBFIndexAnimation, meshSet_t, indexSet_t
  • integerFmt : NVSGTexImageFmt
  • intensity : NBFLightSource
  • intFmt : GLTexImageFmt
  • inverseBindMatrices : NBFSkin
  • isAutoClipPlanes : Camera, NBFCamera
  • isShared : RCObject, NBFObject
  • isStereo : ViewState, NBFViewState
  • isStereoAutomatic : NBFViewState

- j -

  • joints : NBFSkin

- k -

  • key : keyVariant_t
  • keys : NBFInterpolatedAnimation
  • keyStateVariantPairs : NBFStateSet

- l -

  • levelToDisplay : NBFVolumeNode
  • lightSources : NBFGroup
  • linearAttenuation : NVSGLight
  • lodRanges : RedundantLODRangesResult
  • loopCount : NBFAnimation

- m -

  • m_accessType : FileMapping
  • m_animationFrame : AppTraverser
  • m_appTraverser : RenderArea
  • m_bApplyingCgFx : AppTraverser
  • m_bones : SkinnedTriangles::Skin
  • m_bpl : Image
  • m_bpp : Image
  • m_bps : Image
  • m_buttonState : MouseInput
  • m_cameraAnimation : AnimationManipulator
  • m_cameraHeightAboveTerrain : WalkCameraManipulator
  • m_cullStack : Traverser
  • m_cullTraverser : RenderArea
  • m_currentTick : AnimationManipulator
  • m_currentX : MouseInput
  • m_currentY : MouseInput
  • m_delta : AnimationManipulator
  • m_depth : Image
  • m_dist : Intersection
  • m_features : RenderArea
  • m_file : FileMapping
  • m_fileMapping : FileMapping
  • m_filename : VolLoader::FileInfo
  • m_format : Image, VolLoader::FileInfo
  • m_hdc : GLWinRenderArea
  • m_height : Image
  • m_hglrc : GLWinRenderArea
  • m_hSensitivity : WalkCameraManipulator, FlightCameraManipulator
  • m_idRenderArea : RenderArea
  • m_indices : Face
  • m_instance : ILTexLoader
  • m_interrupt : Traverser
  • m_isCritical : ProblemInfo
  • m_isp : Intersection
  • m_isValid : FileMapping
  • m_keyInput : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • m_keyState : KeyInput
  • m_lastX : MouseInput
  • m_lastY : MouseInput
  • m_lockedCamera : ExclusiveModelViewTraverser, SharedModelViewTraverser
  • m_lockedScene : ExclusiveTraverser, SharedTraverser
  • m_lockedViewState : ExclusiveTraverser, SharedTraverser
  • m_lodStack : Traverser
  • m_mappingSize : FileMapping
  • m_mftbl : Traverser
  • m_miLast : TrackballCameraManipulator
  • m_missingFeatures : ProblemInfo
  • m_mouseInput : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • m_nob : Image
  • m_normal : SkinnedTriangles::Skin
  • m_numMSBuffers : RenderArea
  • m_objectCode : Object
  • m_overlapSize : VolLoader::FileInfo
  • m_pDrawable : Intersection
  • m_pixels : Image
  • m_pPath : Intersection
  • m_primitiveIndex : Intersection
  • m_problem : ProblemInfo
  • m_problemLog : RenderArea, Traverser
  • m_raCreated : RenderArea
  • m_raHeight : RenderArea
  • m_raWidth : RenderArea
  • m_refCount : ILTexLoader
  • m_renderArea : Manipulator
  • m_renderTraverser : RenderArea
  • m_root : Traverser
  • m_rotationAxis : TrackballCameraManipulator
  • m_scene : RenderArea, Traverser
  • m_ScreenSizeX : WalkCameraManipulator, FlightCameraManipulator
  • m_ScreenSizeY : WalkCameraManipulator, FlightCameraManipulator
  • m_sliceThickness : VolLoader::FileInfo
  • m_speed : WalkCameraManipulator, FlightCameraManipulator
  • m_speedIncreaseFactor : WalkCameraManipulator, FlightCameraManipulator
  • m_startX : MouseInput
  • m_startY : MouseInput
  • m_tbsize : Trackball
  • m_trackball : TrackballCameraManipulator
  • m_trafo : LightSource
  • m_transformPath : TransformManipulator
  • m_transformStack : ExclusiveModelViewTraverser, SharedModelViewTraverser, ExtractGeometryTraverser
  • m_traverser : NBFSaver
  • m_traverserBits : Traverser
  • m_trueY : TrackballTransformManipulator, TrackballCameraManipulator
  • m_type : Image, VolLoader::FileInfo
  • m_vertex : SkinnedTriangles::Skin
  • m_vertexIndices : Intersection
  • m_viewState : RenderArea, Traverser
  • m_vSensitivity : FlightCameraManipulator
  • m_width : Image
  • m_worldUpVector : WalkCameraManipulator, FlightCameraManipulator
  • magFilter : NBFTextureAttributeItem
  • maskKey : switchMask_t
  • masks : NBFSwitch
  • meshes : NBFMeshedPrimitiveSet
  • minFilter : NBFTextureAttributeItem
  • minuteLastModified : NBFHeader
  • missingCount : MissingResult
  • monthLastModified : NBFHeader

- n -

  • name : PlugInCallback::DegenerateGeometryInfo, sampler_t, tweak_t
  • nbfBugfixLevel : NBFHeader
  • nbfMajorVersion : NBFHeader
  • nbfMinorVersion : NBFHeader
  • nearDist : NBFCamera
  • nonLinearFmt : NVSGTexImageFmt
  • normal : plane_t, skin_t
  • normalizeEnableFlags : NBFVertexAttributeSet
  • normalizeFlags : NBFAnimatedVertexAttributeSet
  • normals : VNVector
  • nullNormalsCount : NullNormalsResult
  • nullNormalsNumber : NullNormalsResult
  • numberOfAnimationFrames : NBFScene
  • numBindings : NBFTextureAttribute
  • numBones : skin_t
  • numCameraAnimations : NBFScene
  • numCameras : NBFScene
  • numChars : sstr_t, str_t
  • numChildren : NBFGroup, switchMask_t
  • numClipPlanes : NBFGroup
  • numCounts : NBFSkin
  • numDoFJitters : NBFViewState
  • numDrawables : geometrySet_t
  • numFSAAJitters : NBFViewState
  • numGeometrySets : NBFGeoNode
  • numHeadLights : NBFCamera
  • numIndices : NBFIndependentPrimitiveSet, indexSet_t
  • numJoints : NBFSkin
  • numKeys : NBFInterpolatedAnimation
  • numLightSource : NBFGroup
  • numMasks : NBFSwitch
  • numMeshes : NBFMeshedPrimitiveSet
  • numRanges : NBFLOD
  • numSamplers : NBFCgFx
  • numSkins : NBFSkinnedTriangles
  • numStateAttribs : NBFStatePass
  • numStatePasses : NBFStateVariant
  • numStateVariants : NBFStateSet
  • numSteps : NBFFramedAnimation
  • numStrips : NBFStrippedPrimitiveSet
  • numTexCoords : texCoordSet_t
  • numTweaks : NBFCgFx, tweak_t
  • numValues : tweak_t
  • numVData : vertexAttrib_t
  • nvsgBugfixLevel : NBFHeader
  • nvsgMajorVersion : NBFHeader
  • nvsgMinorVersion : NBFHeader

- o -

  • objectAnno : NBFObject
  • objectCode : AnalyzeResult, NBFObject, NBFViewState
  • objectCount : AnalyzeResult
  • objectDataID : NBFObject
  • objectName : NBFObject
  • offset : plane_t
  • ORBIT : TrackballCameraManipulator
  • orientation : trafo_t

- p -

  • PAN1 : TrackballTransformManipulator, TrackballCameraManipulator
  • PAN2 : TrackballTransformManipulator, TrackballCameraManipulator
  • pixelFormat : texImage_t
  • pixels : texImage_t
  • polygonOffsetEnabled : NBFFaceAttribute
  • polygonOffsetFactor : NBFFaceAttribute
  • polygonOffsetUnits : NBFFaceAttribute
  • position : NVSGLight, PlugInCallback::DegenerateGeometryInfo, PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UnexpectedTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo, PlugInCallback::EmptyTokenInfo, NBFSpotLight, NBFPointLight, NBFCamera

- q -

  • quadraticAttenuation : NVSGLight

- r -

  • ranges : NBFLOD
  • reducedCount : EquivalenceResult, CombinableResult
  • redundantLODRanges : RedundantLODRangesResult
  • redundantLODs : RedundantLODRangesResult
  • reserved : NBFHeader
  • resolution : VolLoader::FileInfo
  • root : NBFScene
  • ROTATE : TrackballTransformManipulator
  • ROTATEXN : TrackballCameraManipulator
  • ROTATEXP : TrackballCameraManipulator
  • ROTATEYN : TrackballCameraManipulator
  • ROTATEYP : TrackballCameraManipulator
  • ROTATEZN : TrackballCameraManipulator
  • ROTATEZP : TrackballCameraManipulator
  • rotationAxis : NBFBillboard

- s -

  • samplers : NBFCgFx
  • scaleOrientation : trafo_t
  • scaling : trafo_t
  • scene : NBFHeader
  • secondLastModified : NBFHeader
  • shader : NBFVolumeNode
  • shininess : NVSGMaterial
  • shortStrippedCount : ShortStrippedResult
  • shortStrippedNumber : ShortStrippedResult
  • signature : NBFHeader
  • singleChildCount : SingleChildResult
  • size : NBFPointAttribute, vertexAttrib_t
  • skin : NBFPrimitiveSet
  • skinningType : NBFSkin
  • skins : NBFSkinnedTriangles
  • source : NBFCgFx
  • sourceFunction : NBFBlendAttribute
  • sourceObject : NBFObject
  • specular : NVSGMaterial, NVSGLight
  • specularColor : NBFLightSource
  • speed : NBFAnimation
  • spotCutoff : NVSGLight
  • spotExponent : NVSGLight
  • stateAttribs : NBFStatePass
  • statePasses : NBFStateVariant
  • stateSet : geometrySet_t
  • stereoAutomaticFactor : NBFViewState
  • stereoEyeDistance : NBFViewState
  • stippleFactor : NBFLineAttribute
  • stipplePattern : NBFLineAttribute
  • str : tweak_t
  • strips : NBFStrippedPrimitiveSet
  • swinging : NBFAnimation
  • systemHints : NBFNode
  • systemSpecificErrorCode : PlugInCallback::FileMappingFailedInfo, PlugInCallback::FileAccessFailedInfo

- t -

  • targetDistance : NBFViewState
  • texAttribItem : texBinding_t
  • texBorderColor : NBFTextureAttributeItem
  • texCoords : texCoordSet_t
  • texEnvColor : NBFTextureAttributeItem
  • texEnvMode : NBFTextureAttributeItem
  • texEnvScale : NBFTextureAttributeItem
  • texGenMode : NBFTextureAttributeItem
  • texGenPlane : NBFTextureAttributeItem
  • texImg : NBFTextureAttributeItem, sampler_t
  • texTarget : NBFTextureAttributeItem
  • texUnit : texBinding_t
  • texWrapR : NBFTextureAttributeItem
  • texWrapS : NBFTextureAttributeItem
  • texWrapT : NBFTextureAttributeItem
  • threshold : NBFAlphaTestAttribute
  • TILT : WalkCameraManipulator
  • token : PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::EmptyTokenInfo
  • trafo : NBFTextureAttributeItem, NBFTransform
  • trafos : NBFTrafoAnimation
  • TRANSLATE : WalkCameraManipulator
  • translation : trafo_t
  • tweaks : NBFCgFx, tweak_t
  • twoSidedLighting : NBFFaceAttribute
  • type : tweak_t, vertexAttrib_t, NVSGTexImageFmt, GLTexImageFmt

- u -

  • UnifyTarget : UnifyTraverser
  • uploadHint : NVSGTexImageFmt, GLTexImageFmt
  • upVector : NBFCamera
  • userHints : NBFNode
  • usrFmt : NVSGTexImageFmt, GLTexImageFmt

- v -

  • value : PlugInCallback::InvalidValueInfo
  • value0 : PlugInCallback::IncompatibleValueInfo
  • value0Name : PlugInCallback::IncompatibleValueInfo
  • value1 : PlugInCallback::IncompatibleValueInfo
  • value1Name : PlugInCallback::IncompatibleValueInfo
  • valueName : PlugInCallback::InvalidValueInfo
  • valueType : PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo
  • variant : keyVariant_t
  • vattribs : NBFVertexAttributeSet
  • vdata : vertexAttrib_t
  • vertex : skin_t
  • vertexAttributeSet : NBFPrimitiveSet
  • vertices : VNVector
  • viewState : NBFHeader
  • volumeName : NBFVolumeNode
  • voxelLimitFraction : NBFVolumeNode

- w -

  • WALKBACKWARD : WalkCameraManipulator
  • WALKFORWARD : WalkCameraManipulator
  • weight : bone_t
  • weights : NBFSkin
  • width : NBFLineAttribute, texImage_t, meshSet_t
  • windowOffset : NBFCamera
  • windowSize : NBFCamera

- y -

  • yearLastModified : NBFHeader
Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


Namespace Index

NVSGSDK Namespace List

Here is a list of all documented namespaces with brief descriptions:
nvgl | Namespace for OpenGL
nvmath | Namespace for mathematical helper functions and classes
nvsg | Scenegrah classes - core NVSG
nvtraverser | Scenegraph traverser classes
nvui | Namespace for user interface and interaction classes
nvutil | Nvutil namespace
nvutil::IO | IO namespace
Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


nvgl Namespace Reference

Namespace for OpenGL. More...

Classes

struct | GLTexImageFmt
GLTexImageFmt specifies the format and data type of a texture image. More...

struct | NVSGTexImageFmt
Internal data structure used to describe formats. More...

class | GLContext
Wrapper for OpenGL functions to provide caching, extension handling, and, in debug mode, error handling per context. More...

class | GLContext::GLLocks
class | GLResourceDeleter
class | GLDALDataCreator
struct | GLDALData
struct | GLTextureCache
struct | GLTextureCache::Deleter
struct | GLTextureCache::GLImageFormat
struct | GLDisplayListCache
struct | GLDisplayListCache::Deleter
struct | GLArrayBufferCache
struct | GLArrayBufferCache::Deleter
struct | GLElementArrayBufferCache
struct | GLElementArrayBufferCache::Deleter
struct | GLPixelBufferCache
struct | GLPixelBufferCache::Deleter
struct | GLEvalVertexAttrib
class | GLFunctions
The GLFunctions class holds the OpenGL extension function pointers. More...

class | WGLFunctions
class | GLXFunctions
class | GLObjects
The GLObjects class is a container of OpenGL objects. More...

struct | GLObjects::GLShareables

Typedefs

typedef nvutil::Singleton<
WGLFunctions > 		theWGLFunctions
typedef nvutil::Singleton<
GLXFunctions > 		theGLXFunctions
typedef std::set< GLuint > | NameSet
typedef NameSet::const_iterator | ConstNameSetIter

Enumerations

enum {
NVSG_ARRAY_BUFFER = 0, NVSG_FIRST_VERTEX_BUFFER = NVSG_ARRAY_BUFFER, NVSG_ELEMENT_ARRAY_BUFFER, NVSG_LAST_VERTEX_BUFFER = NVSG_ELEMENT_ARRAY_BUFFER,
NVSG_PIXEL_PACK_BUFFER, NVSG_FIRST_PIXEL_BUFFER = NVSG_PIXEL_PACK_BUFFER, NVSG_PIXEL_UNPACK_BUFFER, NVSG_LAST_PIXEL_BUFFER = NVSG_PIXEL_UNPACK_BUFFER,
NVSG_NUM_VERTEX_BUFFERS = NVSG_LAST_VERTEX_BUFFER - NVSG_FIRST_VERTEX_BUFFER + 1, NVSG_NUM_PIXEL_BUFFERS = NVSG_LAST_PIXEL_BUFFER - NVSG_FIRST_PIXEL_BUFFER + 1, NVSG_NUM_BUFFERS = NVSG_NUM_VERTEX_BUFFERS + NVSG_NUM_PIXEL_BUFFERS
}
enum {
GL_INVALID_BUFFER_TARGET = -1, GL_VERTEX_BUFFER_INTERLEAVED_GENERIC = 0, GL_FEEDBACK_BUFFER_INTERLEAVED_GENERIC = 1, GL_VERTEX_BUFFER_FIRST = GL_VERTEX_BUFFER_INTERLEAVED_GENERIC,
GL_VERTEX_BUFFER_LAST = GL_FEEDBACK_BUFFER_INTERLEAVED_GENERIC, GL_INDEX_BUFFER_UNSIGNED_SHORT, GL_INDEX_BUFFER_FIRST = GL_INDEX_BUFFER_UNSIGNED_SHORT, GL_INDEX_BUFFER_UNSIGNED_INT,
GL_INDEX_BUFFER_LAST = GL_INDEX_BUFFER_UNSIGNED_INT, GL_NUM_BUFFER_TARGETS
}
enum | { GL_BUFFER = 0x00000001, GL_DL = 0x00000002, GL_TEX = 0x00000004 }

Functions

GLContext * glContext ()
Get the GLContext of the current thread.

bool | equalf (GLfloat a, GLfloat b)
Fast float compare helper.

bool | equal3f (GLfloat a1, GLfloat a2, GLfloat a3, const GLfloat *b)
Fast float compare helper.

bool | equal3fv (const GLfloat *a, const GLfloat *b)
Fast float compare helper.

bool | equal4f (GLfloat a1, GLfloat a2, GLfloat a3, GLfloat a4, const GLfloat *b)
Fast float compare helper.

bool | equal4fv (const GLfloat *a, const GLfloat *b)
Fast float compare helper.

void | GLAccum (GLenum op, GLfloat value)
Replacement of glAccum.

void | GLActiveStencilFace (GLenum face)
Replacement of glActiveStencilFaceEXT.

void | GLActiveTexture (GLenum texture)
Replacement of glActiveTexture.

void | GLActiveVarying (GLuint program, const GLchar *name)
Replacement of glActiveVaryingNV.

void | GLAddSwapHintRect (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glSwapHintRectWin.

void | GLAlphaFunc (GLenum func, GLclampf ref)
Replacement of glAlphaFunc.

void | GLResetAlphaFunc ()
Helper function to reset alpha function and alpha reference value.

GLboolean | GLAreProgramsResident (GLsizei n, const GLuint *programs, GLboolean *residences)
Replacement of glAreProgramsResidentNV.

GLboolean | GLAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences)
Replacement of glAreTexturesResident.

void | GLArrayElement (GLint i)
Replacement of glArrayElement.

void | GLAttachObject (GLhandleARB containerObj, GLhandleARB attachedObj)
Replacement of glAttachObjectARB.

void | GLAttachShader (GLuint program, GLuint shader)
Replacement of glAttachShader.

void | GLBegin (GLenum mode)
Replacement of glBegin.

void | GLBeginOcclusionQuery (GLuint id)
Replacement of glBeginOcclusionQueryNV.

void | GLBeginQuery (GLenum target, GLuint id)
Replacement of glBeginQuery.

void | GLBeginTransformFeedback (GLenum primitiveMode)
Replacement of glBeginTransformFeedbackNV.

void | GLBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
Replacement of glBlendColor.

void | GLBindArraySet (GLuint buffer)
Replacement of glBindArraySetARB.

void | GLBindAttribLocation (GLuint program, GLuint index, const GLchar *name)
Replacement of glBindAttribLocation.

void | GLBindBuffer (GLenum target, GLuint id)
Replacement of glBindBuffer.

void | GLBindBufferBase (GLenum target, GLuint index, GLuint buffer)
Replacement of glBindBufferBaseNV.

void | GLBindBufferOffset (GLenum target, GLuint index, GLuint buffer, GLintptr offset)
Replacement of glBindBufferOffsetNV.

void | GLBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
Replacement of glBindBufferRangeNV.

void | GLBufferData (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage)
Replacement of glBufferData.

void | GLBufferSubData (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data)
Replacement of glBufferSubData.

void | GLDeleteArraySets (GLsizei n, const GLuint *buffers)
Replacement of glDeleteArraySetsARB.

void | GLDeleteBuffers (GLsizei n, const GLuint *buffers)
Replacement of glDeleteBuffers.

void | GLDeleteFences (GLsizei n, const GLuint *fences)
Replacement of glDeleteFencesNV.

void | GLGenArraySets (GLsizei n, GLuint *buffers)
Replacement of glGenArraySetsARB.

void | GLGenBuffers (GLsizei n, GLuint *buffers)
Replacement of glGenBuffers.

void | GLGenFences (GLsizei n, GLuint *fences)
Replacement of glGenFencesNV.

GLvoid * | GLMapBuffer (GLenum target, GLenum access)
Replacement of glMapBuffer.

void | GLUnlockArrays ()
Replacement of glUnlockArrays.

void | GLUniform1f (GLint location, GLfloat v0)
Replacement of glUniform1f.

void | GLUniform1fv (GLint location, GLsizei count, const GLfloat *value)
Replacement of glUniform1fv.

void | GLUniform1i (GLint location, GLint v0)
Replacement of glUniform1i.

void | GLUniform1iv (GLint location, GLsizei count, const GLint *value)
Replacement of glUniform1iv.

void | GLUniform1ui (GLint location, GLuint v0)
Replacement of glUniform1uiEXT.

void | GLUniform1uiv (GLint location, GLsizei count, const GLuint *value)
Replacement of glUniform1uivEXT.

void | GLUniform2f (GLint location, GLfloat v0, GLfloat v1)
Replacement of glUniform2f.

void | GLUniform2fv (GLint location, GLsizei count, const GLfloat *value)
Replacement of glUniform2fv.

void | GLUniform2i (GLint location, GLint v0, GLint v1)
Replacement of glUniform2i.

void | GLUniform2iv (GLint location, GLsizei count, const GLint *value)
Replacement of glUniform2iv.

void | GLUniform2ui (GLint location, GLuint v0, GLuint v1)
Replacement of glUniform2ui.

void | GLUniform2uiv (GLint location, GLsizei count, const GLuint *value)
Replacement of glUniform2uiv.

void | GLUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
Replacement of glUniform3f.

void | GLUniform3fv (GLint location, GLsizei count, const GLfloat *value)
Replacement of glUniform3fv.

void | GLUniform3i (GLint location, GLint v0, GLint v1, GLint v2)
Replacement of glUniform3i.

void | GLUniform3iv (GLint location, GLsizei count, const GLint *value)
Replacement of glUniform3iv.

void | GLUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2)
Replacement of glUniform3ui.

void | GLUniform3uiv (GLint location, GLsizei count, const GLuint *value)
Replacement of glUniform3uiv.

void | GLUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
Replacement of glUniform4f.

void | GLUniform4fv (GLint location, GLsizei count, const GLfloat *value)
Replacement of glUniform4fv.

void | GLUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
Replacement of glUniform4i.

void | GLUniform4iv (GLint location, GLsizei count, const GLint *value)
Replacement of glUniform4iv.

void | GLUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
Replacement of glUniform4ui.

void | GLUniform4uiv (GLint location, GLsizei count, const GLuint *value)
Replacement of glUniform4uiv.

void | GLUniformBuffer (GLuint program, GLint location, GLuint buffer)
Replacement of glUniformBufferEXT.

void | GLUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix2fv.

void | GLUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix2x3fv.

void | GLUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix2x4fv.

void | GLUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix3fv.

void | GLUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix3x2fv.

void | GLUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix3x4fv.

void | GLUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix4fv.

void | GLUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix4x2fv.

void | GLUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Replacement of glUniformMatrix4x3fv.

GLboolean | GLUnmapBuffer (GLenum target)
Replacement of glUnmapBuffer.

void | GLUseProgram (GLuint program)
Replacement of glUseProgram.

void | GLUseProgramObject (GLhandleARB programObj)
Replacement of glUseProgramObjectARB.

void | GLValidateProgram (GLuint program)
Replacement of glValidateProgram.

GLboolean | GLIsArraySet (GLuint name)
Replacement of glIsArraySetARB.

GLboolean | GLIsBuffer (GLuint name)
Replacement of glIsBuffer.

void | GLBindFragDataLocation (GLuint program, GLuint color, const GLchar *name)
Replacement of glBindFragDataLocationEXT.

void | GLBindProgram (GLenum target, GLuint id)
Replacement of glBindProgramNV.

void | GLBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
Replacement of glBitmap.

void | GLBlendEquation (GLenum mode)
Replacement of glBlendEquation.

void | GLBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
Replacement of glBlendEquationSeparate.

void | GLBlendFunc (GLenum sfactor, GLenum dfactor)
Replacement of glBlendFunc.

void | GLResetBlendFunc ()
Helper function to reset the blend function.

void | GLBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
Replacement of glBlendFunc.

void | GLResetBlendFuncSeparate ()
Helper function to reset the blend function, using the GL_EXT_blend_func_separate extention.

void | GLBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
Replacement of glBlitFramebufferEXT.

void | GLBindTexture (GLenum target, GLuint texture)
Replacement of glBindTexture.

void | GLCallList (GLuint list)
Replacement of glCallList.

void | GLCallLists (GLsizei n, GLenum type, const GLvoid *lists)
Replacement of glCallLists.

void | GLClampColor (GLenum target, GLenum clamp)
Replacement of glClampColorARB.

void | GLClear (GLbitfield mask)
Replacement of glClear.

void | GLClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Replacement of glClearAccum.

void | GLClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
Replacement of glClearColor.

void | GLClearColorIi (GLint red, GLint green, GLint blue, GLint alpha)
Replacement of glClearColorIiEXT.

void | GLClearColorIui (GLuint red, GLuint green, GLuint blue, GLuint alpha)
Replacement of glClearColorIuiEXT.

void | GLResetClearColor ()
Helper function to reset the clear color.

void | GLClearDepth (GLclampd depth)
Replacement of glClearDepth.

void | GLClearDepthd (GLdouble depth)
Replacement of glClearDepthd.

void | GLResetClearDepth ()
Helper function to reset the clear depth.

void | GLClearIndex (GLfloat c)
Replacement of glClearIndex.

void | GLClearStencil (GLint s)
Replacement of glClearStencil.

void | GLResetClearStencil ()
Helper function to reset the stencil clear value.

void | GLClientActiveTexture (GLenum texture)
Replacement of glClientActiveTexture.

void | GLClipPlane (GLenum plane, const GLdouble *equation)
Replacement of glClipPlane.

void | GLResetClipPlaneEquation (GLenum plane)
Helper function to reset a clip plane equation.

void | GLColor3b (GLbyte red, GLbyte green, GLbyte blue)
Replacement of glColor3b.

void | GLColor3bv (const GLbyte *v)
Replacement of glColor3bv.

void | GLColor3d (GLdouble red, GLdouble green, GLdouble blue)
Replacement of glColor3d.

void | GLColor3dv (const GLdouble *v)
Replacement of glColor3dv.

void | GLColor3f (GLfloat red, GLfloat green, GLfloat blue)
Replacement of glColor3f.

void | GLColor3fv (const GLfloat *v)
Replacement of glColor3fv.

void | GLColor3h (GLhalf red, GLhalf green, GLhalf blue)
Replacement of glColor3hNV.

void | GLColor3hv (const GLhalf *v)
Replacement of glColor3hv.

void | GLColor3i (GLint red, GLint green, GLint blue)
Replacement of glColor3i.

void | GLColor3iv (const GLint *v)
Replacement of glColor3iv.

void | GLColor3s (GLshort red, GLshort green, GLshort blue)
Replacement of glColor3s.

void | GLColor3sv (const GLshort *v)
Replacement of glColor3sv.

void | GLColor3ub (GLubyte red, GLubyte green, GLubyte blue)
Replacement of glColor3ub.

void | GLColor3ubv (const GLubyte *v)
Replacement of glColor3ubv.

void | GLColor3ui (GLuint red, GLuint green, GLuint blue)
Replacement of glColor3ui.

void | GLColor3uiv (const GLuint *v)
Replacement of glColor3uiv.

void | GLColor3us (GLushort red, GLushort green, GLushort blue)
Replacement of glColor3us.

void | GLColor3usv (const GLushort *v)
Replacement of glColor3usv.

void | GLColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
Replacement of glColor4b.

void | GLColor4bv (const GLbyte *v)
Replacement of glColor4bv.

void | GLColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
Replacement of glColor4d.

void | GLColor4dv (const GLdouble *v)
Replacement of glColor4dv.

void | GLColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Replacement of glColor4f.

void | GLColor4fv (const GLfloat *v)
Replacement of glColor4fv.

void | GLColor4h (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha)
Replacement of glColor4hNV.

void | GLColor4hv (const GLhalf *v)
Replacement of glColor4hv.

void | GLColor4i (GLint red, GLint green, GLint blue, GLint alpha)
Replacement of glColor4i.

void | GLColor4iv (const GLint *v)
Replacement of glColor4iv.

void | GLColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha)
Replacement of glColor4s.

void | GLColor4sv (const GLshort *v)
Replacement of glColor4sv.

void | GLColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
Replacement of glColor4ub.

void | GLColor4ubv (const GLubyte *v)
Replacement of glColor4ubv.

void | GLColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha)
Replacement of glColor4ui.

void | GLColor4uiv (const GLuint *v)
Replacement of glColor4uiv.

void | GLColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha)
Replacement of glColor4us.

void | GLColor4usv (const GLushort *v)
Replacement of glColor4usv.

void | GLColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
Replacement of glColorMask.

void | GLColorMaskIndexed (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
Replacement of glColorMaskIndexedEXT.

void | GLResetColorMask ()
Helper function to reset the color mask.

void | GLColorMaterial (GLenum face, GLenum mode)
Replacement of glColorMaterial.

void | GLResetColorMaterialMode ()
Helper function to reset the color material mode.

void | GLColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glColorPointer.

void | GLColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
Replacement of glColorSubTable.

void | GLColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
Replacement of glColorTable.

void | GLColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params)
Replacement of glColorTableParameterfv.

void | GLColorTableParameteriv (GLenum target, GLenum pname, const GLint *params)
Replacement of glColorTableParameteriv.

void | GLCombinerInput (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
Replacement of glCombinerInput.

void | GLCombinerOutput (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)
Replacement of glCombinerOutput.

void | GLCombinerParameterf (GLenum pname, GLfloat param)
Replacement of glCombinerParameterf.

void | GLCombinerParameterfv (GLenum pname, const GLfloat *params)
Replacement of glCombinerParameterfv.

void | GLCombinerParameteri (GLenum pname, GLint param)
Replacement of glCombinerParameteri.

void | GLCombinerParameteriv (GLenum pname, const GLint *params)
Replacement of glCombinerParameteriv.

void | GLCombinerStageParameterfv (GLenum stage, GLenum pname, const GLfloat *params)
Replacement of glCombinerStageParameterfv.

void | GLCompileShader (GLuint shader)
Replacement of glCompileShader.

void | GLCompressedTexImage1D (GLenum target, int level, GLenum internalformat, GLsizei width, int border, GLsizei imageSize, const void *data)
Replacement of glCompressedTexImage1D.

void | GLCompressedTexImage2D (GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, int border, GLsizei imageSize, const void *data)
Replacement of glCompressedTexImage2D.

void | GLCompressedTexImage3D (GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLsizei imageSize, const void *data)
Replacement of glCompressedTexImage3D.

void | GLCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
Replacement of glCompressedTexSubImage1D.

void | GLCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
Replacement of glCompressedTexSubImage2D.

void | GLCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
Replacement of glCompressedTexSubImage3D.

void | GLConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
Replacement of glConvolutionFilter1D.

void | GLConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
Replacement of glConvolutionFilter2D.

void | GLConvolutionParameterf (GLenum target, GLenum pname, GLfloat params)
Replacement of glConvolutionParameterf.

void | GLConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params)
Replacement of glConvolutionParameterfv.

void | GLConvolutionParameteri (GLenum target, GLenum pname, GLint params)
Replacement of glConvolutionParameteri.

void | GLConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params)
Replacement of glConvolutionParameteriv.

void | GLCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
Replacement of glCopyColorSubTable.

void | GLCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
Replacement of glCopyColorTable.

void | GLCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
Replacement of glCopyConvolutionFilter1D.

void | GLCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glCopyConvolutionFilter2D.

void | GLCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
Replacement of glCopyPixels.

void | GLCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
Replacement of glCopyTexImage1D.

void | GLCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
Replacement of glCopyTexImage2D.

void | GLCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
Replacement of glCopyTexSubImage1D.

void | GLCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glCopyTexSubImage2D.

void | GLCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glCopyTexSubImage2D.

GLuint | GLCreateProgram ()
Replacement of glCreateProgram.

GLhandleARB | GLCreateProgramObject ()
Replacement of glCreateProgramObjectARB.

GLuint | GLCreateShader (GLenum type)
Replacement of glCreateShader.

GLhandleARB | GLCreateShaderObject (GLenum shaderType)
Replacement of glCreateShaderObjectARB.

void | GLCullFace (GLenum mode)
Replacement of glCullFace.

void | GLResetCullFaceMode ()
Helper function to reset the cull face mode.

void | GLCullFaceLock (GLenum mode)
Helper function to set the cull face mode and lock it.

void | GLCullFaceUnlock (GLenum mode)
Helper function to unlock the cull face and set it.

void | GLDeleteLists (GLuint list, GLsizei range)
Replacement of glDeleteLists.

void | GLDeleteObject (GLhandleARB obj)
Replacement of glDeleteObjectARB.

void | GLDeleteOcclusionQueries (GLsizei n, const GLuint *ids)
Replacement of glDeleteOcclusionQueriesNV.

void | GLDeleteProgram (GLuint program)
Replacement of glDeleteProgram.

void | GLDeletePrograms (GLsizei n, const GLuint *ids)
Replacement of glDeleteProgramsNV.

void | GLDeleteQueries (GLsizei n, const GLuint *ids)
Replacement of glDeleteQueries.

void | GLDeleteShader (GLuint shader)
Replacement of glDeleteShader.

void | GLDeleteTextures (GLsizei n, const GLuint *textures)
Replacement of glDeleteTextures.

void | GLDepthBounds (GLclampd zmin, GLclampd zmax)
Replacement of glDepthBounds.

void | GLDepthBoundsd (GLdouble zmin, GLdouble zmax)
Replacement of glDepthBoundsd.

void | GLDepthFunc (GLenum func)
Replacement of glDepthFunc.

void | GLResetDepthFunc ()
Helper function to reset the depth func.

void | GLDepthMask (GLboolean flag)
Replacement of glDepthMask.

void | GLResetDepthMask ()
Helper function to reset the depth mask.

void | GLDepthRange (GLclampd znear, GLclampd zfar)
Replacement of glDepthRange.

void | GLDepthRanged (GLdouble zNear, GLdouble zFar)
Replacement of glDepthRandedNV.

void | GLResetDepthRange ()
Helper function to reset the depth range.

void | GLDetachObject (GLhandleARB containerObj, GLhandleARB attachedObj)
Replacement of glDetachObjectARB.

void | GLDetachShader (GLuint program, GLuint shader)
Replacement of glDetachShader.

void | GLDisableAlphaTest (void)
Cached version of GLDisable( GL_ALPHA_TEST ).

void | GLDisableAutoNormal (void)
Cached version of GLDisable( GL_AUTO_NORMAL ).

void | GLDisableBlend (void)
Cached version of GLDisable( GL_BLEND ).

void | GLDisableClipPlane (GLenum plane)
Cached version of GLDisable( GL_CLIP_PLANEi ).

void | GLDisableColorLogicOp (void)
Cached version of GLDisable( GL_COLOR_LOGIC_OP ).

void | GLDisableColorMaterial (void)
Cached version of GLDisable( GL_COLOR_MATERIAL ).

void | GLDisableCullFace (void)
Cached version of GLDisable( GL_CULL_FACE ).

void | GLDisableCullFaceLock (void)
Helper function to disable the cull face and lock it.

void | GLDisableCullFaceUnlock (void)
Helper function to unlock the cull face and set it.

void | GLDisableDepthTest (void)
Cached version of GLDisable( GL_DEPTH_TEST ).

void | GLDisableDither (void)
Cached version of GLDisable( GL_DITHER ).

void | GLDisableFog (void)
Cached version of GLDisable( GL_FOG ).

void | GLDisableIndexed (GLenum target, GLuint index)
Replacement of glDiableIndexed.

void | GLDisableLight (GLenum light)
Cached version of GLDisable( GL_LIGHTi ).

void | GLDisableLighting (void)
Cached version of GLDisable( GL_LIGHTING ).

void | GLDisableLightingLock (void)
Helper function to disable lighting and lock it.

void | GLDisableLightingUnlock (void)
Helper function to unlock the lighting and disable it.

void | GLDisableLineSmooth (void)
Cached version of GLDisable( GL_LINE_SMOOTH ).

void | GLDisableLineStipple (void)
Cached version of GLDisable( GL_LINE_STIPPLE ).

void | GLDisableLogicOp (void)
Cached version of GLDisable( GL_LOGIC_OP ).

void | GLDisableNormalize (void)
Cached version of GLDisable( GL_NORMALIZE ).

void | GLDisablePointSmooth (void)
Cached version of GLDisable( GL_POINT_SMOOTH ).

void | GLDisablePolygonOffsetFill (void)
Cached version of GLDisable( GL_POLYGON_OFFSET_FILL ).

void | GLDisablePolygonOffsetLine (void)
Cached version of GLDisable( GL_POLYGON_OFFSET_LINE ).

void | GLDisablePolygonOffsetPoint (void)
Cached version of GLDisable( GL_POLYGON_OFFSET_POINT ).

void | GLDisablePolygonSmooth (void)
Cached version of GLDisable( GL_POLYGON_SMOOTH ).

void | GLDisablePolygonStipple (void)
Cached version of GLDisable( GL_POLYGON_STIPPLE ).

void | GLDisableScissorTest (void)
Cached version of GLDisable( GL_SCISSOR_TEST ).

void | GLDisableStencilTest (void)
Cached version of GLDisable( GL_STENCIL_TEST ).

void | GLDisableTexture (GLenum target)
void | GLDisableTextureGen (GLenum target)
Cached version of GLDisable( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

void | GLDisable (GLenum cap)
Replacement of glDisable.

void | GLDisableColorArray (void)
Cached version of GLDisableClientState( GL_COLOR_ARRAY ).

void | GLDisableFogCoordinateArray (void)
Cached version of GLDisableClientState( GL_FOG_COORDINATE_ARRAY ).

void | GLDisableNormalArray (void)
Cached version of GLDisableClientState( GL_NORMAL_ARRAY ).

void | GLDisableSecondaryColorArray (void)
Cached version of GLDisableClientState( GL_SECONDARY_COLOR_ARRAY ).

void | GLDisableTextureCoordArray (void)
Cached version of GLDisableClientState( GL_TEXTURE_COORD_ARRAY ).

void | GLDisableVertexArray (void)
Cached version of GLDisableClientState( GL_VERTEX_ARRAY ).

void | GLDisableClientState (GLenum array)
Replacement of glDisableClientState.

void | GLDisableVertexAttribArray (GLuint index)
Replacement of glDisableVertexAttribArray.

void | GLDrawArrays (GLenum mode, GLint first, GLsizei count)
Replacement of glDrawArrays.

void | GLDrawArraysInstanced (GLenum mode, GLint start, GLsizei count, GLsizei primcount)
Replacement of glDrawArraysInstancedEXT.

void | GLDrawBuffer (GLenum mode)
Replacement of glDrawBuffer.

void | GLDrawBuffers (GLsizei n, const GLenum *bufs)
Replacement of glDrawBuffersARB.

void | GLDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
Replacement of glDrawElements.

void | GLDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)
Replacement of glDrawElementsInstancedEXT.

void | GLMultiDrawArrays (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
Replacement of glMultiDrawArrays.

void | GLMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount)
Replacement of glMultiDrawElements.

void | GLDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glDrawPixels.

void | GLDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
Replacement of glDrawRangeElements.

void | GLEdgeFlagPointer (GLsizei stride, const GLboolean *pointer)
Replacement of glEdgeFlagPointer.

void | GLEdgeFlag (GLboolean flag)
Replacement of glEdgeFlag.

void | GLEdgeFlagv (const GLboolean *flag)
Replacement of glEdgeFlagv.

void | GLEnableAlphaTest (void)
Cached version of GLEnable( GL_ALPHA_TEST ).

void | GLResetAlphaTest ()
Helper function to reset the enable state of the alpha test.

void | GLEnableAutoNormal (void)
Cached version of GLEnable( GL_AUTO_NORMAL ).

void | GLResetAutoNormal ()
Helper function to reset the enable state of the auto normal calculation.

void | GLEnableBlend (void)
Cached version of GLEnable( GL_BLEND ).

void | GLResetBlend ()
Helper function to reset the enable state of the blending.

void | GLEnableClipPlane (GLenum plane)
Cached version of GLEnable( GL_CLIP_PLANEi ).

void | GLResetClipPlane (GLenum plane)
Helper function to reset the enable state of the clip plane plane.

void | GLEnableColorLogicOp (void)
Cached version of GLEnable( GL_COLOR_LOGIC_OP ).

void | GLResetColorLogicOp ()
Helper function to reset the enable state of the color logic operation.

void | GLEnableColorMaterial (void)
Cached version of GLEnable( GL_COLOR_MATERIAL ).

void | GLResetColorMaterial ()
Helper function to reset the enable state of the color material.

void | GLEnableCullFace (void)
Cached version of GLEnable( GL_CULL_FACE ).

void | GLResetCullFace ()
Helper function to reset the enable state of face culling.

void | GLEnableCullFaceLock (void)
Helper function to enable face culling and lock it.

void | GLEnableCullFaceUnlock (void)
Helper function to unlock the face culling and enable it.

void | GLEnableDepthTest (void)
Cached version of GLEnable( GL_DEPTH_TEST ).

void | GLResetDepthTest ()
Helper function to reset the enable state of depth testing.

void | GLEnableDither (void)
Cached version of GLEnable( GL_DITHER ).

void | GLResetDither ()
Helper function to reset the enable state of dithering.

void | GLEnableFog (void)
Cached version of GLEnable( GL_FOG ).

void | GLResetFog ()
Helper function to reset the the enable state of fogging.

void | GLEnableIndexed (GLenum target, GLuint index)
Replacement of glEnabledIndexed.

void | GLEnableLight (GLenum light)
Cached version of GLEnable( GL_LIGHTi ).

void | GLResetLight (GLenum light)
Helper function to reset the enable state of the light light.

void | GLEnableLighting (void)
Cached version of GLEnable( GL_LIGHTING ).

void | GLResetLighting ()
Helper function to reset the enable state of lighting.

void | GLEnableLineSmooth (void)
Cached version of GLEnable( GL_LINE_SMOOTH ).

void | GLResetLineSmooth ()
Helper function to reset the enable state of line smoothing.

void | GLEnableLineStipple (void)
Cached version of GLEnable( GL_LINE_STIPPLE ).

void | GLResetLineStipple ()
Helper function to reset the enable state of line stippling.

void | GLEnableLogicOp (void)
Cached version of GLEnable( GL_LOGIC_OP ).

void | GLResetLogicOp ()
Helper function to reset the enable state of logic operation.

void | GLEnableNormalize (void)
Cached version of GLEnable( GL_NORMALIZE ).

void | GLResetNormalize ()
Helper function to reset the enable state of normalizing.

void | GLEnablePointSmooth (void)
Cached version of GLEnable( GL_POINT_SMOOTH ).

void | GLResetPointSmooth ()
Helper function to reset the enable state of point smoothing.

void | GLEnablePolygonOffsetFill (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_FILL ).

void | GLResetPolygonOffsetFill ()
Helper function to reset the enable state of filled polygon offset.

void | GLEnablePolygonOffsetLine (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_LINE ).

void | GLResetPolygonOffsetLine ()
Helper function to reset the enable state of lined polygon offset.

void | GLEnablePolygonOffsetPoint (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_POINT ).

void | GLResetPolygonOffsetPoint ()
Helper function to reset the enable state of pointed polygon offset.

void | GLEnablePolygonSmooth (void)
Cached version of GLEnable( GL_POLYGON_SMOOTH ).

void | GLResetPolygonSmooth ()
Helper function to reset the enable state of polygon smoothing.

void | GLEnablePolygonStipple (void)
Cached version of GLEnable( GL_POLYGON_STIPPLE ).

void | GLResetPolygonStipple ()
Helper function to reset the enable state of polygon stippling.

void | GLEnableScissorTest (void)
Cached version of GLEnable( GL_SCISSOR_TEST ).

void | GLResetScissorTest ()
Helper function to reset the enable state of scissor testing.

void | GLEnableStencilTest (void)
Cached version of GLEnable( GL_STENCIL_TEST ).

void | GLResetStencilTest ()
Helper function to reset the enable state of stencil testing.

void | GLEnableTexture (GLenum target)
void | GLResetTexture (GLenum target)
Helper function to reset the enable state of texture target target.

void | GLEnableTextureGen (GLenum target)
Cached version of GLEnable( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

void | GLEnable (GLenum cap)
Replacement of glEnable.

void | GLEnableColorArray (void)
Cached version of GLEnableClientState( GL_COLOR_ARRAY ).

void | GLEnableFogCoordinateArray (void)
Cached version of GLEnableClientState( GL_FOG_COORDINATE_ARRAY ).

void | GLEnableNormalArray (void)
Cached version of GLEnableClientState( GL_NORMAL_ARRAY ).

void | GLEnableSecondaryColorArray (void)
Cached version of GLEnableClientState( GL_SECONDARY_COLOR_ARRAY ).

void | GLEnableTextureCoordArray (void)
Cached version of GLEnableClientState( GL_TEXTURE_COORD_ARRAY ).

void | GLEnableVertexArray (void)
Cached version of GLEnableClientState( GL_VERTEX_ARRAY ).

void | GLEnableClientState (GLenum array)
Replacement of glEnableClientState.

void | GLEnableVertexAttribArray (GLuint index)
Replacement of glEnableVertexAttribArray.

void | GLEnd (void)
Replacement of glEnd.

void | GLEndList (void)
Replacement of glEndList.

void | GLEndOcclusionQuery (void)
Replacement of glEndOcclusionQueryNV.

void | GLEndQuery (GLenum target)
Replacement of glEndQuery.

void | GLEndTransformFeedback ()
Replacement of glEndTransformFeedbackNV.

void | GLEvalCoord1d (GLdouble u)
Replacement of glEvalCoord1d.

void | GLEvalCoord1f (GLfloat u)
Replacement of glEvalCoord1f.

void | GLEvalCoord2d (GLdouble u, GLdouble v)
Replacement of glEvalCoord2d.

void | GLEvalCoord2f (GLfloat u, GLfloat v)
Replacement of glEvalCoord2f.

void | GLEvalMesh1 (GLenum mode, GLint i1, GLint i2)
Replacement of glEvalMesh1.

void | GLEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
Replacement of glEvalMesh2.

void | GLEvalPoint1 (GLint i)
Replacement of glEvalPoint1.

void | GLEvalPoint2 (GLint i, GLint j)
Replacement of glEvalPoint2.

void | GLExecuteProgram (GLenum target, GLuint id, const GLfloat *params)
Replacement of glExecuteProgramNV.

void | GLFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer)
Replacement of glFeedbackBuffer.

void | GLFinalCombinerInput (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
Replacement of glFinalCombinerInput.

void | GLFinish (void)
Replacement of glFinish.

void | GLFinishFence (GLuint fence)
Replacement of glFinishFenceNV.

void | GLFlush (void)
Replacement of glFlush.

void | GLFlushPixelDataRange (GLenum target)
Replacement of glFlushPixelDataRangeNV.

void | GLFlushVertexArrayRange ()
Replacement of glFlushVertexArrayRange.

void | GLFogColor (const GLfloat *color)
Cached version of GLFog[fv|iv]( GL_FOG_COLOR, params ).

void | GLResetFogColor ()
Helper function to reset the fog color.

void | GLFogCoordd (GLdouble fog)
Replacement of glFogCoordd.

void | GLFogCoorddv (const GLdouble *fog)
Replacement of glFogCoorddv.

void | GLFogCoordf (GLfloat fog)
Replacement of glFogCoordf.

void | GLFogCoordfv (const GLfloat *fog)
Replacement of glFogCoordfv.

void | GLFogCoordh (GLhalf fog)
Replacement of glFogCoordh.

void | GLFogCoordhv (const GLhalf *fog)
Replacement of glFogCoordhv.

void | GLFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glFogCoordPointer.

void | GLFogDensity (GLfloat density)
Cached version of GLFog[f|fv|i|iv]( GL_FOG_DENSITY, param[s] ).

void | GLResetFogDensity ()
Helper function to reset the fog density.

void | GLFogEnd (GLfloat end)
Cached version of GLFog[f|fv|i|iv]( GL_FOG_END, param[s] ).

void | GLResetFogEnd ()
Helper function to reset the fog end value.

void | GLFogf (GLenum pname, GLfloat param)
Replacement of glFogf.

void | GLFogfv (GLenum pname, const GLfloat *params)
Replacement of glFogfv.

void | GLFogi (GLenum pname, GLint param)
Replacement of glFogi.

void | GLFogiv (GLenum pname, const GLint *params)
Replacement of glFogiv.

void | GLFogMode (GLenum mode)
Cached version of GLFog[f|fv|i|iv]( GL_FOG_MODE, param[s] ).

void | GLResetFogMode ()
Helper function to reset the fog mode.

void | GLFogStart (GLfloat start)
Cached version of GLFog[f|fv|i|iv]( GL_FOG_START, param[s] ).

void | GLResetFogStart ()
Helper function to reset the fog start value.

void | GLFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level)
Replacement of glFramebufferTextureEXT.

void | GLFramebufferTextureFace (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)
Replacement of glFramebufferTextureFaceEXT.

void | GLFrontFace (GLenum mode)
Replacement of glFrontFace.

void | GLResetFrontFace ()
Helper function to reset the front face state.

void | GLFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
Replacement of glFrustum.

GLuint | GLGenLists (GLsizei range)
Replacement of glGenLists.

void | GLGenOcclusionQueries (GLsizei n, GLuint *ids)
Replacement of glGenOcclusionQueriesNV.

void | GLGenPrograms (GLsizei n, GLuint *ids)
Replacement of glGenProgramsNV.

void | GLGenQueries (GLsizei n, GLuint *ids)
Replacement of glGenQueries.

void | GLGenTextures (GLsizei n, GLuint *textures)
Replacement of glGenTextures.

void | GLGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
Replacement of glGetActiveAttrib.

void | GLGetActiveUniform (GLuint program, GLuint index, GLsizei maxLength, GLsizei *length, GLsizei *size, GLenum *type, GLcharARB *name)
Replacement of glGetActiveUniform.

void | GLGetActiveVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
Replacement of glGetActiveVaryingNV.

void | GLGetAttachedObjects (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj)
Replacement of glGetAttachedObjectsARB.

void | GLGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
Replacement of glGetAttachedShaders.

GLint | GLGetAttribLocation (GLuint program, const GLchar *name)
Replacement of glGetAttribLocation.

void | GLGetBooleanv (GLenum pname, GLboolean *params)
Replacement of glGetBooleanv.

void | GLGetBooleanIndexedv (GLenum target, GLuint index, GLboolean *data)
Replacement of glGetBooleanIndexedvEXT.

void | GLGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table)
Replacement of glGetColorTable.

void | GLGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetColorTableParameterfv.

void | GLGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetColorTableParameteriv.

void | GLGetCombinerInputParameterfv (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params)
Replacement of glGetCombinerInputParameterfv.

void | GLGetCombinerInputParameteriv (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params)
Replacement of glGetCombinerInputParameteriv.

void | GLGetCombinerOutputParameterfv (GLenum stage, GLenum portion, GLenum pname, GLfloat *params)
Replacement of glGetCombinerOutputParameterfv.

void | GLGetCombinerOutputParameteriv (GLenum stage, GLenum portion, GLenum pname, GLint *params)
Replacement of glGetCombinerOutputParameteriv.

void | GLGetCombinerStageParameterfv (GLenum stage, GLenum pname, GLfloat *params)
Replacement of glGetCombinerStageParameterfv.

void | GLGetCompressedTexImage (GLenum target, GLint lod, GLvoid *img)
Replacement of glGetCompressedTexImage.

void | GLGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image)
Replacement of glGetConvolutionFilter.

void | GLGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetConvolutionParameterfv.

void | GLGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetConvolutionParameteriv.

void | GLGetDoublev (GLenum pname, GLdouble *params)
Replacement of glGetDoublev.

void | GLGetFenceiv (GLuint fence, GLenum pname, GLint *params)
Replacement of glGetFenceivNV.

void | GLGetFinalCombinerInputParameterfv (GLenum variable, GLenum pname, GLfloat *params)
Replacement of glGetFinalCombinerInputParamterfv.

void | GLGetFinalCombinerInputParameteriv (GLenum variable, GLenum pname, GLint *params)
Replacement of glGetFinalCombinerInputParamteriv.

void | GLGetFloatv (GLenum pname, GLfloat *params)
Replacement of glGetFloatv.

void | GLGetFogColor (GLfloat *fogColor)
GLint | GLGetFragDataLocation (GLuint program, const GLchar *name)
Replacement of glGetFragDataLocationEXT.

GLhandleARB | GLGetHandle (GLenum pname)
Replacement of glGetHandleARB.

void | GLGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
Replacement of glGetHistogram.

void | GLGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetHistogramParameterfv.

void | GLGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetHistogramParameteriv.

void | GLGetInfoLog (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog)
Replacement of glGetInfoLogARB.

void | GLGetIntegerv (GLenum pname, GLint *params)
Replacement of glGetIntegerv.

void | GLGetIntegerIndexedv (GLenum target, GLuint index, GLint *data)
Replacement of glGetIntegerIndexedvEXT.

void | GLGetBufferParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetBufferParameteriv.

void | GLGetBufferPointerv (GLenum target, GLenum pname, GLvoid **params)
Replacement of glGetBufferPointerv.

void | GLGetBufferSubData (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data)
Replacement of glGetBufferSubData.

void | GLGetClipPlane (GLenum plane, GLdouble *equation)
Replacement of glGetClipPlane.

void | GLGetLightfv (GLenum light, GLenum pname, GLfloat *params)
Replacement of glGetLightfv.

void | GLGetLightiv (GLenum light, GLenum pname, GLint *params)
Replacement of glGetLightiv.

void | GLGetMapdv (GLenum target, GLenum query, GLdouble *v)
Replacement of glGetMapdv.

void | GLGetMapfv (GLenum target, GLenum query, GLfloat *v)
Replacement of glGetMapfv.

void | GLGetMapiv (GLenum target, GLenum query, GLint *v)
Replacement of glGetMapiv.

void | GLGetMaterialfv (GLenum face, GLenum pname, GLfloat *params)
Replacement of glGetMaterialfv.

void | GLGetMaterialiv (GLenum face, GLenum pname, GLint *params)
Replacement of glGetMaterialiv.

GLint | GLGetMaxTexCoords (void)
Get the maximal number of texture coordinate slots.

GLint | GLGetMaxTexUnits (void)
Get the maximal number of texture units.

GLint | GLGetMaxTexImageUnits (void)
Get the maximal number of texture image units.

void | GLGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
Replacement of glGetMinmax.

void | GLGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetMinmaxParameterfv.

void | GLGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetMinmaxParameteriv.

void | GLGetObjectParameterfv (GLhandleARB obj, GLenum pname, GLfloat *params)
Replacement of glGetObjectParameterfvARB.

void | GLGetObjectParameteriv (GLhandleARB obj, GLenum pname, GLint *params)
Replacement of glGetObjectParameterivARB.

void | GLGetOcclusionQueryiv (GLuint id, GLenum pname, GLint *params)
Replacement of glGetOcclusionQueryivNV.

void | GLGetOcclusionQueryuiv (GLuint id, GLenum pname, GLuint *params)
Replacement of glGetOcclusionQueryuivNV.

void | GLGetPixelMapfv (GLenum map, GLfloat *values)
Replacement of glGetPixelMapfv.

void | GLGetPixelMapuiv (GLenum map, GLuint *values)
Replacement of glGetPixelMapuiv.

void | GLGetPixelMapusv (GLenum map, GLushort *values)
Replacement of glGetPixelMapusv.

void | GLGetPointerv (GLenum pname, GLvoid **params)
Replacement of glGetPointerv.

void | GLGetPolygonStipple (GLubyte *mask)
Replacement of glGetPolygonStipple.

void | GLGetProgramEnvParameterdv (GLenum target, GLuint index, GLdouble *params)
Replacement of glGetProgramEnvParameterdvARB.

void | GLGetProgramEnvParameterfv (GLenum target, GLuint index, GLfloat *params)
Replacement of glGetProgramEnvParameterfvARB.

void | GLGetProgramiv (GLuint program, GLenum pname, GLint *params)
Replacement of glGetProgramiv.

void | GLGetProgramLocalParameterdv (GLenum target, GLuint index, GLdouble *params)
Replacement of glGetProgramLocalParameterdvARB.

void | GLGetProgramLocalParameterfv (GLenum target, GLuint index, GLfloat *params)
Replacement of glGetProgramLocalParameterfvARB.

void | GLGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
Replacement of glGetProgramInfoLog.

void | GLGetProgramEnvParameterIiv (GLenum target, GLuint index, GLint *params)
Replacement of glGetProgramEnvParameterIivNV.

void | GLGetProgramEnvParameterIuiv (GLenum target, GLuint index, GLuint *params)
Replacement of glGetProgramEnvParameterIuivNV.

void | GLGetProgramLocalParameterIiv (GLenum target, GLuint index, GLint *params)
Replacement of glGetProgramLocalParameterIivNV.

void | GLGetProgramLocalParameterIuiv (GLenum target, GLuint index, GLuint *params)
Replacement of glGetProgramLocalParameterIuivNV.

void | GLGetProgramNamedParameterdv (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params)
Replacement of glGetProgramNamedParameterdvNV.

void | GLGetProgramNamedParameterfv (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params)
Replacement of glGetProgramNamedParameterfvNV.

void | GLGetProgramParameterdv (GLenum target, GLuint index, GLenum pname, GLdouble *params)
Replacement of glGetProgramParameterdvNV.

void | GLGetProgramParameterfv (GLenum target, GLuint index, GLenum pname, GLfloat *params)
Replacement of glGetProgramParameterfvNV.

void | GLGetProgramString (GLuint id, GLenum pname, GLubyte *program)
Replacement of glGetProgramStringNV.

void | GLGetQueryiv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetQueryiv.

void | GLGetQueryObjecti64v (GLuint id, GLenum pname, GLint64EXT *params)
Replacement of glGetQueryObjecti64vEXT.

void | GLGetQueryObjectiv (GLuint id, GLenum pname, GLint *params)
Replacement of glGetQueryObjectiv.

void | GLGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64EXT *params)
Replacement of glGetQueryObjectui64vEXT.

void | GLGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params)
Replacement of glGetQueryObjectuiv.

void | GLGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
Replacement of glGetSeparableFilter.

void | GLGetShaderiv (GLuint shader, GLenum pname, GLint *params)
Replacement of glGetShaderiv.

void | GLGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
Replacement of glGetShaderInfoLog.

void | GLGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLcharARB *source)
Replacement of glGetShaderSource.

const GLubyte * | GLGetString (GLenum name)
Replacement of glGetString.

void | GLGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetTexEnvfv.

void | GLGetTexEnviv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetTexEnviv.

void | GLGetTexGendv (GLenum coord, GLenum pname, GLdouble *params)
Replacement of glGetTexGendv.

void | GLGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params)
Replacement of glGetTexGenfv.

void | GLGetTexGeniv (GLenum coord, GLenum pname, GLint *params)
Replacement of glGetTexGeniv.

void | GLGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
Replacement of glGetTexImage.

void | GLGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params)
Replacement of glGetTexLevelParameterfv.

void | GLGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params)
Replacement of glGetTexLevelParameteriv.

void | GLGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)
Replacement of glGetTexParameterfv.

void | GLGetTexParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetTexParameteriv.

void | GLGetTexParameterIiv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetTexParameterIivEXT.

void | GLGetTexParameterIuiv (GLenum target, GLenum pname, GLuint *params)
Replacement of glGetTexParameterIuivEXT.

void | GLGetTrackMatrixiv (GLenum target, GLuint address, GLenum pname, GLint *params)
Replacement of glGetTrackMatrixivNV.

void | GLGetTransformFeedbackVarying (GLuint program, GLuint index, GLint *location)
Replacement of glGetTransformFeedbackVaryingNV.

void | GLGetUniformfv (GLuint program, GLint location, GLfloat *params)
Replacement of glGetUniformfv.

void | GLGetUniformiv (GLuint program, GLint location, GLint *params)
Replacement of glGetUniformiv.

void | GLGetUniformuiv (GLuint program, GLint location, GLuint *params)
Replacement of glGetUniformuiv.

GLint | GLGetUniformBufferSize (GLuint program, GLint location)
Replacement of glGetUniformBufferSizeEXT.

GLint | GLGetUniformLocation (GLuint program, const GLcharARB *name)
Replacement of glGetUniformLocation.

GLintptr | GLGetUniformOffset (GLuint program, GLint location)
Replacement of glGetUniformOffsetEXT.

GLint | GLGetVaryingLocation (GLuint program, const GLchar *name)
Replacement of glGetVaryingLocationNV.

void | GLGetVertexAttribdv (GLuint index, GLenum pname, GLdouble *params)
Replacement of glGetVertexAttribdv.

void | GLGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params)
Replacement of glGetVertexAttribfv.

void | GLGetVertexAttribiv (GLuint index, GLenum pname, GLint *params)
Replacement of glGetVertexAttribiv.

void | GLGetVertexAttribIiv (GLuint index, GLenum pname, GLint *params)
Replacement of glGetVertexAttribIivEXT.

void | GLGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint *params)
Replacement of glGetVertexAttribIuivEXT.

void | GLGetVertexAttribPointerv (GLuint index, GLenum pname, GLvoid **pointer)
Replacement of glGetVertexAttribPointer.

void | GLHint (GLenum target, GLenum mode)
Replacement of glHint.

void | GLHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
Replacement of glHistogram.

void | GLIndexd (GLdouble c)
Replacement of glIndexd.

void | GLIndexf (GLfloat c)
Replacement of glIndexf.

void | GLIndexi (GLint c)
Replacement of glIndexi.

void | GLIndexMask (GLuint mask)
Replacement of glIndexMask.

void | GLIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glIndexPointer.

void | GLIndexs (GLshort c)
Replacement of glIndexs.

void | GLIndexub (GLubyte c)
Replacement of glIndexub.

void | GLInitNames (void)
Replacement of glInitNames.

void | GLInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer)
Replacement of glInterleavedArrays.

GLboolean | GLIsEnabled (GLenum cap)
Replacement of glIsEnabled.

GLboolean | GLIsEnabledAlphaTest ()
Replacement of glIsEnabled( GL_ALPHA_TEST ).

GLboolean | GLIsEnabledAutoNormal ()
Replacement of glIsEnabled( GL_AUTO_NORMAL ).

GLboolean | GLIsEnabledBlend ()
Replacement of glIsEnabled( GL_BLEND ).

GLboolean | GLIsEnabledClipPlane (GLenum plane)
Replacement of glIsEnabled( GL_CLIP_PLANEi ).

GLboolean | GLIsEnabledColorLogicOp ()
Replacement of glIsEnabled( GL_COLOR_LOGIC_OP ).

GLboolean | GLIsEnabledColorMaterial ()
Replacement of glIsEnabled( GL_COLOR_MATERIAL ).

GLboolean | GLIsEnabledCullFace ()
Replacement of glIsEnabled( GL_CULL_FACE ).

GLboolean | GLIsEnabledDepthTest ()
Replacement of glIsEnabled( GL_DEPTH_TEST ).

GLboolean | GLIsEnabledDither ()
Replacement of glIsEnabled( GL_DITHER ).

GLboolean | GLIsEnabledFog ()
Replacement of glIsEnabled( GL_FOG ).

GLboolean | GLIsEnabledIndexed (GLenum target, GLuint index)
Replacement of glIsEnabledIndexed.

GLboolean | GLIsEnabledLight (GLenum light)
Replacement of glIsEnabled( GL_LIGHTi ).

GLboolean | GLIsEnabledLighting ()
Replacement of glIsEnabled( GL_LIGHTING ).

GLboolean | GLIsEnabledLineSmooth ()
Replacement of glIsEnabled( GL_LINE_SMOOTH ).

GLboolean | GLIsEnabledLineStipple ()
Replacement of glIsEnabled( GL_LINE_STIPPLE ).

GLboolean | GLIsEnabledLogicOp ()
Replacement of glIsEnabled( GL_LOGIC_OP ).

GLboolean | GLIsEnabledNormalize ()
Replacement of glIsEnabled( GL_NORMALIZE ).

GLboolean | GLIsEnabledPointSmooth ()
Replacement of glIsEnabled( GL_POINT_SMOOTH ).

GLboolean | GLIsEnabledPolygonOffsetFill ()
Replacement of glIsEnabled( GL_POLYGON_OFFSET_FILL ).

GLboolean | GLIsEnabledPolygonOffsetLine ()
Replacement of glIsEnabled( GL_POLYGON_OFFSET_LINE ).

GLboolean | GLIsEnabledPolygonOffsetPoint ()
Replacement of glIsEnabled( GL_POLYGON_OFFSET_POINT ).

GLboolean | GLIsEnabledPolygonSmooth ()
Replacement of glIsEnabled( GL_POLYGON_SMOOTH ).

GLboolean | GLIsEnabledPolygonStipple ()
Replacement of glIsEnabled( GL_POLYGON_STIPPLE ).

GLboolean | GLIsEnabledScissorTest ()
Replacement of glIsEnabled( GL_SCISSOR_TEST ).

GLboolean | GLIsEnabledStencilTest ()
Replacement of glIsEnabled( GL_STENCIL_TEST ).

GLboolean | GLIsEnabledTexture (GLenum target)
Replacement of glIsEnabled( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

GLboolean | GLIsEnabledTextureGen (GLenum target)
Replacement of glIsEnabled( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

GLint | GLGetVersion ()
Returns the version of the OpenGL available on the target system.

GLboolean | GLIsExtensionAvailable (const std::string &extension)
Test if a given extension is available on the current context.

GLboolean | GLIsExtensionExported (const std::string &extension)
Test if a given extension is exported on the current context.

GLboolean | GLIsFence (GLuint fence)
Replacement of glIsFenceNV.

GLboolean | GLIsList (GLuint list)
Replacement of glIsList.

GLboolean | GLIsOcclusionQuery (GLuint id)
Replacement of glIsOcclusionQueryNV.

GLboolean | GLIsProgram (GLuint program)
Replacement of glIsProgram.

GLboolean | GLIsQuery (GLuint id)
Replacement of glIsQuery.

GLboolean | GLIsShader (GLuint shader)
Replacement of glIsShader.

GLboolean | GLIsTexture (GLuint texture)
Replacement of glIsTexture.

void | GLLightAmbient (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_AMBIENT, param ).

void | GLResetLightAmbient (GLenum light)
Helper function to reset the ambient light color.

void | GLLightConstantAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_CONSTANT_ATTENUATION, param ).

void | GLResetLightConstantAttenuation (GLenum light)
Helper function to reset the constant attenuation of the light light.

void | GLLightDiffuse (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_DIFFUSE, param ).

void | GLResetLightDiffuse (GLenum light)
Helper function to reset the diffuse color of the light light.

void | GLLightLinearAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_LINEAR_ATTENUATION, param ).

void | GLResetLightLinearAttenuation (GLenum light)
Helper function to reset the linear attenuation of the light light.

void | GLLightPosition (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_POSITION, param ).

void | GLResetLightPosition (GLenum light)
Helper function to reset the position of the light light.

void | GLLightQuadraticAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_QUADRATIC_ATTENUATION, param ).

void | GLResetLightQuadraticAttenuation (GLenum light)
Helper function to reset the quadratic attenuation of the light light.

void | GLLightSpecular (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_SPECULAR, param ).

void | GLResetLightSpecular (GLenum light)
Helper function to reset the specular color of the light light.

void | GLLightSpotCutoff (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_SPOT_CUTOFF, param ).

void | GLResetLightSpotCutoff (GLenum light)
Helper function to reset the spot cutoff of the light light.

void | GLLightSpotDirection (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_SPOT_DIRECTION, param ).

void | GLResetLightSpotDirection (GLenum light)
Helper function to reset the spot cutoff of the light light.

void | GLLightSpotExponent (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_SPOT_EXPONENT, param ).

void | GLResetLightSpotExponent (GLenum light)
Helper function to reset the spot exponent of the light light.

void | GLLightf (GLenum light, GLenum pname, GLfloat param)
Replacement of glLightf.

void | GLLightfv (GLenum light, GLenum pname, const GLfloat *params)
Replacement of glLightfv.

void | GLLighti (GLenum light, GLenum pname, GLint param)
Replacement of glLighti.

void | GLintToGLfloat (const GLint *params, GLfloat *fParams)
Convert GLInt to GLFloat.

void | GLLightiv (GLenum light, GLenum pname, GLint *params)
Replacement of glLightiv.

void | GLLightModelAmbient (const GLfloat *params)
Replacement of glLightModelfv( GL_LIGHT_MODEL_AMBIENT, params ).

void | GLResetLightModelAmbient ()
Helper function to reset the ambient light color.

void | GLLightModelLocalViewer (GLint param)
Replacement of GLLightModelLocalViewer.

void | GLResetLightModelLocalViewer ()
Helper function to reset the local viewer setting.

void | GLLightModelTwoSide (GLint param)
Replacement of GLLightModelTwoSide.

void | GLResetLightModelTwoSide ()
Helper function to reset the two sided lighting state.

void | GLLightModelTwoSideLock (GLint param)
Helper function to set two sided lighting and lock it.

void | GLLightModelTwoSideUnlock (GLint param)
Helper function to unlock the two sided lighting and set it.

void | GLLightModelf (GLenum pname, GLfloat param)
Replacement of glLightModelf.

void | GLLightModelfv (GLenum pname, const GLfloat *params)
Replacement of glLightModelfv.

void | GLLightModeli (GLenum pname, GLint param)
Replacement of glLightModeli.

void | GLLightModeliv (GLenum pname, const GLint *params)
Replacement of glLightModeliv.

void | GLLineStipple (GLint factor, GLushort pattern)
Replacement of glLineStipple.

void | GLResetLineStippleDefinition ()
Helper function to reset line stipple repeat and pattern.

void | GLLineWidth (GLfloat width)
Replacement of glLineWidth.

void | GLResetLineWidth ()
Helper function to reset the line width.

void | GLLinkProgram (GLuint program)
Replacement of glLinkProgram.

void | GLListBase (GLuint base)
Replacement of glListBase.

void | GLLoadIdentity (void)
Replacement of glLoadItentity.

void | GLLoadMatrixd (const GLdouble *m)
Replacement of glLoadMatrixd.

void | GLLoadMatrixf (const GLfloat *m)
Replacement of glLoadMatrixf.

void | GLLoadTransposedMatrixd (const GLdouble *m)
Replacement of glLoadTransposeMatrixd.

void | GLLoadTransposeMatrixf (const GLfloat *m)
Replacement of glLoadTransposMatrixf.

void | GLLoadName (GLuint name)
Replacement of glLoadName.

void | GLLoadProgram (GLenum target, GLuint id, GLsizei len, const GLubyte *program)
Replacement of glLoadProgramNV.

void | GLLockArrays (GLint first, GLsizei count)
Replacement of glLockArrays.

void | GLLogicOp (GLenum opcode)
Replacement of glLogicOp.

void | GLMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
Replacement of glMap1d.

void | GLMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
Replacement of glMap1f.

void | GLMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
Replacement of glMap2d.

void | GLMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
Replacement of glMap2f.

void | GLMapGrid1d (GLint un, GLdouble u1, GLdouble u2)
Replacement of glMapGrid1d.

void | GLMapGrid1f (GLint un, GLfloat u1, GLfloat u2)
Replacement of glMapGrid1f.

void | GLMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
Replacement of glMapGrid2d.

void | GLMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
Replacement of glMapGrid2f.

void | GLMaterialShininessBack (GLfloat param)
Cached version of GLMaterialf( GL_BACK, GL_SHININESS, param ).

void | GLResetMaterialShininessBack ()
Helper function to reset the material back face shininess.

void | GLMaterialShininessFront (GLfloat param)
Cached version of GLMaterialf( GL_FRONT, GL_SHININESS, param ).

void | GLResetMaterialShininessFront ()
Helper function to reset the material front face shininess.

void | GLMaterialShininessFrontAndBack (GLfloat param)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, param ).

void | GLResetMaterialShininessFrontAndBack ()
Helper function to reset the material back and front face shininess.

void | GLMaterialShininess (GLenum face, GLfloat param)
Cached version of GLMaterialf( face, GL_SHININESS, param ).

void | GLMaterialAmbientBack (const GLfloat *params)
Cached version of GLMaterialf( GL_BACK, GL_AMBIENT, param ).

void | GLResetMaterialAmbientBack ()
Helper function to reset the material back face ambient color.

void | GLMaterialAmbientFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_AMBIENT, param ).

void | GLResetMaterialAmbientFront ()
Helper function to reset the material front face ambient color.

void | GLMaterialAmbientFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_AMBIENT, param ).

void | GLResetMaterialAmbientFrontAndBack ()
Helper function to reset the material back and front face ambient color.

void | GLMaterialAmbient (GLenum face, const GLfloat *params)
Cached version of GLMaterialfv( face, GL_AMBIENT, params ).

void | GLMaterialDiffuseBack (const GLfloat *params)
Cached version of GLMaterialf( GL_BACK, GL_DIFFUSE, param ).

void | GLResetMaterialDiffuseBack ()
Helper function to reset the material back face diffuse color.

void | GLMaterialDiffuseFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_DIFFUSE, param ).

void | GLResetMaterialDiffuseFront ()
Helper function to reset the material front face diffuse color.

void | GLMaterialDiffuseFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_DIFFUSE, param ).

void | GLResetMaterialDiffuseFrontAndBack ()
Helper function to reset the material back and front face diffuse color.

void | GLMaterialDiffuse (GLenum face, const GLfloat *params)
Cached version of GLMaterialfv( face, GL_DIFFUSE, params ).

void | GLMaterialEmissionBack (const GLfloat *params)
Cached version of GLMaterialf( GL_BACK, GL_EMISSION, param ).

void | GLResetMaterialEmissionBack ()
Helper function to reset the material back face emission color.

void | GLMaterialEmissionFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_EMISSION, param ).

void | GLResetMaterialEmissionFront ()
Helper function to reset the material front face emission color.

void | GLMaterialEmissionFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_EMISSION, param ).

void | GLResetMaterialEmissionFrontAndBack ()
Helper function to reset the material back and front face emission color.

void | GLMaterialEmission (GLenum face, const GLfloat *params)
Cached version of GLMaterialfv( face, GL_EMISSION, params ).

void | GLMaterialSpecularBack (const GLfloat *params)
Cached version of GLMaterialf( GL_BACK, GL_SPECULAR, param ).

void | GLResetMaterialSpecularBack ()
Helper function to reset the material back face specular color.

void | GLMaterialSpecularFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_SPECULAR, param ).

void | GLResetMaterialSpecularFront ()
Helper function to reset the material front face specular color.

void | GLMaterialSpecularFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SPECULAR, param ).

void | GLResetMaterialSpecularFrontAndBack ()
Helper function to reset the material back and front face specular color.

void | GLMaterialSpecular (GLenum face, const GLfloat *params)
Cached version of GLMaterialfv( face, GL_SPECULAR, params ).

void | GLMaterialf (GLenum face, GLenum pname, GLfloat param)
Replacement of glMaterialf.

void | GLMaterialfv (GLenum face, GLenum pname, const GLfloat *params)
Replacement of glMaterialfv.

void | GLMateriali (GLenum face, GLenum pname, GLint param)
Replacement of glMateriali.

void | GLMaterialiv (GLenum face, GLenum pname, const GLint *params)
Replacement of glMaterialiv.

void | GLMatrixMode (GLenum mode)
Replacement of glMatrixMode.

void | GLMinmax (GLenum target, GLenum internalformat, GLboolean sink)
Replacement of glMinmax.

void | GLMultiTexCoord1d (GLenum target, GLdouble s)
Replacement of glMultiTexCoord1d.

void | GLMultiTexCoord1dv (GLenum target, const GLdouble *v)
Replacement of glMultiTexCoord1dv.

void | GLMultiTexCoord1f (GLenum target, GLfloat s)
Replacement of glMultiTexCoord1f.

void | GLMultiTexCoord1fv (GLenum target, const GLfloat *v)
Replacement of glMultiTexCoord1fv.

void | GLMultiTexCoord1h (GLenum target, GLhalf s)
Replacement of glMultiTexCoord1hNV.

void | GLMultiTexCoord1hv (GLenum target, const GLhalf *v)
Replacement of glMultiTexCoord1hv.

void | GLMultiTexCoord1i (GLenum target, GLint s)
Replacement of glMultiTexCoord1i.

void | GLMultiTexCoord1iv (GLenum target, const GLint *v)
Replacement of glMultiTexCoord1iv.

void | GLMultiTexCoord1s (GLenum target, GLshort s)
Replacement of glMultiTexCoord1s.

void | GLMultiTexCoord1sv (GLenum target, const GLshort *v)
Replacement of glMultiTexCoord1sv.

void | GLMultiTexCoord2d (GLenum target, GLdouble s, GLdouble t)
Replacement of glMultiTexCoord2d.

void | GLMultiTexCoord2dv (GLenum target, const GLdouble *v)
Replacement of glMultiTexCoord2dv.

void | GLMultiTexCoord2f (GLenum target, GLfloat s, GLfloat t)
Replacement of glMultiTexCoord2f.

void | GLMultiTexCoord2fv (GLenum target, const GLfloat *v)
Replacement of glMultiTexCoord2fv.

void | GLMultiTexCoord2h (GLenum target, GLhalf s, GLhalf t)
Replacement of glMultiTexCoord2hNV.

void | GLMultiTexCoord2hv (GLenum target, const GLhalf *v)
Replacement of glMultiTexCoord2hv.

void | GLMultiTexCoord2i (GLenum target, GLint s, GLint t)
Replacement of glMultiTexCoord2i.

void | GLMultiTexCoord2iv (GLenum target, const GLint *v)
Replacement of glMultiTexCoord2iv.

void | GLMultiTexCoord2s (GLenum target, GLshort s, GLshort t)
Replacement of glMultiTexCoord2s.

void | GLMultiTexCoord2sv (GLenum target, const GLshort *v)
Replacement of glMultiTexCoord2sv.

void | GLMultiTexCoord3d (GLenum target, GLdouble s, GLdouble t, GLdouble r)
Replacement of glMultiTexCoord3d.

void | GLMultiTexCoord3dv (GLenum target, const GLdouble *v)
Replacement of glMultiTexCoord3dv.

void | GLMultiTexCoord3f (GLenum target, GLfloat s, GLfloat t, GLfloat r)
Replacement of glMultiTexCoord3f.

void | GLMultiTexCoord3fv (GLenum target, const GLfloat *v)
Replacement of glMultiTexCoord3fv.

void | GLMultiTexCoord3h (GLenum target, GLhalf s, GLhalf t, GLhalf r)
Replacement of glMultiTexCoord3hNV.

void | GLMultiTexCoord3hv (GLenum target, const GLhalf *v)
Replacement of glMultiTexCoord3hv.

void | GLMultiTexCoord3i (GLenum target, GLint s, GLint t, GLint r)
Replacement of glMultiTexCoord3i.

void | GLMultiTexCoord3iv (GLenum target, const GLint *v)
Replacement of glMultiTexCoord3iv.

void | GLMultiTexCoord3s (GLenum target, GLshort s, GLshort t, GLshort r)
Replacement of glMultiTexCoord3s.

void | GLMultiTexCoord3sv (GLenum target, const GLshort *v)
Replacement of glMultiTexCoord3sv.

void | GLMultiTexCoord4d (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
Replacement of glMultiTexCoord4d.

void | GLMultiTexCoord4dv (GLenum target, const GLdouble *v)
Replacement of glMultiTexCoord4dv.

void | GLMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
Replacement of glMultiTexCoord4f.

void | GLMultiTexCoord4fv (GLenum target, const GLfloat *v)
Replacement of glMultiTexCoord4fv.

void | GLMultiTexCoord4h (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q)
Replacement of glMultiTexCoord4hNV.

void | GLMultiTexCoord4hv (GLenum target, const GLhalf *v)
Replacement of glMultiTexCoord4hv.

void | GLMultiTexCoord4i (GLenum target, GLint s, GLint t, GLint r, GLint q)
Replacement of glMultiTexCoord4i.

void | GLMultiTexCoord4iv (GLenum target, const GLint *v)
Replacement of glMultiTexCoord4iv.

void | GLMultiTexCoord4s (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
Replacement of glMultiTexCoord4s.

void | GLMultiTexCoord4sv (GLenum target, const GLshort *v)
Replacement of glMultiTexCoord4sv.

void | GLMultiTexCoordPointer (GLenum target, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glMultiTexCoordPointer.

void | GLMultMatrixd (const GLdouble *m)
Replacement of glMultMatrixd.

void | GLMultMatrixf (const GLfloat *m)
Replacement of glMultMatrixf.

void | GLMultTransposeMatrixd (const GLdouble *m)
Replacement of glMultTransposeMatrixd.

void | GLMultTransposeMatrixf (const GLfloat *m)
Replacement of glMultTransposeMatrixf.

void | GLNewList (GLuint list, GLenum mode)
Replacement of glNewList.

void | GLNormal3b (GLbyte nx, GLbyte ny, GLbyte nz)
Replacement of glNormal3b.

void | GLNormal3bv (const GLbyte *v)
Replacement of glNormal3bv.

void | GLNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)
Replacement of glNormal3d.

void | GLNormal3dv (const GLdouble *v)
Replacement of glNormal3dv.

void | GLNormal3f (GLfloat nx, GLfloat ny, GLfloat nz)
Replacement of glNormal3f.

void | GLNormal3fv (const GLfloat *v)
Replacement of glNormal3fv.

void | GLNormal3h (GLhalf nx, GLhalf ny, GLhalf nz)
Replacement of glNormal3hNV.

void | GLNormal3hv (const GLhalf *v)
Replacement of glNormal3hv.

void | GLNormal3i (GLint nx, GLint ny, GLint nz)
! Replacement of glNormal3i

void | GLNormal3iv (const GLint *v)
Replacement of glNormal3iv.

void | GLNormal3s (GLshort nx, GLshort ny, GLshort nz)
Replacement of glNormal3s.

void | GLNormal3sv (const GLshort *v)
Replacement of glNormal3sv.

void | GLNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glNormalPointer.

void | GLOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
Replacement of glOrtho.

void | GLPassThrough (GLfloat token)
Replacement of glPassThrough.

void | GLPixelDataRange (GLenum target, GLsizei size, const GLvoid *pointer)
Replacement of glPixelDataRangeNV.

void | GLPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values)
Replacement of glPixelMapfv.

void | GLPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values)
Replacement of glPixelMapuiv.

void | GLPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values)
Replacement of glPixelMapusv.

void | GLPixelStoref (GLenum pname, GLfloat param)
Replacement of glPixelStoref.

void | GLPixelStorei (GLenum pname, GLint param)
Replacement of glPixelStorei.

void | GLPixelTransferf (GLenum pname, GLfloat param)
Replacement of glPixelTransferf.

void | GLPixelTransferi (GLenum pname, GLint param)
Replacement of glPixelTransferi.

void | GLPixelZoom (GLfloat xfactor, GLfloat yfactor)
Replacement of glPixelZoom.

void | GLPointParameterf (GLenum pname, GLfloat param)
Replacement of glPointParameterf.

void | GLPointParameterfv (GLenum pname, const GLfloat *params)
Replacement of glPointParameterfv.

void | GLPointParameteri (GLenum pname, GLint param)
Replacement of glPointParameteri.

void | GLPointParameteriv (GLenum pname, const GLint *params)
Replacement of glPointParameteriv.

void | GLPointSize (GLfloat size)
Replacement of glPointSize.

void | GLResetPointSize ()
Helper function to reset the point size.

void | GLPolygonModeBack (GLenum mode)
Cached version of GLPolygonMode( GL_BACK, mode ).

void | GLResetPolygonModeBack ()
Helper function to reset back face polygon mode.

void | GLPolygonModeFront (GLenum mode)
Cached version of GLPolygonMode( GL_FRONT, mode ).

void | GLResetPolygonModeFront ()
Helper function to reset front face polygon mode.

void | GLPolygonModeFrontAndBack (GLenum mode)
Cached version of GLPolygonMode( GL_FRONT_AND_BACK, mode ).

void | GLResetPolygonModeFrontAndBack ()
Helper function to reset back and front face polygon mode.

void | GLPolygonMode (GLenum face, GLenum mode)
Cached version of GLPolygonMode( face, mode ).

void | GLPolygonModeLock (GLenum face, GLenum mode)
Helper function to set the polygon mode and lock it.

void | GLPolygonModeUnlock (GLenum face, GLenum mode)
Helper function to unlock the polygon mode and set it.

void | GLPolygonOffset (GLfloat factor, GLfloat units)
Replacement of glPolygonOffset.

void | GLResetPolygonOffset ()
Helper function to reset the polygon offset.

void | GLPolygonStipple (const GLubyte *mask)
Replacement of glPolygonStipple.

void | GLPopAttrib (void)
Replacement of glPopAttrib.

void | GLPopClientAttrib (void)
Replacement of glPopClientAttrib.

void | GLPopMatrix (void)
Replacement of glPopMatrix.

void | GLPopName (void)
Replacement of glPopName.

void | GLPrimitiveRestart ()
Replacement of glPrimitiveRestart.

void | GLPrimitiveRestartIndex (GLuint index)
Replacement of glPrimitiveRestartIndex.

void | GLPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities)
Replacement of glPrioritizeTextures.

void | GLProgramBufferParametersfv (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params)
Replacement of glProgramBufferParametersfvNV.

void | GLProgramBufferParametersIiv (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params)
Replacement of glProgramBufferParametersIivNV.

void | GLProgramBufferParametersIuiv (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params)
Replacement of glProgramBufferParametersIuivNV.

void | GLProgramEnvParameter4d (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glProgramEnvParameter4dARB.

void | GLProgramEnvParameter4dv (GLenum target, GLuint index, const GLdouble *params)
Replacement of glProgramEnvParameter4dvARB.

void | GLProgramEnvParameter4f (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramEnvParameter4fARB.

void | GLProgramEnvParameter4fv (GLenum target, GLuint index, const GLfloat *params)
Replacement of glProgramEnvParameter4fvARB.

void | GLProgramEnvParametersI4iv (GLenum target, GLuint index, GLsizei count, const GLint *params)
Replacement of glProgramEnvParametersI4ivNV.

void | GLProgramEnvParametersI4uiv (GLenum target, GLuint index, GLsizei count, const GLuint *params)
Replacement of glProgramEnvParametersI4uivNV.

void | GLProgramEnvParameterI4i (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
Replacement of glProgramEnvParameterI4iNV.

void | GLProgramEnvParameterI4iv (GLenum target, GLuint index, const GLint *params)
Replacement of glProgramEnvParameterI4ivNV.

void | GLProgramEnvParameterI4ui (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
Replacement of glProgramEnvParameterI4uiNV.

void | GLProgramEnvParameterI4uiv (GLenum target, GLuint index, const GLuint *params)
Replacement of glProgramEnvParameterI4uivNV.

void | GLProgramEnvParameters4fv (GLenum target, GLuint index, GLsizei count, const GLfloat *params)
Replacement of glProgramEnvParameters4fvEXT.

void | GLProgramLocalParameter4d (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glProgramLocalParameter4dARB.

void | GLProgramLocalParameter4dv (GLenum target, GLuint index, const GLdouble *params)
Replacement of glProgramLocalParameter4dvARB.

void | GLProgramLocalParameter4f (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramLocalParameter4fARB.

void | GLProgramLocalParameter4fv (GLenum target, GLuint index, const GLfloat *params)
Replacement of glProgramLocalParameter4fvARB.

void | GLProgramLocalParametersI4iv (GLenum target, GLuint index, GLsizei count, const GLint *params)
Replacement of glProgramLocalParametersI4ivNV.

void | GLProgramLocalParametersI4uiv (GLenum target, GLuint index, GLsizei count, const GLuint *params)
Replacement of glProgramLocalParametersI4uivNV.

void | GLProgramLocalParameterI4i (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
Replacement of glProgramLocalParameterI4iNV.

void | GLProgramLocalParameterI4iv (GLenum target, GLuint index, const GLint *params)
Replacement of glProgramLocalParameterI4ivNV.

void | GLProgramLocalParameterI4ui (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
Replacement of glProgramLocalParameterI4uiNV.

void | GLProgramLocalParameterI4uiv (GLenum target, GLuint index, const GLuint *params)
Replacement of glProgramLocalParameterI4uivNV.

void | GLProgramLocalParameters4fv (GLenum target, GLuint index, GLsizei count, const GLfloat *params)
Replacement of glProgramLocalParameters4fvEXT.

void | GLProgramNamedParameter4d (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glProgramNamedParameter4dNV.

void | GLProgramNamedParameter4dv (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v)
Replacement of glProgramNamedParameter4dvNV.

void | GLProgramNamedParameter4f (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramNamedParameter4fNV.

void | GLProgramNamedParameter4fv (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v)
Replacement of glProgramNamedParameter4fvNV.

void | GLProgramParameter4d (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glProgramParameter4dNV.

void | GLProgramParameter4dv (GLenum target, GLuint index, const GLdouble *v)
Replacement of glProgramParameter4dvNV.

void | GLProgramParameter4f (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramParameter4fNV.

void | GLProgramParameter4fv (GLenum target, GLuint index, const GLfloat *v)
Replacement of glProgramParameter4fvNV.

void | GLProgramParameteri (GLuint program, GLenum pname, GLint value)
Replacement of glProgramParameteriEXT.

void | GLProgramParameters4dv (GLenum target, GLuint index, GLsizei count, const GLdouble *v)
Replacement of glProgramParameters4dvNV.

void | GLProgramParameters4fv (GLenum target, GLuint index, GLsizei count, const GLfloat *v)
Replacement of glProgramParameters4fvNV.

void | GLProgramString (GLenum target, GLenum format, GLsizei len, const GLvoid *string)
Replacement of glProgramStringARB.

void | GLProgramVertexLimit (GLenum target, GLint limit)
Replacement of glProgramVertexLimitNV.

void | GLPushAttrib (GLbitfield mask)
Replacement of glPushAttrib.

void | GLPushClientAttrib (GLbitfield mask)
Replacement of glPushClientAttrib.

void | GLPushMatrix (void)
Replacement of glPushMatrix.

void | GLPushName (GLuint name)
Replacement of glPushName.

void | GLRasterPos2d (GLdouble x, GLdouble y)
Replacement of glRasterPos2d.

void | GLRasterPos2f (GLfloat x, GLfloat y)
Replacement of glRasterPos2f.

void | GLRasterPos2i (GLint x, GLint y)
Replacement of glRasterPos2i.

void | GLRasterPos2s (GLshort x, GLshort y)
Replacement of glRasterPos2s.

void | GLRasterPos3d (GLdouble x, GLdouble y, GLdouble z)
Replacement of glRasterPos3d.

void | GLRasterPos3f (GLfloat x, GLfloat y, GLfloat z)
Replacement of glRasterPos3f.

void | GLRasterPos3i (GLint x, GLint y, GLint z)
Replacement of glRasterPos3i.

void | GLRasterPos3s (GLshort x, GLshort y, GLshort z)
Replacement of glRasterPos3s.

void | GLRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glRasterPos4d.

void | GLRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glRasterPos4f.

void | GLRasterPos4i (GLint x, GLint y, GLint z, GLint w)
Replacement of glRasterPos4i.

void | GLRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w)
Replacement of glRasterPos4s.

void | GLReadBuffer (GLenum mode)
Replacement of glReadBuffer.

void | GLReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
Replacement of glReadPixels.

void | GLRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
Replacement of glRectd.

void | GLRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
Replacement of glRectf.

void | GLRecti (GLint x1, GLint y1, GLint x2, GLint y2)
Replacement of glRecti.

void | GLRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2)
Replacement of glRects.

void | GLRenderMode (GLenum mode)
Replacement of glRenderMode.

void | GLRequestResidentPrograms (GLsizei n, const GLuint *programs)
Replacement of glRequestResidentProgramsNV.

void | GLResetHistogram (GLenum target)
Replacement of glResetHistogram.

void | GLResetMinmax (GLenum target)
Replacement of glResetMinmax.

void | GLRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
Replacement of glRotated.

void | GLRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
Replacement of glRotatef.

void | GLScaled (GLdouble x, GLdouble y, GLdouble z)
Replacement of glScaled.

void | GLScalef (GLfloat x, GLfloat y, GLfloat z)
Replacement of glScalef.

void | GLSampleCoverage (GLclampf value, GLboolean invert)
Replacement of glSampleCoverage.

void | GLScissor (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glScissor.

void | GLResetScissor ()
Helper function to reset the scissor rectangle.

void | GLSecondaryColor3b (GLbyte red, GLbyte green, GLbyte blue)
Replacement of glSecondaryColor3b.

void | GLSecondaryColor3bv (const GLbyte *v)
Replacement of glSecondaryColor3bv.

void | GLSecondaryColor3d (GLdouble red, GLdouble green, GLdouble blue)
Replacement of glSecondaryColor3d.

void | GLSecondaryColor3dv (const GLdouble *v)
Replacement of glSecondaryColor3dv.

void | GLSecondaryColor3f (GLfloat red, GLfloat green, GLfloat blue)
Replacement of glSecondaryColor3f.

void | GLSecondaryColor3fv (const GLfloat *v)
Replacement of glSecondaryColor3fv.

void | GLSecondaryColor3h (GLhalf red, GLhalf green, GLhalf blue)
Replacement of glSecondaryColor3h.

void | GLSecondaryColor3hv (const GLhalf *v)
Replacement of glSecondaryColor3hv.

void | GLSecondaryColor3i (GLint red, GLint green, GLint blue)
Replacement of glSecondaryColor3i.

void | GLSecondaryColor3iv (const GLint *v)
Replacement of glSecondaryColor3iv.

void | GLSecondaryColor3s (GLshort red, GLshort green, GLshort blue)
Replacement of glSecondaryColor3s.

void | GLSecondaryColor3sv (const GLshort *v)
Replacement of glSecondaryColor3sv.

void | GLSecondaryColor3ub (GLubyte red, GLubyte green, GLubyte blue)
Replacement of glSecondaryColor3ub.

void | GLSecondaryColor3ubv (const GLubyte *v)
Replacement of glSecondaryColor3ubv.

void | GLSecondaryColor3ui (GLuint red, GLuint green, GLuint blue)
Replacement of glSecondaryColor3ui.

void | GLSecondaryColor3uiv (const GLuint *v)
Replacement of glSecondaryColor3uiv.

void | GLSecondaryColor3us (GLushort red, GLushort green, GLushort blue)
Replacement of glSecondaryColor3us.

void | GLSecondaryColor3usv (const GLushort *v)
Replacement of glSecondaryColor3usv.

void | GLSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glSecondaryColorPointer.

void | GLSelectBuffer (GLsizei size, GLuint *buffer)
Replacement of glSelectBuffer.

void | GLSelectTexture (GLenum target)
Replacement of glSelectTexture.

void | GLSelectTextureCoordSet (GLenum target)
Replacement of GLSelectTextureCoordSet.

void | GLSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
Replacement of glSeparableFilter2D.

void | GLSetFence (GLuint fence, GLenum condition)
Replacement of glSetFenceNV.

void | GLSetWindowStereoMode (GLboolean displayMode)
Replacement of glSetWindowStereoModeNV.

void | GLShadeModel (GLenum mode)
Replacement of glShadeModel.

void | GLResetShadeModel ()
Helper function to reset the shade model.

void | GLShaderSource (GLuint shader, GLsizei count, const GLcharARB **string, const GLint *length)
Replacement of glShaderSource.

void | GLStencilClearTag (GLsizei tagBits, GLuint clearTag)
Replacement of glStencilClearTag.

void | GLStencilFunc (GLenum func, GLint ref, GLuint mask)
Replacement of glStencilFunc.

void | GLStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
Replacement of glStencilFuncSeparate.

void | GLStencilOpSeparate (GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
Replacement of glStencilOpSeparate.

void | GLStencilMaskSeparate (GLenum face, GLuint mask)
Replacement of glStencilMaskSeparate.

void | GLResetStencilFunc ()
Helper function to reset the stencil function values.

void | GLStencilMask (GLuint mask)
Replacement of glStencilMask.

void | GLResetStencilMask ()
Helper function to reset the stencil mask.

void | GLStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
Replacement of glStencilOp.

void | GLResetStencilOp ()
Helper function to reset the stencil operation values.

void | GLStringMarker (GLsizei len, const GLvoid *string)
Replacement of glStringMarkerGREMEDY.

void | GLFrameTerminator (void)
Replacement of glFrameTerminatorGREMEDY.

GLboolean | GLTestFence (GLuint fence)
Replacement of glTestFenceNV.

void | GLTexBuffer (GLenum target, GLenum internalformat, GLuint buffer)
Replacement of glTexBufferEXT.

void | GLTexCoord1d (GLdouble s)
Replacement of glTexCoord1d.

void | GLTexCoord1dv (const GLdouble *v)
Replacement of glTexCoord1dv.

void | GLTexCoord1f (GLfloat s)
Replacement of glTexCoord1f.

void | GLTexCoord1fv (const GLfloat *v)
Replacement of glTexCoord1fv.

void | GLTexCoord1h (GLhalf s)
Replacement of glTexCoord1hNV.

void | GLTexCoord1hv (const GLhalf *v)
Replacement of glTexCoord1hv.

void | GLTexCoord1i (GLint s)
Replacement of glTexCoord1i.

void | GLTexCoord1iv (const GLint *v)
Replacement of glTexCoord1iv.

void | GLTexCoord1s (GLshort s)
Replacement of glTexCoord1s.

void | GLTexCoord1sv (const GLshort *v)
Replacement of glTexCoord1sv.

void | GLTexCoord2d (GLdouble s, GLdouble t)
Replacement of glTexCoord2d.

void | GLTexCoord2dv (const GLdouble *v)
Replacement of glTexCoord2dv.

void | GLTexCoord2f (GLfloat s, GLfloat t)
Replacement of glTexCoord2f.

void | GLTexCoord2fv (const GLfloat *v)
Replacement of glTexCoord2fv.

void | GLTexCoord2h (GLhalf s, GLhalf t)
Replacement of glTexCoord2hNV.

void | GLTexCoord2hv (const GLhalf *v)
Replacement of glTexCoord2hv.

void | GLTexCoord2i (GLint s, GLint t)
Replacement of glTexCoord2i.

void | GLTexCoord2iv (const GLint *v)
Replacement of glTexCoord2iv.

void | GLTexCoord2s (GLshort s, GLshort t)
Replacement of glTexCoord2s.

void | GLTexCoord2sv (const GLshort *v)
Replacement of glTexCoord2sv.

void | GLTexCoord3d (GLdouble s, GLdouble t, GLdouble r)
Replacement of glTexCoord3d.

void | GLTexCoord3dv (const GLdouble *v)
Replacement of glTexCoord3dv.

void | GLTexCoord3f (GLfloat s, GLfloat t, GLfloat r)
Replacement of glTexCoord3f.

void | GLTexCoord3fv (const GLfloat *v)
Replacement of glTexCoord3fv.

void | GLTexCoord3h (GLhalf s, GLhalf t, GLhalf r)
Replacement of glTexCoord3hNV.

void | GLTexCoord3hv (const GLhalf *v)
Replacement of glTexCoord3hv.

void | GLTexCoord3i (GLint s, GLint t, GLint r)
Replacement of glTexCoord3i.

void | GLTexCoord3iv (const GLint *v)
Replacement of glTexCoord3iv.

void | GLTexCoord3s (GLshort s, GLshort t, GLshort r)
Replacement of glTexCoord3s.

void | GLTexCoord3sv (const GLshort *v)
Replacement of glTexCoord3sv.

void | GLTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)
Replacement of glTexCoord4d.

void | GLTexCoord4dv (const GLdouble *v)
Replacement of glTexCoord4dv.

void | GLTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)
Replacement of glTexCoord4f.

void | GLTexCoord4fv (const GLfloat *v)
Replacement of glTexCoord4fv.

void | GLTexCoord4h (GLhalf s, GLhalf t, GLhalf r, GLhalf q)
Replacement of glTexCoord4hNV.

void | GLTexCoord4hv (const GLhalf *v)
Replacement of glTexCoord4hv.

void | GLTexCoord4i (GLint s, GLint t, GLint r, GLint q)
Replacement of glTexCoord4i.

void | GLTexCoord4iv (const GLint *v)
Replacement of glTexCoord4iv.

void | GLTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)
Replacement of glTexCoord4s.

void | GLTexCoord4sv (const GLshort *v)
Replacement of glTexCoord4sv.

void | GLTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glTexCoordPointer.

void | GLTextureEnvColor (const GLfloat *params)
Cached version of GLTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params ).

void | GLTextureEnvMode (GLint param)
Cached version of GLTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, param ).

void | GLTexEnvf (GLenum target, GLenum pname, GLfloat param)
Cached version of glTexEnvf( target, pname, param ).

void | GLTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)
Cached version of glTexEnvf( target, pname, param ).

void | GLTexEnvi (GLenum target, GLenum pname, GLint param)
Cached version of glTexEnvi( target, pname, param ).

void | GLTexEnviv (GLenum target, GLenum pname, const GLint *params)
Cached version of glTexEnviv( target, pname, param ).

void | GLTexGend (GLenum coord, GLenum pname, GLdouble param)
Replacement of glTexGend.

void | GLTexGenf (GLenum coord, GLenum pname, GLfloat param)
Replacement of glTexGenf.

void | GLTexGenfv (GLenum coord, GLenum pname, const GLfloat *param)
Replacement of glTexGenfv.

void | GLTexGeni (GLenum coord, GLenum pname, GLint param)
Replacement of glTexGeni.

void | GLTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexImage1D.

void | GLTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexImage2D.

void | GLTexImage3D (GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type, const void *pixels)
Replacement of glTexImage3D.

void | GLTextureBorderColor (GLenum target, const GLfloat *params)
Cached version of GLTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, params ).

void | GLTextureMagFilter (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_MAG_FILTER, param ).

void | GLTextureMinFilter (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_MIN_FILTER, param ).

void | GLTextureWrapR (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_R, param ).

void | GLTextureWrapS (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_S, param ).

void | GLTextureWrapT (GLenum target, GLint param)
Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_T, param ).

void | GLTrackMatrix (GLenum target, GLuint address, GLenum matrix, GLenum transform)
Cached version of glTrackMatrixNV.

void | GLTransformFeedbackAttribs (GLuint count, const GLint *attribs, GLenum bufferMode)
Cached version of glTransformFeedbackAttribsNV.

void | GLTransformFeedbackVaryings (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode)
Cached version of glTransformFeedbackVaryingsNV.

void | GLTexParameterf (GLenum target, GLenum pname, GLfloat param)
Cached version of glTexParameterf( target, pname, param ).

void | GLTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)
Cached version of glTexParameterfv( target, pname, params ).

void | GLTexParameteri (GLenum target, GLenum pname, GLint param)
Cached version of glTexParameteri( target, pname, param ).

void | GLTexParameterIiv (GLenum target, GLenum pname, const GLint *params)
Replacement of glTexParameterIivEXT.

void | GLTexParameterIuiv (GLenum target, GLenum pname, const GLuint *params)
Replacement of glTexParameterIuivEXT.

void | GLTexParameteriv (GLenum target, GLenum pname, const GLint *params)
Cached version of glTexParameteriv( target, pname, params ).

void | GLTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexSubImage1D.

void | GLTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexSubImage2D.

void | GLTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexSubImage3D.

void | GLTranslated (GLdouble x, GLdouble y, GLdouble z)
Replacement of glTranslated.

void | GLTranslatef (GLfloat x, GLfloat y, GLfloat z)
Replacement of glTranslatef.

GLboolean | GLValidBackBufferHint (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glValidBackBufferHintAutodesk.

void | GLVertex2d (GLdouble x, GLdouble y)
Replacement of glVertex2d.

void | GLVertex2dv (const GLdouble *v)
Replacement of glVertex2dv.

void | GLVertex2f (GLfloat x, GLfloat y)
Replacement of glVertex2f.

void | GLVertex2fv (const GLfloat *v)
Replacement of glVertex2fv.

void | GLVertex2h (GLhalf x, GLhalf y)
Replacement of glVertex2hNV.

void | GLVertex2hv (const GLhalf *v)
Replacement of glVertex2hv.

void | GLVertex2i (GLint x, GLint y)
Replacement of glVertex2i.

void | GLVertex2iv (const GLint *v)
Replacement of glVertex2iv.

void | GLVertex2s (GLshort x, GLshort y)
Replacement of glVertex2s.

void | GLVertex2sv (const GLshort *v)
Replacement of glVertex2sv.

void | GLVertex3d (GLdouble x, GLdouble y, GLdouble z)
Replacement of glVertex3d.

void | GLVertex3dv (const GLdouble *v)
Replacement of glVertex3dv.

void | GLVertex3f (GLfloat x, GLfloat y, GLfloat z)
Replacement of glVertex3f.

void | GLVertex3fv (const GLfloat *v)
Replacement of glVertex3fv.

void | GLVertex3h (GLhalf x, GLhalf y, GLhalf z)
Replacement of glVertex3hNV.

void | GLVertex3hv (const GLhalf *v)
Replacement of glVertex3hv.

void | GLVertex3i (GLint x, GLint y, GLint z)
Replacement of glVertex3i.

void | GLVertex3iv (const GLint *v)
Replacement of glVertex3iv.

void | GLVertex3s (GLshort x, GLshort y, GLshort z)
Replacement of glVertex3s.

void | GLVertex3sv (const GLshort *v)
Replacement of glVertex3sv.

void | GLVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glVertex4d.

void | GLVertex4dv (const GLdouble *v)
Replacement of glVertex4dv.

void | GLVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glVertex4f.

void | GLVertex4fv (const GLfloat *v)
Replacement of glVertex4fv.

void | GLVertex4h (GLhalf x, GLhalf y, GLhalf z, GLhalf w)
Replacement of glVertex4hNV.

void | GLVertex4hv (const GLhalf *v)
Replacement of glVertex4hv.

void | GLVertex4i (GLint x, GLint y, GLint z, GLint w)
Replacement of glVertex4i.

void | GLVertex4iv (const GLint *v)
Replacement of glVertex4iv.

void | GLVertex4s (GLshort x, GLshort y, GLshort z, GLshort w)
Replacement of glVertex4s.

void | GLVertex4sv (const GLshort *v)
Replacement of glVertex4sv.

void | GLVertexArrayRange (GLsizei size, const GLvoid *pointer)
Replacement of glVertexArrayRange.

void | GLVertexAttrib1d (GLuint index, GLdouble x)
Replacement of glVertexAttrib1d.

void | GLVertexAttrib1dv (GLuint index, const GLdouble *v)
Replacement of glVertexAttrib1dv.

void | GLVertexAttrib1f (GLuint index, GLfloat x)
Replacement of glVertexAttrib1f.

void | GLVertexAttrib1fv (GLuint index, const GLfloat *v)
Replacement of glVertexAttrib1fv.

void | GLVertexAttrib1h (GLuint index, GLhalf x)
Replacement of glVertexAttrib1h.

void | GLVertexAttrib1hv (GLuint index, const GLhalf *v)
Replacement of glVertexAttrib1nv.

void | GLVertexAttrib1s (GLuint index, GLshort x)
Replacement of glVertexAttrib1s.

void | GLVertexAttrib1sv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib1sv.

void | GLVertexAttrib2d (GLuint index, GLdouble x, GLdouble y)
Replacement of glVertexAttrib2d.

void | GLVertexAttrib2dv (GLuint index, const GLdouble *v)
Replacement of glVertexAttrib2dv.

void | GLVertexAttrib2f (GLuint index, GLfloat x, GLfloat y)
Replacement of glVertexAttrib2f.

void | GLVertexAttrib2fv (GLuint index, const GLfloat *v)
Replacement of glVertexAttrib2fv.

void | GLVertexAttrib2h (GLuint index, GLhalf x, GLhalf y)
Replacement of glVertexAttrib2h.

void | GLVertexAttrib2hv (GLuint index, const GLhalf *v)
Replacement of glVertexAttrib2hv.

void | GLVertexAttrib2s (GLuint index, GLshort x, GLshort y)
Replacement of glVertexAttrib2s.

void | GLVertexAttrib2sv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib2sv.

void | GLVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)
Replacement of glVertexAttrib3d.

void | GLVertexAttrib3dv (GLuint index, const GLdouble *v)
Replacement of glVertexAttrib3dv.

void | GLVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z)
Replacement of glVertexAttrib3f.

void | GLVertexAttrib3fv (GLuint index, const GLfloat *v)
Replacement of glVertexAttrib3fv.

void | GLVertexAttrib3h (GLuint index, GLhalf x, GLhalf y, GLhalf z)
Replacement of glVertexAttrib3h.

void | GLVertexAttrib3hv (GLuint index, const GLhalf *v)
Replacement of glVertexAttrib3hv.

void | GLVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z)
Replacement of glVertexAttrib3s.

void | GLVertexAttrib3sv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib3sv.

void | GLVertexAttrib4bv (GLuint index, const GLbyte *v)
Replacement of glVertexAttrib3bv.

void | GLVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glVertexAttrib4d.

void | GLVertexAttrib4dv (GLuint index, const GLdouble *v)
Replacement of glVertexAttrib4dv.

void | GLVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glVertexAttrib4f.

void | GLVertexAttrib4fv (GLuint index, const GLfloat *v)
Replacement of glVertexAttrib4fv.

void | GLVertexAttrib4h (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w)
Replacement of glVertexAttrib4h.

void | GLVertexAttrib4hv (GLuint index, const GLhalf *v)
Replacement of glVertexAttrib4hv.

void | GLVertexAttrib4iv (GLuint index, const GLint *v)
Replacement of glVertexAttrib4iv.

void | GLVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
Replacement of glVertexAttrib4s.

void | GLVertexAttrib4sv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib4sv.

void | GLVertexAttrib4ub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
Replacement of glVertexAttrib4ub.

void | GLVertexAttrib4ubv (GLuint index, const GLubyte *v)
Replacement of glVertexAttrib4ubv.

void | GLVertexAttrib4uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttrib4uiv.

void | GLVertexAttrib4usv (GLuint index, const GLushort *v)
Replacement of glVertexAttrib4usv.

void | GLVertexAttrib4Nbv (GLuint index, const GLbyte *v)
Replacement of glVertexAttrib4Nbv.

void | GLVertexAttrib4Niv (GLuint index, const GLint *v)
Replacement of glVertexAttrib4Niv.

void | GLVertexAttrib4Nsv (GLuint index, const GLshort *v)
Replacement of glVertexAttrib4Nsv.

void | GLVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
Replacement of glVertexAttrib4Nub.

void | GLVertexAttrib4Nubv (GLuint index, const GLubyte *v)
Replacement of glVertexAttrib4Nubv.

void | GLVertexAttrib4Nuiv (GLuint index, const GLuint *v)
Replacement of glVertexAttrib4Nuiv.

void | GLVertexAttrib4Nusv (GLuint index, const GLushort *v)
Replacement of glVertexAttrib4Nusv.

void | GLVertexAttribI1i (GLuint index, GLint x)
Replacement of glVertexAttribI1iEXT.

void | GLVertexAttribI2i (GLuint index, GLint x, GLint y)
Replacement of glVertexAttribI2iEXT.

void | GLVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z)
Replacement of glVertexAttribI3iEXT.

void | GLVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w)
Replacement of glVertexAttribI4iEXT.

void | GLVertexAttribI1ui (GLuint index, GLuint x)
Replacement of glVertexAttribI1uiExt.

void | GLVertexAttribI2ui (GLuint index, GLuint x, GLuint y)
Replacement of glVertexAttribI2uiExt.

void | GLVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z)
Replacement of glVertexAttribI3uiExt.

void | GLVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
Replacement of glVertexAttribI4uiExt.

void | GLVertexAttribI1iv (GLuint index, const GLint *v)
Replacement of glVertexAttribI1ivEXT.

void | GLVertexAttribI2iv (GLuint index, const GLint *v)
Replacement of glVertexAttribI2ivEXT.

void | GLVertexAttribI3iv (GLuint index, const GLint *v)
Replacement of glVertexAttribI3ivEXT.

void | GLVertexAttribI4iv (GLuint index, const GLint *v)
Replacement of glVertexAttribI4ivEXT.

void | GLVertexAttribI1uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttribI1iuvEXT.

void | GLVertexAttribI2uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttribI2uivEXT.

void | GLVertexAttribI3uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttribI3uivEXT.

void | GLVertexAttribI4uiv (GLuint index, const GLuint *v)
Replacement of glVertexAttribI4uivEXT.

void | GLVertexAttribI4bv (GLuint index, const GLbyte *v)
Replacement of glVertexAttribI4bvEXT.

void | GLVertexAttribI4ubv (GLuint index, const GLubyte *v)
Replacement of glVertexAttribI4ubvEXT.

void | GLVertexAttribI4sv (GLuint index, const GLshort *v)
Replacement of glVertexAttribI4svEXT.

void | GLVertexAttribI4usv (GLuint index, const GLushort *v)
Replacement of glVertexAttribI4usvEXT.

void | GLVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glVertexAttribIPointerEXT.

void | GLVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalize, GLsizei stride, const GLvoid *pointer)
Replacement of glVertexAttribPointer.

void | GLVertexAttribPointerNV (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glVertexAttribPointerNV.

void | GLVertexAttribs1dvNV (GLuint index, GLsizei count, const GLdouble *v)
Replacement of glVertexAttribs1dvNV.

void | GLVertexAttribs1fvNV (GLuint index, GLsizei count, const GLfloat *v)
Replacement of glVertexAttribs1fvNV.

void | GLVertexAttribs1hv (GLuint index, GLsizei count, const GLhalf *v)
Replacement of glVertexAttribs1hv.

void | GLVertexAttribs1svNV (GLuint index, GLsizei count, const GLshort *v)
Replacement of glVertexAttribs1svNV.

void | GLVertexAttribs2dvNV (GLuint index, GLsizei count, const GLdouble *v)
Replacement of glVertexAttribs2dvNV.

void | GLVertexAttribs2fvNV (GLuint index, GLsizei count, const GLfloat *v)
Replacement of glVertexAttribs2fvNV.

void | GLVertexAttribs2hv (GLuint index, GLsizei count, const GLhalf *v)
Replacement of glVertexAttribs2hv.

void | GLVertexAttribs2svNV (GLuint index, GLsizei count, const GLshort *v)
Replacement of glVertexAttribs2svNV.

void | GLVertexAttribs3dvNV (GLuint index, GLsizei count, const GLdouble *v)
Replacement of glVertexAttribs3dvNV.

void | GLVertexAttribs3fvNV (GLuint index, GLsizei count, const GLfloat *v)
Replacement of glVertexAttribs3fvNV.

void | GLVertexAttribs3hv (GLuint index, GLsizei count, const GLhalf *v)
Replacement of glVertexAttribs3hv.

void | GLVertexAttribs3svNV (GLuint index, GLsizei count, const GLshort *v)
Replacement of glVertexAttribs3svNV.

void | GLVertexAttribs4dvNV (GLuint index, GLsizei count, const GLdouble *v)
Replacement of glVertexAttribs4dvNV.

void | GLVertexAttribs4fvNV (GLuint index, GLsizei count, const GLfloat *v)
Replacement of glVertexAttribs4fvNV.

void | GLVertexAttribs4hv (GLuint index, GLsizei count, const GLhalf *v)
Replacement of glVertexAttribs4hv.

void | GLVertexAttribs4svNV (GLuint index, GLsizei count, const GLshort *v)
Replacement of glVertexAttribs4svNV.

void | GLVertexAttribs4ubvNV (GLuint index, GLsizei count, const GLubyte *v)
Replacement of glVertexAttribs4svNV.

void | GLVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glVertexPointer.

void | GLViewport (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glViewport.

void | GLWindowBackBufferHint ()
Replacement of glWindowBackBufferHintAutodesk.

void | GLWindowPos2d (GLdouble x, GLdouble y)
Replacement of glWindowPos2d.

void | GLWindowPos2dv (const GLdouble *p)
Replacement of glWindowPos2dv.

void | GLWindowPos2f (GLfloat x, GLfloat y)
Replacement of glWindowPos2f.

void | GLWindowPos2fv (const GLfloat *p)
Replacement of glWindowPos2fv.

void | GLWindowPos2i (GLint x, GLint y)
Replacement of glWindowPos2i.

void | GLWindowPos2iv (const GLint *p)
Replacement of glWindowPos2iv.

void | GLWindowPos2s (GLshort x, GLshort y)
Replacement of glWindowPos2s.

void | GLWindowPos2sv (const GLshort *p)
Replacement of glWindowPos2sv.

void | GLWindowPos3d (GLdouble x, GLdouble y, GLdouble z)
Replacement of glWindowPos3d.

void | GLWindowPos3dv (const GLdouble *p)
Replacement of glWindowPos3dv.

void | GLWindowPos3f (GLfloat x, GLfloat y, GLfloat z)
Replacement of glWindowPos3f.

void | GLWindowPos3fv (const GLfloat *p)
Replacement of glWindowPos3fv.

void | GLWindowPos3i (GLint x, GLint y, GLint z)
Replacement of glWindowPos3i.

void | GLWindowPos3iv (const GLint *p)
Replacement of glWindowPos3iv.

void | GLWindowPos3s (GLshort x, GLshort y, GLshort z)
Replacement of glWindowPos3s.

void | GLWindowPos3sv (const GLshort *p)
Replacement of glWindowPos3sv.

GLboolean | GLIsRenderbuffer (GLuint renderbuffer)
Replacement of glIsRenderbufferEXT.

void | GLBindRenderbuffer (GLenum target, GLuint renderbuffer)
Replacement of glBindRenderbufferEXT.

void | GLDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers)
Replacement of glDeleteRenderbuffersEXT.

void | GLGenRenderbuffers (GLsizei n, GLuint *renderbuffers)
Replacement of glGenRenderbuffersEXT.

void | GLRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
Replacement of glRenderbufferStorageEXT.

void | GLRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
Replacement of glRenderbufferStorageMultisampleEXT.

void | GLRenderbufferStorageMultisampleCoverage (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)
Replacement of glRenderbufferStorageMultisampleCoverageNV.

void | GLGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetRenderbufferParameterivEXT.

GLboolean | GLIsFramebuffer (GLuint framebuffer)
Replacement of glIsFramebufferEXT.

void | GLBindFramebuffer (GLenum target, GLuint framebuffer)
Replacement of glBindFramebufferEXT.

void | GLDeleteFramebuffers (GLsizei n, const GLuint *framebuffers)
Replacement of glDeleteFramebuffersEXT.

void | GLGenFramebuffers (GLsizei n, GLuint *framebuffers)
Replacement of glGenFramebuffersEXT.

GLenum | GLCheckFramebufferStatus (GLenum target)
Replacement of glCheckFramebufferStatusEXT.

void | GLFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
Replacement of glFramebufferTexture1DEXT.

void | GLFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
Replacement of glFramebufferTexture2DEXT.

void | GLFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
Replacement of glFramebufferTexture3DEXT.

void | GLFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
Replacement of glFramebufferTextureLayerEXT.

void | GLFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
Replacement of glFramebufferRenderbufferEXT.

void | GLGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params)
Replacement of glGetFramebufferAttachmentParameterivEXT.

void | GLGenerateMipmap (GLenum target)
Replacement of glGenerateMipmapEXT.

GLenum | GLGetTexWrapMode (nvsg::TextureWrapMode twm)
Translate an nvsg::TextureWrapMode into a GL-specific texture wrap mode as a GLenum.

bool | WGLInitializeExtensions (void)
Initialize the wgl-extension functions inside the WGLFunctions class.

bool | WGLIsExtensionAvailable (const std::string &extstr)
Returns whether the specified wgl-extension is available.

bool | WGLIsExtensionExported (const std::string &extstr)
Returns whether the specified wgl-extension is exported.

BOOL | WGLBindTexImage (HPBUFFERARB hPbuffer, int iBuffer)
Replacement of wglBindTexImageARB.

BOOL | WGLChoosePixelFormat (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats)
Replacement of wglChoosePixelFormatARB.

HGLRC | WGLCreateContext (HDC hdc)
Replacement of wglCreateContext.

HPBUFFERARB | WGLCreatePbuffer (HDC hdc, int pixelFormat, int width, int height, const int *attribList)
Replacement of wglCreatePbufferARB.

BOOL | WGLDeleteContext (HGLRC hglrc)
Replacement of wglDeleteContext.

BOOL | WGLDestroyPbuffer (HPBUFFERARB hPbuffer)
Replacement of wglDestroyPbufferARB.

HGLRC | WGLGetCurrentContext (void)
Replacement for wglGetCurrenContext.

HDC | WGLGetCurrentDC (void)
Replacement for wglGetCurrentDC.

HDC | WGLGetPbufferDC (HPBUFFERARB hPbuffer)
Replacement of wglGetPbufferDCARB.

BOOL | WGLQueryPbuffer (HPBUFFERARB hPbuffer, int attribute, int *value)
Replacement of wglQueryPbufferARB.

int | WGLReleasePbufferDC (HPBUFFERARB hPbuffer, HDC hdc)
Replacement of wglReleasePbufferDCARB.

BOOL | WGLReleaseTexImage (HPBUFFERARB hPbuffer, int iBuffer)
Replacement of wglReleaseTexImageARB.

BOOL | WGLJoinSwapGroupNV (HDC hDC, GLuint group)
Replacement of wglJointSwapGroupNV.

BOOL | WGLBindSwapBarrierNV (GLuint group, GLuint barrier)
Replacement of wglBindSwapBarrierNV.

BOOL | WGLQuerySwapGroupNV (HDC hDC, GLuint *group, GLuint *barrier)
Replacement of wglQuerySwapGroupNV.

BOOL | WGLQueryMaxSwapGroupsNV (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers)
Replacement of wglQueryMaxSwapGroupsNV.

BOOL | WGLQueryFrameCountNV (HDC hDC, GLuint *count)
Replacement of wglQueryFrameCountNV.

BOOL | WGLResetFrameCountNV (HDC hDC)
Replacement of wglResetFrameCountNV.

BOOL | WGLEnumGpus (UINT iIndex, HGPUNV *hGpu)
Replacement of wglEnumGpusNV.

BOOL | WGLEnumGpuDevices (HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice)
Replacement of wglEnumGpuDevicesNV.

HDC | WGLCreateAffinityDC (const HGPUNV *pGpuList)
Replacement for wglCreateAffinityDVNV.

BOOL | WGLEnumGpusFromAffinityDC (HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu)
Replacement for wglEnumGpusFromAffinityDCNV.

BOOL | WGLDeleteDC (HDC hAffinityDC)
Replacement for wglDeleteDCNV.

BOOL | WGLGetVideoDevice (HDC hDC, INT iVideoStreams, HPVIDEODEVICE *phpVideoDevice)
Replacement for wglGetVideoDeviceNV.

BOOL | WGLReleaseVideoDevice (HPVIDEODEVICE hpVideoDevice)
Replacement for wglReleaseVideoDeviceNV.

BOOL | WGLBindVideoImage (HPVIDEODEVICE hpVideoDevice, HPBUFFERARB hPbuffer, INT iVideoBuffer)
Replacement for wglBindVideoImageNV.

BOOL | WGLReleaseVideoImage (HPBUFFERARB hPbuffer, INT iVideoBuffer)
Replacement for wglReleaseVideoImageNV.

BOOL | WGLSendPbufferToVideo (HPBUFFERARB hPbuffer, INT iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock)
Replacement for wglSendPbufferToVideoNV.

BOOL | WGLGetVideoInfo (HPVIDEODEVICE hpVideoDevice, unsigned long *pulCounterOutputVideo, unsigned long *pulCounterOutputPbuffer)
Replacement for wglGetVideoInfoNV.

bool | GLXInitializeExtensions (Display *dpy)
Initialize the glx-extension functions inside the GLXFunctions class.

bool | GLXIsExtensionAvailable (const std::string &extstr)
Returns whether the specified glx-extension is available.

bool | GLXIsExtensionExported (const std::string &extstr)
Returns whether the specified glx-extension is exported.

GLXContext | GLXCreateContext (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct)
Replacement of glXCreateContext.

void | GLXDestroyContext (Display *dpy, GLXContext ctx)
Replacement of glXDestroyContext.

GLXContext | GLXGetCurrentContext ()
Replacement of glXGetCurrentContext.

GLXDrawable | GLXGetCurrentDrawable ()
Replacement of glXGetCurrentDrawable.

NVSG_API int | GLXSwapInterval (int value)
int | GLXGetVideoSync (unsigned int *value)
int | GLXWaitVideoSync (int divisor, int remainder, unsigned int *cnt)
Bool | GLXJoinSwapGroup (Display *dpy, GLXDrawable drawable, GLuint group)
Bool | GLXBindSwapBarrier (Display *dpy, GLuint group, GLuint barrier)
Bool | GLXQuerySwapGroup (Display *dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier)
Bool | GLXQueryMaxSwapGroups (Display *dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers)
Bool | GLXQueryFrameCount (Display *dpy, int screen, GLuint *count)
Bool | GLXResetFrameCount (Display *dpy, int screen)
int | GLXGetVideoDevice (Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice)
int | GLXReleaseVideoDevice (Display *dpy, int screen, GLXVideoDeviceNV VideoDevice)
int | GLXBindVideoImage (Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer)
int | GLXReleaseVideoImage (Display *dpy, GLXPbuffer pbuf)
int | GLXSendPbufferToVideo (Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock)
int | GLXGetVideoInfo (Display *dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputVideo, unsigned long *pulCounterOutputPbuffer)
void | GLXBindTexImage (Display *dpy, GLXDrawable d, int buffer, const int *attrList)
void | GLXReleaseTexImage (Display *dpy, GLXDrawable d, int buffer)
NVSG_API void | GLGenVertexBuffer (GLenum target, GLsizeiptr size, GLuint *buffer)
Generates a vertex buffer of requested size.

NVSG_API void | GLGenIndexBuffer (GLenum target, GLsizeiptr size, GLuint *buffer)
Generates an index buffer of requested size.

NVSG_API void | GLDeleteVertexBuffer (GLuint buffer)
Deletes a vertex buffer.

NVSG_API void | GLDeleteIndexBuffer (GLuint buffer)
Deletes an index buffer.

NVSG_API void | GLBindVertexBuffer (GLuint buffer)
Binds the buffer name associated with the identifier buffer to the GL_ARRAY_ELEMENT target.

NVSG_API void | GLBindTransformFeedbackBuffer (GLuint index, GLuint buffer, GLuint offset)
Binds the buffer name associated with the identifier buffer to the GL_TRANSFORM_FEEDBACK_BUFFER_NV target.

NVSG_API void | GLBindIndexBuffer (GLuint buffer)
Binds the buffer name associated with the identifier buffer to the GL_ELEMENT_ARRAY_ELEMENT target.

NVSG_API void | GLUploadBuffers ()
Uploads all pending buffers.

NVSG_API GLvoid * | GLMapVertexBuffer (GLuint buffer)
Maps the vertex buffer identified by buffer into process memory for write-only access.

NVSG_API GLvoid * | GLMapIndexBuffer (GLuint buffer)
Maps the index buffer identified by buffer into process memory for write-only access.

NVSG_API GLboolean | GLUnmapVertexBuffer (GLuint buffer)
Relinquishes a vertex buffer mapping.

NVSG_API GLboolean | GLUnmapIndexBuffer (GLuint buffer)
Relinquishes an index buffer mapping.

NVSG_API GLsizeiptr | GLGetVertexBufferOffset (GLuint buffer)
Returns the start offset for the specified buffer.

NVSG_API void | GLBuildVertexBufferCache (nvgl::GLArrayBufferCache *vi, GLuint whichBuffer, const nvsg::VertexAttributeSet *vas)
VBO / Cache Filling Methods.

NVSG_API void | GLFillVertexBufferCache (nvgl::GLArrayBufferCache *vi, GLuint whichBuffer, const nvsg::VertexAttributeSet *vas)
NVSG_API void | GLBuildIndexBufferCache (nvgl::GLElementArrayBufferCache *vi, GLsizeiptr offs, unsigned int numStrips, const nvsg::IndexSet *strips, bool primitiveRestartSupport)
NVSG_API void | GLBuildIndexBufferCache (nvgl::GLElementArrayBufferCache *vi, GLsizeiptr offs, unsigned int numIndices, const unsigned int *indices)
NVSG_API GLsizeiptr | GLGetIndexBufferOffset (GLuint buffer)
Returns the start offset for the specified buffer.

NVSG_API GLboolean | GLIsVertexBuffer (GLuint buffer)
Returns whether buffer identifies a valid vertex buffer for the current context.

NVSG_API GLboolean | GLIsIndexBuffer (GLuint buffer)
Returns whether buffer identifies a valid index buffer for the current context.

Variables

NVSG_API DWORD | glContextTlsIdx
NVSG_API GLenum | glError
holds the current OpenGL error code to ease debugging

Detailed Description

Namespace for OpenGL.

This namespace wraps around the native OpenGL implementation. It organizes caching, attribute handling, etc....

Note:
Do not use native OpenGL calls when extending NVSG or NVSG-based viewers. Instead, use the implementation of the OpenGL commands contained in this namespace so you do not break caching, etc.

Do not include other OpenGL headers. nvgl.h should be the only OpenGL header you need.

Function Documentation

GLContext* glContext ( ) [inline]

Get the GLContext of the current thread.

Returns:
The GLContext of the current thread.
Remarks:
When using WGLMakeCurrent (or GLXMakeCurrent on Linux), to make a HGLRC current, the corresponding GLContext is assigned. As there can be only one HGLRC current per thread, the same holds for the GLContext. Using this function returns the GLContext of the current thread.
See also:
WGLMakeCurrent, GLXMakeCurrent, GLContext

bool equalf | ( | GLfloat | a,
 |  | GLfloat | b
 | ) | [inline]

Fast float compare helper.

bool equal3f | ( | GLfloat | a1,
 |  | GLfloat | a2,
 |  | GLfloat | a3,
 |  | const GLfloat * | b
 | ) | [inline]

Fast float compare helper.

bool equal3fv | ( | const GLfloat * | a,
 |  | const GLfloat * | b
 | ) | [inline]

Fast float compare helper.

bool equal4f | ( | GLfloat | a1,
 |  | GLfloat | a2,
 |  | GLfloat | a3,
 |  | GLfloat | a4,
 |  | const GLfloat * | b
 | ) | [inline]

Fast float compare helper.

bool equal4fv | ( | const GLfloat * | a,
 |  | const GLfloat * | b
 | ) | [inline]

Fast float compare helper.

void GLAccum | ( | GLenum | op,
 |  | GLfloat | value
 | ) | [inline]

Replacement of glAccum.

This function asserts on the result before returning.

void GLActiveStencilFace ( GLenum face ) [inline]

Replacement of glActiveStencilFaceEXT.

This function asserts on the result before returning.

void GLActiveTexture ( GLenum texture ) [inline]

Replacement of glActiveTexture.

This function stores the texture to activate for subsequent texture operations.

void GLActiveVarying | ( | GLuint | program,
 |  | const GLchar * | name
 | ) | [inline]

Replacement of glActiveVaryingNV.

This function asserts on the result before returning.

void GLAddSwapHintRect | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glSwapHintRectWin.

This function asserts on the result before returning.

void GLAlphaFunc | ( | GLenum | func,
 |  | GLclampf | ref
 | ) | [inline]

Replacement of glAlphaFunc.

This function caches the alpha func and ref and asserts on the result before returning.

void GLResetAlphaFunc ( ) [inline]

Helper function to reset alpha function and alpha reference value.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this functions sets the alpha function and alpha reference value to the previous function and value. Otherwise, the alpha function is set to GL_ALWAYS, and the alpha reference value is set to zero.
See also:
GLAlphaFunc

GLboolean GLAreProgramsResident | ( | GLsizei | n,
 |  | const GLuint * | programs,
 |  | GLboolean * | residences
 | ) | [inline]

Replacement of glAreProgramsResidentNV.

This function asserts on the result before returning.

GLboolean GLAreTexturesResident | ( | GLsizei | n,
 |  | const GLuint * | textures,
 |  | GLboolean * | residences
 | ) | [inline]

Replacement of glAreTexturesResident.

This function asserts on the result before returning.

void GLArrayElement ( GLint i ) [inline]

Replacement of glArrayElement.

This function asserts on the result before returning.

void GLAttachObject | ( | GLhandleARB | containerObj,
 |  | GLhandleARB | attachedObj
 | ) | [inline]

Replacement of glAttachObjectARB.

This function asserts on the result before returning.

void GLAttachShader | ( | GLuint | program,
 |  | GLuint | shader
 | ) | [inline]

Replacement of glAttachShader.

This function asserts on the result before returning.

void GLBegin ( GLenum mode ) [inline]

Replacement of glBegin.

This function asserts on the result before returning.

void GLBeginOcclusionQuery ( GLuint id ) [inline]

Replacement of glBeginOcclusionQueryNV.

This function asserts on the result before returning.

void GLBeginQuery | ( | GLenum | target,
 |  | GLuint | id
 | ) | [inline]

Replacement of glBeginQuery.

This function asserts on the result before returning.

void GLBeginTransformFeedback ( GLenum primitiveMode ) [inline]

Replacement of glBeginTransformFeedbackNV.

void GLBlendColor | ( | GLclampf | red,
 |  | GLclampf | green,
 |  | GLclampf | blue,
 |  | GLclampf | alpha
 | ) | [inline]

Replacement of glBlendColor.

void GLBindArraySet ( GLuint buffer ) [inline]

Replacement of glBindArraySetARB.

void GLBindAttribLocation | ( | GLuint | program,
 |  | GLuint | index,
 |  | const GLchar * | name
 | ) | [inline]

Replacement of glBindAttribLocation.

void GLBindBuffer | ( | GLenum | target,
 |  | GLuint | id
 | ) | [inline]

Replacement of glBindBuffer.

This function caches and asserts on the result before returning.

void GLBindBufferBase | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | buffer
 | ) | [inline]

Replacement of glBindBufferBaseNV.

This function asserts on the result before returning.

void GLBindBufferOffset | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | buffer,
 |  | GLintptr | offset
 | ) | [inline]

Replacement of glBindBufferOffsetNV.

This function asserts on the result before returning.

void GLBindBufferRange | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | buffer,
 |  | GLintptr | offset,
 |  | GLsizeiptr | size
 | ) | [inline]

Replacement of glBindBufferRangeNV.

This function asserts on the result before returning.

void GLBufferData | ( | GLenum | target,
 |  | GLsizeiptrARB | size,
 |  | const GLvoid * | data,
 |  | GLenum | usage
 | ) | [inline]

Replacement of glBufferData.

This function asserts on the result before returning.

void GLBufferSubData | ( | GLenum | target,
 |  | GLintptrARB | offset,
 |  | GLsizeiptrARB | size,
 |  | const GLvoid * | data
 | ) | [inline]

Replacement of glBufferSubData.

This function and asserts on the result before returning.

void GLDeleteArraySets | ( | GLsizei | n,
 |  | const GLuint * | buffers
 | ) | [inline]

Replacement of glDeleteArraySetsARB.

This function asserts on the result before returning.

void GLDeleteBuffers | ( | GLsizei | n,
 |  | const GLuint * | buffers
 | ) | [inline]

Replacement of glDeleteBuffers.

This function updates some caches, and asserts on the result before returning.

void GLDeleteFences | ( | GLsizei | n,
 |  | const GLuint * | fences
 | ) | [inline]

Replacement of glDeleteFencesNV.

void GLGenArraySets | ( | GLsizei | n,
 |  | GLuint * | buffers
 | ) | [inline]

Replacement of glGenArraySetsARB.

void GLGenBuffers | ( | GLsizei | n,
 |  | GLuint * | buffers
 | ) | [inline]

Replacement of glGenBuffers.

This function asserts on the result, and updates some caches.

void GLGenFences | ( | GLsizei | n,
 |  | GLuint * | fences
 | ) | [inline]

Replacement of glGenFencesNV.

GLvoid* GLMapBuffer | ( | GLenum | target,
 |  | GLenum | access
 | ) | [inline]

Replacement of glMapBuffer.

This function hides the extension character of glMapBufferARB and asserts on the result before returning.

void GLUnlockArrays ( ) [inline]

Replacement of glUnlockArrays.

This function asserts on the result before returning.

void GLUniform1f | ( | GLint | location,
 |  | GLfloat | v0
 | ) | [inline]

Replacement of glUniform1f.

This function asserts on the result before returning.

void GLUniform1fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniform1fv.

This function asserts on the result before returning.

void GLUniform1i | ( | GLint | location,
 |  | GLint | v0
 | ) | [inline]

Replacement of glUniform1i.

This function asserts on the result before returning.

void GLUniform1iv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLint * | value
 | ) | [inline]

Replacement of glUniform1iv.

This function asserts on the result before returning.

void GLUniform1ui | ( | GLint | location,
 |  | GLuint | v0
 | ) | [inline]

Replacement of glUniform1uiEXT.

This function asserts on the result before returning.

void GLUniform1uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) | [inline]

Replacement of glUniform1uivEXT.

This function asserts on the result before returning.

void GLUniform2f | ( | GLint | location,
 |  | GLfloat | v0,
 |  | GLfloat | v1
 | ) | [inline]

Replacement of glUniform2f.

This function asserts on the result before returning.

void GLUniform2fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniform2fv.

This function asserts on the result before returning.

void GLUniform2i | ( | GLint | location,
 |  | GLint | v0,
 |  | GLint | v1
 | ) | [inline]

Replacement of glUniform2i.

This function asserts on the result before returning.

void GLUniform2iv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLint * | value
 | ) | [inline]

Replacement of glUniform2iv.

This function asserts on the result before returning.

void GLUniform2ui | ( | GLint | location,
 |  | GLuint | v0,
 |  | GLuint | v1
 | ) | [inline]

Replacement of glUniform2ui.

This function asserts on the result before returning.

void GLUniform2uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) | [inline]

Replacement of glUniform2uiv.

This function asserts on the result before returning.

void GLUniform3f | ( | GLint | location,
 |  | GLfloat | v0,
 |  | GLfloat | v1,
 |  | GLfloat | v2
 | ) | [inline]

Replacement of glUniform3f.

This function asserts on the result before returning.

void GLUniform3fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniform3fv.

This function asserts on the result before returning.

void GLUniform3i | ( | GLint | location,
 |  | GLint | v0,
 |  | GLint | v1,
 |  | GLint | v2
 | ) | [inline]

Replacement of glUniform3i.

This function asserts on the result before returning.

void GLUniform3iv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLint * | value
 | ) | [inline]

Replacement of glUniform3iv.

This function asserts on the result before returning.

void GLUniform3ui | ( | GLint | location,
 |  | GLuint | v0,
 |  | GLuint | v1,
 |  | GLuint | v2
 | ) | [inline]

Replacement of glUniform3ui.

This function asserts on the result before returning.

void GLUniform3uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) | [inline]

Replacement of glUniform3uiv.

This function asserts on the result before returning.

void GLUniform4f | ( | GLint | location,
 |  | GLfloat | v0,
 |  | GLfloat | v1,
 |  | GLfloat | v2,
 |  | GLfloat | v3
 | ) | [inline]

Replacement of glUniform4f.

This function asserts on the result before returning.

void GLUniform4fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniform4fv.

This function asserts on the result before returning.

void GLUniform4i | ( | GLint | location,
 |  | GLint | v0,
 |  | GLint | v1,
 |  | GLint | v2,
 |  | GLint | v3
 | ) | [inline]

Replacement of glUniform4i.

This function asserts on the result before returning.

void GLUniform4iv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLint * | value
 | ) | [inline]

Replacement of glUniform4iv.

This function asserts on the result before returning.

void GLUniform4ui | ( | GLint | location,
 |  | GLuint | v0,
 |  | GLuint | v1,
 |  | GLuint | v2,
 |  | GLuint | v3
 | ) | [inline]

Replacement of glUniform4ui.

This function asserts on the result before returning.

void GLUniform4uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) | [inline]

Replacement of glUniform4uiv.

This function asserts on the result before returning.

void GLUniformBuffer | ( | GLuint | program,
 |  | GLint | location,
 |  | GLuint | buffer
 | ) | [inline]

Replacement of glUniformBufferEXT.

This function asserts on the result before returning.

void GLUniformMatrix2fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix2fv.

This function asserts on the result before returning.

void GLUniformMatrix2x3fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix2x3fv.

This function asserts on the result before returning.

void GLUniformMatrix2x4fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix2x4fv.

This function asserts on the result before returning.

void GLUniformMatrix3fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix3fv.

This function asserts on the result before returning.

void GLUniformMatrix3x2fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix3x2fv.

This function asserts on the result before returning.

void GLUniformMatrix3x4fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix3x4fv.

This function asserts on the result before returning.

void GLUniformMatrix4fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix4fv.

This function asserts on the result before returning.

void GLUniformMatrix4x2fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix4x2fv.

This function asserts on the result before returning.

void GLUniformMatrix4x3fv | ( | GLint | location,
 |  | GLsizei | count,
 |  | GLboolean | transpose,
 |  | const GLfloat * | value
 | ) | [inline]

Replacement of glUniformMatrix4x3fv.

This function asserts on the result before returning.

GLboolean GLUnmapBuffer ( GLenum target ) [inline]

Replacement of glUnmapBuffer.

This function asserts on the result before returning.

void GLUseProgram ( GLuint program ) [inline]

Replacement of glUseProgram.

This function asserts on the result before returning.

void GLUseProgramObject ( GLhandleARB programObj ) [inline]

Replacement of glUseProgramObjectARB.

This function asserts on the result before returning.

void GLValidateProgram ( GLuint program ) [inline]

Replacement of glValidateProgram.

This function asserts on the result before returning.

GLboolean GLIsArraySet ( GLuint name ) [inline]

Replacement of glIsArraySetARB.

This function asserts on the result before returning.

GLboolean GLIsBuffer ( GLuint name ) [inline]

Replacement of glIsBuffer.

This function tests if for the current render context, name denotes a valid vertex buffer object.

void GLBindFragDataLocation | ( | GLuint | program,
 |  | GLuint | color,
 |  | const GLchar * | name
 | ) | [inline]

Replacement of glBindFragDataLocationEXT.

This function asserts on the result before returning.

void GLBindProgram | ( | GLenum | target,
 |  | GLuint | id
 | ) | [inline]

Replacement of glBindProgramNV.

This function hides the extension character of glBindProgramNV and asserts on the result before returning.

void GLBitmap | ( | GLsizei | width,
 |  | GLsizei | height,
 |  | GLfloat | xorig,
 |  | GLfloat | yorig,
 |  | GLfloat | xmove,
 |  | GLfloat | ymove,
 |  | const GLubyte * | bitmap
 | ) | [inline]

Replacement of glBitmap.

This function asserts on the result before returning.

void GLBlendEquation ( GLenum mode ) [inline]

Replacement of glBlendEquation.

This function asserts on the result before returning.

void GLBlendEquationSeparate | ( | GLenum | modeRGB,
 |  | GLenum | modeAlpha
 | ) | [inline]

Replacement of glBlendEquationSeparate.

This function asserts on the result before returning.

void GLBlendFunc | ( | GLenum | sfactor,
 |  | GLenum | dfactor
 | ) | [inline]

Replacement of glBlendFunc.

This function caches the blend func settings and asserts on the result before returning.

void GLResetBlendFunc ( ) [inline]

Helper function to reset the blend function.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this functions sets the blend function to the previous function. Otherwise, the blend function is set to GL_ONE for the source factor and GL_ZERO for the destination factor.
See also:
GLBlendFunc, GLBlendFuncSeparate

void GLBlendFuncSeparate | ( | GLenum | sfactorRGB,
 |  | GLenum | dfactorRGB,
 |  | GLenum | sfactorAlpha,
 |  | GLenum | dfactorAlpha
 | ) | [inline]

Replacement of glBlendFunc.

This function caches the blend func settings and asserts on the result before returning.

void GLResetBlendFuncSeparate ( ) [inline]

Helper function to reset the blend function, using the GL_EXT_blend_func_separate extention.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this functions sets the four factors of the extended blend function the previous values. Otherwise, the blend function factors are set to GL_ONE, GL_ZERO, GL_ONE, and GL_ZERO, in this order.
See also:
GLBlendFuncSeparate

void GLBlitFramebuffer | ( | GLint | srcX0,
 |  | GLint | srcY0,
 |  | GLint | srcX1,
 |  | GLint | srcY1,
 |  | GLint | dstX0,
 |  | GLint | dstY0,
 |  | GLint | dstX1,
 |  | GLint | dstY1,
 |  | GLbitfield | mask,
 |  | GLenum | filter
 | ) | [inline]

Replacement of glBlitFramebufferEXT.

Parameters:
srcX0 | source lower left X pos
srcY0 | source lower left Y pos
srcX1 | source upper right X pos
srcY1 | source upper right Y pos
dstX0 | destination lower left X pos
dstY0 | destination lower left Y pos
dstX1 | destination upper right X pos
dstY1 | destination uppoer right Y pos
mask | mask containing bits for COLOR, DEPTH, or STENCIL to blit.
filter | filter to use if src and dst are not the same size. Must be GL_NEAREST or GL_LINEAR. Must be GL_NEAREST if mask contains anything but the color buffer.
Note:
It is assumed that the extension GL_EXT_framebuffer_blit is supported.

This function asserts on no GL error.

void GLBindTexture | ( | GLenum | target,
 |  | GLuint | texture
 | ) | [inline]

Replacement of glBindTexture.

This function updates the active texture and asserts on the result before returning.

void GLCallList ( GLuint list ) [inline]

Replacement of glCallList.

This function asserts on the result before returning.

void GLCallLists | ( | GLsizei | n,
 |  | GLenum | type,
 |  | const GLvoid * | lists
 | ) | [inline]

Replacement of glCallLists.

This function asserts on the result before returning.

void GLClampColor | ( | GLenum | target,
 |  | GLenum | clamp
 | ) | [inline]

Replacement of glClampColorARB.

This function asserts on the result before returning.

void GLClear ( GLbitfield mask ) [inline]

Replacement of glClear.

This function asserts on the result before returning.

void GLClearAccum | ( | GLfloat | red,
 |  | GLfloat | green,
 |  | GLfloat | blue,
 |  | GLfloat | alpha
 | ) | [inline]

Replacement of glClearAccum.

This function asserts on the result before returning.

void GLClearColor | ( | GLclampf | red,
 |  | GLclampf | green,
 |  | GLclampf | blue,
 |  | GLclampf | alpha
 | ) | [inline]

Replacement of glClearColor.

This function caches the clear color settings and asserts on the result before returning.

void GLClearColorIi | ( | GLint | red,
 |  | GLint | green,
 |  | GLint | blue,
 |  | GLint | alpha
 | ) | [inline]

Replacement of glClearColorIiEXT.

This function asserts on the result before returning.

void GLClearColorIui | ( | GLuint | red,
 |  | GLuint | green,
 |  | GLuint | blue,
 |  | GLuint | alpha
 | ) | [inline]

Replacement of glClearColorIuiEXT.

This function asserts on the result before returning.

void GLResetClearColor ( ) [inline]

Helper function to reset the clear color.

Remarks:
if GL_SUPPORT_RESET is defined (per default, it is), this function sets the four values of the clear color to the previous value. Otherwise, they are all set to 0.0f.
See also:
GLClearColor

void GLClearDepth ( GLclampd depth ) [inline]

Replacement of glClearDepth.

This function caches the depth clear setting and asserts on the result before returning.

void GLClearDepthd ( GLdouble depth ) [inline]

Replacement of glClearDepthd.

This functions asserts on the result before returning.

void GLResetClearDepth ( ) [inline]

Helper function to reset the clear depth.

Remarks:
if ( GL_SUPPORT_RESET is defined (per default, it is), this function sets the clear depth to the previous value. Otherwise, it is set to 1.0f.
See also:
GLClearDepth

void GLClearIndex ( GLfloat c ) [inline]

Replacement of glClearIndex.

This function asserts on the result before returning.

void GLClearStencil ( GLint s ) [inline]

Replacement of glClearStencil.

This function caches the stencil clear setting and asserts on the result before returning.

void GLResetClearStencil ( ) [inline]

Helper function to reset the stencil clear value.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil clear value to the previous value. Otherwise, it is set to zero.
See also:
GLClearStencil

void GLClientActiveTexture ( GLenum texture ) [inline]

Replacement of glClientActiveTexture.

This functions caches the next active texture unit and asserts on the result before returning.

void GLClipPlane | ( | GLenum | plane,
 |  | const GLdouble * | equation
 | ) | [inline]

Replacement of glClipPlane.

This function asserts on the result before returning.

void GLResetClipPlaneEquation ( GLenum plane ) [inline]

Helper function to reset a clip plane equation.

Parameters:
plane The id of the clip plane for which the plane equation is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the clip plane equation of plane to the previous equations. Otherwise, it is set to the default plane (0,0,0,0).
See also:
GLClipPlane

void GLColor3b | ( | GLbyte | red,
 |  | GLbyte | green,
 |  | GLbyte | blue
 | ) | [inline]

Replacement of glColor3b.

This function caches the color values and asserts on the result before returning.

void GLColor3bv ( const GLbyte * v ) [inline]

Replacement of glColor3bv.

This function caches the color values and asserts on the result before returning.

void GLColor3d | ( | GLdouble | red,
 |  | GLdouble | green,
 |  | GLdouble | blue
 | ) | [inline]

Replacement of glColor3d.

This function caches the color values and asserts on the result before returning.

void GLColor3dv ( const GLdouble * v ) [inline]

Replacement of glColor3dv.

This function caches the color values and asserts on the result before returning.

void GLColor3f | ( | GLfloat | red,
 |  | GLfloat | green,
 |  | GLfloat | blue
 | ) | [inline]

Replacement of glColor3f.

This function caches the color values and asserts on the result before returning.

void GLColor3fv ( const GLfloat * v ) [inline]

Replacement of glColor3fv.

This function caches the color values and asserts on the result before returning.

void GLColor3h | ( | GLhalf | red,
 |  | GLhalf | green,
 |  | GLhalf | blue
 | ) | [inline]

Replacement of glColor3hNV.

This function asserts on the result before returning.

void GLColor3hv ( const GLhalf * v ) [inline]

Replacement of glColor3hv.

This function asserts on the result before returning.

void GLColor3i | ( | GLint | red,
 |  | GLint | green,
 |  | GLint | blue
 | ) | [inline]

Replacement of glColor3i.

This function caches the color values and asserts on the result before returning.

void GLColor3iv ( const GLint * v ) [inline]

Replacement of glColor3iv.

This function caches the color values and asserts on the result before returning.

void GLColor3s | ( | GLshort | red,
 |  | GLshort | green,
 |  | GLshort | blue
 | ) | [inline]

Replacement of glColor3s.

This function caches the color values and asserts on the result before returning.

void GLColor3sv ( const GLshort * v ) [inline]

Replacement of glColor3sv.

This function caches the color values and asserts on the result before returning.

void GLColor3ub | ( | GLubyte | red,
 |  | GLubyte | green,
 |  | GLubyte | blue
 | ) | [inline]

Replacement of glColor3ub.

This function caches the color values and asserts on the result before returning.

void GLColor3ubv ( const GLubyte * v ) [inline]

Replacement of glColor3ubv.

This function caches the color values and asserts on the result before returning.

void GLColor3ui | ( | GLuint | red,
 |  | GLuint | green,
 |  | GLuint | blue
 | ) | [inline]

Replacement of glColor3ui.

This function caches the color values and asserts on the result before returning.

void GLColor3uiv ( const GLuint * v ) [inline]

Replacement of glColor3uiv.

This function caches the color values and asserts on the result before returning.

void GLColor3us | ( | GLushort | red,
 |  | GLushort | green,
 |  | GLushort | blue
 | ) | [inline]

Replacement of glColor3us.

This function caches the color values and asserts on the result before returning.

void GLColor3usv ( const GLushort * v ) [inline]

Replacement of glColor3usv.

This function caches the color values and asserts on the result before returning.

void GLColor4b | ( | GLbyte | red,
 |  | GLbyte | green,
 |  | GLbyte | blue,
 |  | GLbyte | alpha
 | ) | [inline]

Replacement of glColor4b.

This function caches the color values and asserts on the result before returning.

void GLColor4bv ( const GLbyte * v ) [inline]

Replacement of glColor4bv.

This function caches the color values and asserts on the result before returning.

void GLColor4d | ( | GLdouble | red,
 |  | GLdouble | green,
 |  | GLdouble | blue,
 |  | GLdouble | alpha
 | ) | [inline]

Replacement of glColor4d.

This function caches the color values and asserts on the result before returning.

void GLColor4dv ( const GLdouble * v ) [inline]

Replacement of glColor4dv.

This function caches the color values and asserts on the result before returning.

void GLColor4f | ( | GLfloat | red,
 |  | GLfloat | green,
 |  | GLfloat | blue,
 |  | GLfloat | alpha
 | ) | [inline]

Replacement of glColor4f.

This function caches the color values and asserts on the result before returning.

void GLColor4fv ( const GLfloat * v ) [inline]

Replacement of glColor4fv.

This function caches the color values and asserts on the result before returning.

void GLColor4h | ( | GLhalf | red,
 |  | GLhalf | green,
 |  | GLhalf | blue,
 |  | GLhalf | alpha
 | ) | [inline]

Replacement of glColor4hNV.

This function asserts on the result before returning.

void GLColor4hv ( const GLhalf * v ) [inline]

Replacement of glColor4hv.

This function asserts on the result before returning.

void GLColor4i | ( | GLint | red,
 |  | GLint | green,
 |  | GLint | blue,
 |  | GLint | alpha
 | ) | [inline]

Replacement of glColor4i.

This function caches the color values and asserts on the result before returning.

void GLColor4iv ( const GLint * v ) [inline]

Replacement of glColor4iv.

This function caches the color values and asserts on the result before returning.

void GLColor4s | ( | GLshort | red,
 |  | GLshort | green,
 |  | GLshort | blue,
 |  | GLshort | alpha
 | ) | [inline]

Replacement of glColor4s.

This function caches the color values and asserts on the result before returning.

void GLColor4sv ( const GLshort * v ) [inline]

Replacement of glColor4sv.

This function caches the color values and asserts on the result before returning.

void GLColor4ub | ( | GLubyte | red,
 |  | GLubyte | green,
 |  | GLubyte | blue,
 |  | GLubyte | alpha
 | ) | [inline]

Replacement of glColor4ub.

This function caches the color values and asserts on the result before returning.

void GLColor4ubv ( const GLubyte * v ) [inline]

Replacement of glColor4ubv.

This function caches the color values and asserts on the result before returning.

void GLColor4ui | ( | GLuint | red,
 |  | GLuint | green,
 |  | GLuint | blue,
 |  | GLuint | alpha
 | ) | [inline]

Replacement of glColor4ui.

This function caches the color values and asserts on the result before returning.

void GLColor4uiv ( const GLuint * v ) [inline]

Replacement of glColor4uiv.

This function caches the color values and asserts on the result before returning.

void GLColor4us | ( | GLushort | red,
 |  | GLushort | green,
 |  | GLushort | blue,
 |  | GLushort | alpha
 | ) | [inline]

Replacement of glColor4us.

This function caches the color values and asserts on the result before returning.

void GLColor4usv ( const GLushort * v ) [inline]

Replacement of glColor4usv.

This function caches the color values and asserts on the result before returning.

void GLColorMask | ( | GLboolean | red,
 |  | GLboolean | green,
 |  | GLboolean | blue,
 |  | GLboolean | alpha
 | ) | [inline]

Replacement of glColorMask.

This function asserts on the result before returning.

void GLColorMaskIndexed | ( | GLuint | index,
 |  | GLboolean | r,
 |  | GLboolean | g,
 |  | GLboolean | b,
 |  | GLboolean | a
 | ) | [inline]

Replacement of glColorMaskIndexedEXT.

This functions asserts on the result before returning.

void GLResetColorMask ( ) [inline]

Helper function to reset the color mask.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the color mask to the previous mask. Otherwise, all four mask components are set to GL_TRUE.
See also:
GLColorMask

void GLColorMaterial | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [inline]

Replacement of glColorMaterial.

This function asserts on the result before returning.

void GLResetColorMaterialMode ( ) [inline]

Helper function to reset the color material mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the color material mode to the previous mode. Otherwise, it is set to GL_AMBIENT_AND_DIFFUSE for GL_FRONT_AND_BACK faces.
See also:
GLColorMaterial

void GLColorPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glColorPointer.

This function caches the color pointer settings and asserts on the result before returning.

void GLColorSubTable | ( | GLenum | target,
 |  | GLsizei | start,
 |  | GLsizei | count,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | data
 | ) | [inline]

Replacement of glColorSubTable.

This function asserts on the result before returning.

void GLColorTable | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | table
 | ) | [inline]

Replacement of glColorTable.

This function asserts on the result before returning.

void GLColorTableParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glColorTableParameterfv.

This function asserts on the result before returning.

void GLColorTableParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glColorTableParameteriv.

This function asserts on the result before returning.

void GLCombinerInput | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | variable,
 |  | GLenum | input,
 |  | GLenum | mapping,
 |  | GLenum | componentUsage
 | ) | [inline]

Replacement of glCombinerInput.

This function asserts on the result before returning.

void GLCombinerOutput | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | abOutput,
 |  | GLenum | cdOutput,
 |  | GLenum | sumOutput,
 |  | GLenum | scale,
 |  | GLenum | bias,
 |  | GLboolean | abDotProduct,
 |  | GLboolean | cdDotProduct,
 |  | GLboolean | muxSum
 | ) | [inline]

Replacement of glCombinerOutput.

This function asserts on the result before returning.

void GLCombinerParameterf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glCombinerParameterf.

This function asserts on the result before returning.

void GLCombinerParameterfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glCombinerParameterfv.

This function asserts on the result before returning.

void GLCombinerParameteri | ( | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glCombinerParameteri.

This function asserts on the result before returning.

void GLCombinerParameteriv | ( | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glCombinerParameteriv.

This function asserts on the result before returning.

void GLCombinerStageParameterfv | ( | GLenum | stage,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glCombinerStageParameterfv.

This function asserts on the result before returning.

void GLCompileShader ( GLuint shader ) [inline]

Replacement of glCompileShader.

This function asserts on the result before returning.

void GLCompressedTexImage1D | ( | GLenum | target,
 |  | int | level,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | int | border,
 |  | GLsizei | imageSize,
 |  | const void * | data
 | ) | [inline]

Replacement of glCompressedTexImage1D.

This function hides the extension character of glCompressedTexImage1D, updates the active texture, and asserts on the result before returning.

void GLCompressedTexImage2D | ( | GLenum | target,
 |  | int | level,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | int | border,
 |  | GLsizei | imageSize,
 |  | const void * | data
 | ) | [inline]

Replacement of glCompressedTexImage2D.

This function hides the extension character of glCompressedTexImage2D, updates the active texture, and asserts on the result before returning.

void GLCompressedTexImage3D | ( | GLenum | target,
 |  | int | level,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLsizei | depth,
 |  | int | border,
 |  | GLsizei | imageSize,
 |  | const void * | data
 | ) | [inline]

Replacement of glCompressedTexImage3D.

This function hides the extension character of glCompressedTexImage3D, updates the active texture, and asserts on the result before returning.

void GLCompressedTexSubImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLsizei | imageSize,
 |  | const GLvoid * | data
 | ) | [inline]

Replacement of glCompressedTexSubImage1D.

This updates the active texture and asserts on the result before returning.

void GLCompressedTexSubImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLsizei | imageSize,
 |  | const GLvoid * | data
 | ) | [inline]

Replacement of glCompressedTexSubImage2D.

This updates the active texture and asserts on the result before returning.

void GLCompressedTexSubImage3D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLint | zoffset,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLsizei | depth,
 |  | GLenum | format,
 |  | GLsizei | imageSize,
 |  | const GLvoid * | data
 | ) | [inline]

Replacement of glCompressedTexSubImage3D.

This updates the active texture and asserts on the result before returning.

void GLConvolutionFilter1D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | image
 | ) | [inline]

Replacement of glConvolutionFilter1D.

This function asserts on the result before returning.

void GLConvolutionFilter2D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | image
 | ) | [inline]

Replacement of glConvolutionFilter2D.

This function asserts on the result before returning.

void GLConvolutionParameterf | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat | params
 | ) | [inline]

Replacement of glConvolutionParameterf.

This function asserts on the result before returning.

void GLConvolutionParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glConvolutionParameterfv.

This function asserts on the result before returning.

void GLConvolutionParameteri | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint | params
 | ) | [inline]

Replacement of glConvolutionParameteri.

This function asserts on the result before returning.

void GLConvolutionParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glConvolutionParameteriv.

This function asserts on the result before returning.

void GLCopyColorSubTable | ( | GLenum | target,
 |  | GLsizei | start,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width
 | ) | [inline]

Replacement of glCopyColorSubTable.

This function asserts on the result before returning.

void GLCopyColorTable | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width
 | ) | [inline]

Replacement of glCopyColorTable.

This function asserts on the result before returning.

void GLCopyConvolutionFilter1D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width
 | ) | [inline]

Replacement of glCopyConvolutionFilter1D.

This function asserts on the result before returning.

void GLCopyConvolutionFilter2D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glCopyConvolutionFilter2D.

This function asserts on the result before returning.

void GLCopyPixels | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | type
 | ) | [inline]

Replacement of glCopyPixels.

This function asserts on the result before returning.

void GLCopyTexImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | internalFormat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLint | border
 | ) | [inline]

Replacement of glCopyTexImage1D.

This function updates the active texture and asserts on the result before returning.

void GLCopyTexImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | internalFormat,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLint | border
 | ) | [inline]

Replacement of glCopyTexImage2D.

This function updates the active texture and asserts on the result before returning.

void GLCopyTexSubImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width
 | ) | [inline]

Replacement of glCopyTexSubImage1D.

This function updates the active texture and asserts on the result before returning.

void GLCopyTexSubImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glCopyTexSubImage2D.

This function updates the active texture and asserts on the result before returning.

void GLCopyTexSubImage3D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLint | zoffset,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glCopyTexSubImage2D.

This function updates the active texture and asserts on the result before returning.

GLuint GLCreateProgram ( ) [inline]

Replacement of glCreateProgram.

This function asserts on the result before returning.

GLhandleARB GLCreateProgramObject ( ) [inline]

Replacement of glCreateProgramObjectARB.

This function asserts on the result before returning.

GLuint GLCreateShader ( GLenum type ) [inline]

Replacement of glCreateShader.

This function asserts on the result before returning.

GLhandleARB GLCreateShaderObject ( GLenum shaderType ) [inline]

Replacement of glCreateShaderObjectARB.

This function asserts on the result before returning.

void GLCullFace ( GLenum mode ) [inline]

Replacement of glCullFace.

This function caches the cull face setting and asserts on the result before returning.

void GLResetCullFaceMode ( ) [inline]

Helper function to reset the cull face mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the cull face mode to the previous mode. Otherwise, it is set to GL_BACK.
See also:
GLCullFace

void GLCullFaceLock ( GLenum mode ) [inline]

Helper function to set the cull face mode and lock it.

Parameters:
mode The cull face mode to set and lock.
Remarks:
This function sets the cull face mode and locks this state. Any subsequent calls to GLCullFace will not change that value, until the next call to GLCullFaceUnlock.
See also:
GLCullFace, GLCullFaceUnlock

void GLCullFaceUnlock ( GLenum mode ) [inline]

Helper function to unlock the cull face and set it.

Parameters:
mode The cull face mode to set, after unlocking.
Remarks:
This function unlocks the cull face mode and sets it to mode. After a call to GLCullFaceLock, this function is needed to unlock the cull face mode again.
See also:
GLCullFace, GLCullFaceLock

void GLDeleteLists | ( | GLuint | list,
 |  | GLsizei | range
 | ) | [inline]

Replacement of glDeleteLists.

This function updates some caches and asserts on the result before returning.

void GLDeleteObject ( GLhandleARB obj ) [inline]

Replacement of glDeleteObjectARB.

This function asserts on the result before returning.

void GLDeleteOcclusionQueries | ( | GLsizei | n,
 |  | const GLuint * | ids
 | ) | [inline]

Replacement of glDeleteOcclusionQueriesNV.

This function updates some caches and asserts on the result before returning.

void GLDeleteProgram ( GLuint program ) [inline]

Replacement of glDeleteProgram.

This function updates some caches and asserts on the result before returning.

void GLDeletePrograms | ( | GLsizei | n,
 |  | const GLuint * | ids
 | ) | [inline]

Replacement of glDeleteProgramsNV.

This function hides the extension character of glDeleteProgramsNV, updates some caches, and asserts on the result before returning.

void GLDeleteQueries | ( | GLsizei | n,
 |  | const GLuint * | ids
 | ) | [inline]

Replacement of glDeleteQueries.

This function updates some caches, and asserts on the result before returning.

void GLDeleteShader ( GLuint shader ) [inline]

Replacement of glDeleteShader.

This function asserts on the result before returning.

void GLDeleteTextures | ( | GLsizei | n,
 |  | const GLuint * | textures
 | ) | [inline]

Replacement of glDeleteTextures.

This function updates some caches and asserts on the result before returning.

void GLDepthBounds | ( | GLclampd | zmin,
 |  | GLclampd | zmax
 | ) | [inline]

Replacement of glDepthBounds.

This function asserts on the result before returning.

void GLDepthBoundsd | ( | GLdouble | zmin,
 |  | GLdouble | zmax
 | ) | [inline]

Replacement of glDepthBoundsd.

This function asserts on the result before returning.

void GLDepthFunc ( GLenum func ) [inline]

Replacement of glDepthFunc.

This function asserts on the result before returning.

void GLResetDepthFunc ( ) [inline]

Helper function to reset the depth func.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the depth func to the previous value. Otherwise, it is set to GL_LESS.
See also:
GLDepthFunc

void GLDepthMask ( GLboolean flag ) [inline]

Replacement of glDepthMask.

This function asserts on the result before returning.

void GLResetDepthMask ( ) [inline]

Helper function to reset the depth mask.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the depth mask to the previous value. Otherwise, it is set to GL_TRUE.
See also:
GLDepthMask

void GLDepthRange | ( | GLclampd | znear,
 |  | GLclampd | zfar
 | ) | [inline]

Replacement of glDepthRange.

This function asserts on the result before returning.

void GLDepthRanged | ( | GLdouble | zNear,
 |  | GLdouble | zFar
 | ) | [inline]

Replacement of glDepthRandedNV.

This function asserts on the result before returning.

void GLResetDepthRange ( ) [inline]

Helper function to reset the depth range.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the depth range to the previous values. Otherwise, it sets znear to 0.0 and zfar to 1.0.
See also:
GLDepthRange

void GLDetachObject | ( | GLhandleARB | containerObj,
 |  | GLhandleARB | attachedObj
 | ) | [inline]

Replacement of glDetachObjectARB.

void GLDetachShader | ( | GLuint | program,
 |  | GLuint | shader
 | ) | [inline]

Replacement of glDetachShader.

void GLDisableAlphaTest ( void ) [inline]

Cached version of GLDisable( GL_ALPHA_TEST ).

This function caches the GL_ALPHA_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_ALPHA_TEST) directly.

void GLDisableAutoNormal ( void ) [inline]

Cached version of GLDisable( GL_AUTO_NORMAL ).

This function caches the GL_AUTO_NORMAL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_AUTO_NORMAL) directly.

void GLDisableBlend ( void ) [inline]

Cached version of GLDisable( GL_BLEND ).

This function caches the GL_BLEND state. It is faster to call this method instead of calling GL[Disable|Enable](GL_BLEND) directly.

void GLDisableClipPlane ( GLenum plane ) [inline]

Cached version of GLDisable( GL_CLIP_PLANEi ).

This function caches the GL_CLIP_PLANEi state. It is faster to call this method instead of calling GL[Disable|Enable](GL_CLIP_PLANEi) directly.

void GLDisableColorLogicOp ( void ) [inline]

Cached version of GLDisable( GL_COLOR_LOGIC_OP ).

This function caches the GL_COLOR_LOGIC_OP state. It is faster to call this method instead of calling GL[Disable|Enable](GL_COLOR_LOGIC_OP) directly.

void GLDisableColorMaterial ( void ) [inline]

Cached version of GLDisable( GL_COLOR_MATERIAL ).

This function caches the GL_COLOR_MATERIAL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_COLOR_MATERIAL) directly.

void GLDisableCullFace ( void ) [inline]

Cached version of GLDisable( GL_CULL_FACE ).

This function is caches the GL_CULL_FACE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_CULL_FACE) directly.

void GLDisableCullFaceLock ( void ) [inline]

Helper function to disable the cull face and lock it.

Remarks:
This function disables face culling and locks it. Any subsequent calls to GLEnableCullFace, GLDisableCullFace, GLEnable(GL_CULL_FACE), or GLDisable(GL_CULL_FACE) will not change that setting, until the next call to GLDisableCullFaceUnlock or GLEnableCullFaceUnlock.
See also:
GLDisableCullFace, GLDisableCullFaceUnlock, GLEnableCullFaceLock

void GLDisableCullFaceUnlock ( void ) [inline]

Helper function to unlock the cull face and set it.

Remarks:
This function unlocks face culling and disables it.
See also:
GLDisableCullFace, GLDisableCullFaceLock, GLEnableCullFaceUnlock

void GLDisableDepthTest ( void ) [inline]

Cached version of GLDisable( GL_DEPTH_TEST ).

This function caches the GL_DEPTH_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_DEPTH_TEST) directly.

void GLDisableDither ( void ) [inline]

Cached version of GLDisable( GL_DITHER ).

This function caches the GL_DITHER state. It is faster to call this method instead of calling GL[Disable|Enable](GL_DITHER) directly.

void GLDisableFog ( void ) [inline]

Cached version of GLDisable( GL_FOG ).

This function caches the GL_DITHER state. It is faster to call this method instead of calling GL[Disable|Enable](GL_FOG) directly.

void GLDisableIndexed | ( | GLenum | target,
 |  | GLuint | index
 | ) | [inline]

Replacement of glDiableIndexed.

This functions asserts on the result before returning.

void GLDisableLight ( GLenum light ) [inline]

Cached version of GLDisable( GL_LIGHTi ).

This function caches the GL_LIGHTi state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LIGHTi) directly.

void GLDisableLighting ( void ) [inline]

Cached version of GLDisable( GL_LIGHTING ).

This function is caches the GL_LIGHTING state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LIGHTING) directly.

void GLDisableLightingLock ( void ) [inline]

Helper function to disable lighting and lock it.

Remarks:
This function disables lighting and locks it. Any subsequent calls to GLEnableLighting, GLDisableLighting, GLEnable(GL_LIGHTING), or GLDisable(GL_LIGHTING) will not change that setting, until the next call to GLDisableLightingUnlock or GLEnableLightingUnlock.
See also:
GLDisableLighting, GLDisableLightingUnlock, GLEnableLightingLock

void GLDisableLightingUnlock ( void ) [inline]

Helper function to unlock the lighting and disable it.

Remarks:
This function unlocks lighting and disables it.
See also:
GLDisableLighting, GLDisableLightingLock, GLEnableLightingUnlock

void GLDisableLineSmooth ( void ) [inline]

Cached version of GLDisable( GL_LINE_SMOOTH ).

This function is caches the GL_LINE_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LINE_SMOOTH) directly.

void GLDisableLineStipple ( void ) [inline]

Cached version of GLDisable( GL_LINE_STIPPLE ).

This function is caches the GL_LINE_STIPPLE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LINE_STIPPLE) directly.

void GLDisableLogicOp ( void ) [inline]

Cached version of GLDisable( GL_LOGIC_OP ).

This function caches the GL_LOGIC_OP state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LOGIC_OP) directly.

void GLDisableNormalize ( void ) [inline]

Cached version of GLDisable( GL_NORMALIZE ).

This function is caches the GL_NORMALIZE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_NORMALIZE) directly.

void GLDisablePointSmooth ( void ) [inline]

Cached version of GLDisable( GL_POINT_SMOOTH ).

This function is caches the GL_POINT_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POINT_SMOOTH) directly.

void GLDisablePolygonOffsetFill ( void ) [inline]

Cached version of GLDisable( GL_POLYGON_OFFSET_FILL ).

This function is caches the GL_POLYGON_OFFSET_FILL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_FILL) directly.

void GLDisablePolygonOffsetLine ( void ) [inline]

Cached version of GLDisable( GL_POLYGON_OFFSET_LINE ).

This function is caches the GL_POLYGON_OFFSET_LINE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_LINE) directly.

void GLDisablePolygonOffsetPoint ( void ) [inline]

Cached version of GLDisable( GL_POLYGON_OFFSET_POINT ).

This function is caches the GL_POLYGON_OFFSET_POINT state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_POINT) directly.

void GLDisablePolygonSmooth ( void ) [inline]

Cached version of GLDisable( GL_POLYGON_SMOOTH ).

This function caches the GL_POLYGON_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_SMOOTH) directly.

void GLDisablePolygonStipple ( void ) [inline]

Cached version of GLDisable( GL_POLYGON_STIPPLE ).

This function is caches the GL_POLYGON_STIPPLE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_STIPPLE) directly.

void GLDisableScissorTest ( void ) [inline]

Cached version of GLDisable( GL_SCISSOR_TEST ).

This function caches the GL_SCISSOR_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_SCISSOR_TEST) directly.

void GLDisableStencilTest ( void ) [inline]

Cached version of GLDisable( GL_STENCIL_TEST ).

This function caches the GL_STENCIL_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_STENCIL_TEST) directly.

void GLDisableTexture ( GLenum target ) [inline]

This function caches the texture target type per texture unit. It is faster to call this method instead of calling GL[Disable|Enable]( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ) directly.

void GLDisableTextureGen ( GLenum target ) [inline]

Cached version of GLDisable( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

This function caches the texture generation type per texture unit. It is faster to call this method instead of calling GL[Disable|Enable]( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ) directly.

void GLDisable ( GLenum cap ) [inline]

Replacement of glDisable.

This function caches on some cap values and asserts on the result before returning.

void GLDisableColorArray ( void ) [inline]

Cached version of GLDisableClientState( GL_COLOR_ARRAY ).

This function caches the GL_COLOR_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_COLOR_ARRAY ) directly.

void GLDisableFogCoordinateArray ( void ) [inline]

Cached version of GLDisableClientState( GL_FOG_COORDINATE_ARRAY ).

This function caches the GL_FOG_COORDINATE_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_FOG_COORDINATE_ARRAY ) directly.

void GLDisableNormalArray ( void ) [inline]

Cached version of GLDisableClientState( GL_NORMAL_ARRAY ).

This function caches the GL_NORMAL_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_NORMAL_ARRAY ) directly.

void GLDisableSecondaryColorArray ( void ) [inline]

Cached version of GLDisableClientState( GL_SECONDARY_COLOR_ARRAY ).

This function caches the GL_SECONDARY_COLOR_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_SECONDARY_COLOR_ARRAY ) directly.

void GLDisableTextureCoordArray ( void ) [inline]

Cached version of GLDisableClientState( GL_TEXTURE_COORD_ARRAY ).

This function caches the GL_TEXTURE_COORD_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_TEXTURE_COORD_ARRAY ) directly.

void GLDisableVertexArray ( void ) [inline]

Cached version of GLDisableClientState( GL_VERTEX_ARRAY ).

This function caches the GL_VERTEX_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_VERTEX_ARRAY ) directly.

void GLDisableClientState ( GLenum array ) [inline]

Replacement of glDisableClientState.

This function caches on some cap values and asserts on the result before returning.

void GLDisableVertexAttribArray ( GLuint index ) [inline]

Replacement of glDisableVertexAttribArray.

void GLDrawArrays | ( | GLenum | mode,
 |  | GLint | first,
 |  | GLsizei | count
 | ) | [inline]

Replacement of glDrawArrays.

This function asserts on the result before returning.

void GLDrawArraysInstanced | ( | GLenum | mode,
 |  | GLint | start,
 |  | GLsizei | count,
 |  | GLsizei | primcount
 | ) | [inline]

Replacement of glDrawArraysInstancedEXT.

This function asserts on the result before returning.

void GLDrawBuffer ( GLenum mode ) [inline]

Replacement of glDrawBuffer.

This function asserts on the result before returning.

void GLDrawBuffers | ( | GLsizei | n,
 |  | const GLenum * | bufs
 | ) | [inline]

Replacement of glDrawBuffersARB.

This function asserts on the result before returning.

void GLDrawElements | ( | GLenum | mode,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices
 | ) | [inline]

Replacement of glDrawElements.

This function asserts on the result before returning.

void GLDrawElementsInstanced | ( | GLenum | mode,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices,
 |  | GLsizei | primcount
 | ) | [inline]

Replacement of glDrawElementsInstancedEXT.

This function asserts on the result before returning.

void GLMultiDrawArrays | ( | GLenum | mode,
 |  | const GLint * | first,
 |  | const GLsizei * | count,
 |  | GLsizei | primcount
 | ) | [inline]

Replacement of glMultiDrawArrays.

This function asserts on the result before returning.

void GLMultiDrawElements | ( | GLenum | mode,
 |  | const GLsizei * | count,
 |  | GLenum | type,
 |  | const GLvoid ** | indices,
 |  | GLsizei | primcount
 | ) | [inline]

Replacement of glMultiDrawElements.

This function asserts on the result before returning.

void GLDrawPixels | ( | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [inline]

Replacement of glDrawPixels.

This function asserts on the result before returning.

void GLDrawRangeElements | ( | GLenum | mode,
 |  | GLuint | start,
 |  | GLuint | end,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices
 | ) | [inline]

Replacement of glDrawRangeElements.

This function asserts on the result before returning.

void GLEdgeFlagPointer | ( | GLsizei | stride,
 |  | const GLboolean * | pointer
 | ) | [inline]

Replacement of glEdgeFlagPointer.

This function asserts on the result before returning.

void GLEdgeFlag ( GLboolean flag ) [inline]

Replacement of glEdgeFlag.

This function asserts on the result before returning.

void GLEdgeFlagv ( const GLboolean * flag ) [inline]

Replacement of glEdgeFlagv.

This function asserts on the result before returning.

void GLEnableAlphaTest ( void ) [inline]

Cached version of GLEnable( GL_ALPHA_TEST ).

This function caches the GL_ALPHA_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_ALPHA_TEST) directly.

void GLResetAlphaTest ( ) [inline]

Helper function to reset the enable state of the alpha test.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the alpha test state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableAlphaTest, GLEnableAlphaTest, GLDisable, GLEnable

void GLEnableAutoNormal ( void ) [inline]

Cached version of GLEnable( GL_AUTO_NORMAL ).

This function caches the GL_AUTO_NORMAL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_AUTO_NORMAL) directly.

void GLResetAutoNormal ( ) [inline]

Helper function to reset the enable state of the auto normal calculation.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the auto normal state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableAutoNormal, GLEnableAutoNormal, GLDisable, GLEnable

void GLEnableBlend ( void ) [inline]

Cached version of GLEnable( GL_BLEND ).

This function caches the GL_BLEND state. It is faster to call this method instead of calling GL[Disable|Enable](GL_BLEND) directly.

void GLResetBlend ( ) [inline]

Helper function to reset the enable state of the blending.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the blending state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableBlend, GLEnableBlend, GLDisable, GLEnable

void GLEnableClipPlane ( GLenum plane ) [inline]

Cached version of GLEnable( GL_CLIP_PLANEi ).

This function caches the GL_CLIP_PLANEi state. It is faster to call this method instead of calling GL[Disable|Enable](GL_CLIP_PLANEi) directly.

void GLResetClipPlane ( GLenum plane ) [inline]

Helper function to reset the enable state of the clip plane plane.

Parameters:
plane The id of the plane for which the the enable state is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the clip plane state for plane to it's previous state. Otherwise, it is disabled.
See also:
GLDisableClipPlane, GLEnableClipPlane, GLDisable, GLEnable

void GLEnableColorLogicOp ( void ) [inline]

Cached version of GLEnable( GL_COLOR_LOGIC_OP ).

This function caches the GL_COLOR_LOGIC_OP state. It is faster to call this method instead of calling GL[Disable|Enable](GL_COLOR_LOGIC_OP) directly.

void GLResetColorLogicOp ( ) [inline]

Helper function to reset the enable state of the color logic operation.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the color logic operation state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableColorLogicOp, GLEnableColorLogicOp, GLDisable, GLEnable

void GLEnableColorMaterial ( void ) [inline]

Cached version of GLEnable( GL_COLOR_MATERIAL ).

This function caches the GL_COLOR_MATERIAL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_COLOR_MATERIAL) directly.

void GLResetColorMaterial ( ) [inline]

Helper function to reset the enable state of the color material.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the color material state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableColorMaterial, GLEnableColorMaterial, GLDisable, GLEnable

void GLEnableCullFace ( void ) [inline]

Cached version of GLEnable( GL_CULL_FACE ).

This function caches the GL_CULL_FACE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_CULL_FACE) directly.

void GLResetCullFace ( ) [inline]

Helper function to reset the enable state of face culling.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the face culling state to it's previous state. Otherwise, it is enabled. Note, that this enabling face culling by default is NVSG specific and not like in OpenGL.
See also:
GLDisableCullFace, GLEnableCullFace, GLDisable, GLEnable

void GLEnableCullFaceLock ( void ) [inline]

Helper function to enable face culling and lock it.

Remarks:
This function enables face culling and locks it. Any subsequent calls to GLEnableCullFace, GLDisableCullFace, GLEnable(GL_CULL_FACE), or GLDisable(GL_CULL_FACE) will not change that setting, until the next call to GLEnableCullFaceUnlock or GLDisableCullFaceUnlock.
See also:
GLEnableCullFace, GLDisableCullFaceUnlock, GLEnableCullFaceUnlock

void GLEnableCullFaceUnlock ( void ) [inline]

Helper function to unlock the face culling and enable it.

Remarks:
This function unlocks face culling and enables it.
See also:
GLEnableCullFace, GLEnableCullFaceLock, GLDisableCullFaceUnlock

void GLEnableDepthTest ( void ) [inline]

Cached version of GLEnable( GL_DEPTH_TEST ).

This function caches the GL_DEPTH_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_DEPTH_TEST) directly.

void GLResetDepthTest ( ) [inline]

Helper function to reset the enable state of depth testing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the depth test state to it's previous state. Otherwise, it is enabled. Note, that this enabling depth test by default is NVSG specific and not like in OpenGL.
See also:
GLDisableDepthTest, GLEnableDepthTest, GLDisable, GLEnable

void GLEnableDither ( void ) [inline]

Cached version of GLEnable( GL_DITHER ).

This function caches the GL_DITHER state. It is faster to call this method instead of calling GL[Disable|Enable](GL_DITHER) directly.

void GLResetDither ( ) [inline]

Helper function to reset the enable state of dithering.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the dither state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableDither, GLEnableDither, GLDisable, GLEnable

void GLEnableFog ( void ) [inline]

Cached version of GLEnable( GL_FOG ).

This function caches the GL_DITHER state. It is faster to call this method instead of calling GL[Disable|Enable](GL_FOG) directly.

void GLResetFog ( ) [inline]

Helper function to reset the the enable state of fogging.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableFog, GLEnableFog, GLDisable, GLEnable

void GLEnableIndexed | ( | GLenum | target,
 |  | GLuint | index
 | ) | [inline]

Replacement of glEnabledIndexed.

This functions asserts on the result before returning.

void GLEnableLight ( GLenum light ) [inline]

Cached version of GLEnable( GL_LIGHTi ).

This function caches the GL_LIGHTi state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LIGHTi) directly.

void GLResetLight ( GLenum light ) [inline]

Helper function to reset the enable state of the light light.

Parameters:
light The id of the light for which the enable state is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the light state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLight, GLEnableLight, GLDisable, GLEnable

void GLEnableLighting ( void ) [inline]

Cached version of GLEnable( GL_LIGHTING ).

This function caches the GL_LIGHTING state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LIGHTING) directly.

void GLResetLighting ( ) [inline]

Helper function to reset the enable state of lighting.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the lighting state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLighting, GLEnableLighting, GLDisable, GLEnable

void GLEnableLineSmooth ( void ) [inline]

Cached version of GLEnable( GL_LINE_SMOOTH ).

This function caches the GL_LINE_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LINE_SMOOTH) directly.

void GLResetLineSmooth ( ) [inline]

Helper function to reset the enable state of line smoothing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the line smoothing state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLineSmooth, GLEnableLineSmooth, GLDisable, GLEnable

void GLEnableLineStipple ( void ) [inline]

Cached version of GLEnable( GL_LINE_STIPPLE ).

This function caches the GL_LINE_STIPPLE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LINE_STIPPLE) directly.

void GLResetLineStipple ( ) [inline]

Helper function to reset the enable state of line stippling.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the line stippling state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLineStipple, GLEnableLineStipple, GLDisable, GLEnable

void GLEnableLogicOp ( void ) [inline]

Cached version of GLEnable( GL_LOGIC_OP ).

This function caches the GL_LOGIC_OP state. It is faster to call this method instead of calling GL[Disable|Enable](GL_LOGIC_OP) directly.

void GLResetLogicOp ( ) [inline]

Helper function to reset the enable state of logic operation.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the logic operation state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableLogicOp, GLEnableLogicOp, GLDisable, GLEnable

void GLEnableNormalize ( void ) [inline]

Cached version of GLEnable( GL_NORMALIZE ).

This function caches the GL_NORMALIZE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_NORMALIZE) directly.

void GLResetNormalize ( ) [inline]

Helper function to reset the enable state of normalizing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the normalize state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableNormalize, GLEnableNormalize, GLDisable, GLEnable

void GLEnablePointSmooth ( void ) [inline]

Cached version of GLEnable( GL_POINT_SMOOTH ).

This function caches the GL_POINT_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POINT_SMOOTH) directly.

void GLResetPointSmooth ( ) [inline]

Helper function to reset the enable state of point smoothing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the point smoothing state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePointSmooth, GLEnablePointSmooth, GLDisable, GLEnable

void GLEnablePolygonOffsetFill ( void ) [inline]

Cached version of GLEnable( GL_POLYGON_OFFSET_FILL ).

This function caches the GL_POLYGON_OFFSET_FILL state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_FILL) directly.

void GLResetPolygonOffsetFill ( ) [inline]

Helper function to reset the enable state of filled polygon offset.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon offset fill state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonOffsetFill, GLEnablePolygonOffsetFill, GLDisable, GLEnable

void GLEnablePolygonOffsetLine ( void ) [inline]

Cached version of GLEnable( GL_POLYGON_OFFSET_LINE ).

This function caches the GL_POLYGON_OFFSET_LINE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_LINE) directly.

void GLResetPolygonOffsetLine ( ) [inline]

Helper function to reset the enable state of lined polygon offset.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon offset line state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonOffsetLine, GLEnablePolygonOffsetLine, GLDisable, GLEnable

void GLEnablePolygonOffsetPoint ( void ) [inline]

Cached version of GLEnable( GL_POLYGON_OFFSET_POINT ).

This function caches the GL_POLYGON_OFFSET_POINT state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_OFFSET_POINT) directly.

void GLResetPolygonOffsetPoint ( ) [inline]

Helper function to reset the enable state of pointed polygon offset.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon offset point state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonOffsetPoint, GLEnablePolygonOffsetPoint, GLDisable, GLEnable

void GLEnablePolygonSmooth ( void ) [inline]

Cached version of GLEnable( GL_POLYGON_SMOOTH ).

This function caches the GL_POLYGON_SMOOTH state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_SMOOTH) directly.

void GLResetPolygonSmooth ( ) [inline]

Helper function to reset the enable state of polygon smoothing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon smooth state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonSmooth, GLEnablePolygonSmooth, GLDisable, GLEnable

void GLEnablePolygonStipple ( void ) [inline]

Cached version of GLEnable( GL_POLYGON_STIPPLE ).

This function caches the GL_POLYGON_STIPPLE state. It is faster to call this method instead of calling GL[Disable|Enable](GL_POLYGON_STIPPLE) directly.

void GLResetPolygonStipple ( ) [inline]

Helper function to reset the enable state of polygon stippling.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon stippling state to it's previous state. Otherwise, it is disabled.
See also:
GLDisablePolygonStipple, GLEnablePolygonStipple, GLDisable, GLEnable

void GLEnableScissorTest ( void ) [inline]

Cached version of GLEnable( GL_SCISSOR_TEST ).

This function caches the GL_SCISSOR_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_SCISSOR_TEST) directly.

void GLResetScissorTest ( ) [inline]

Helper function to reset the enable state of scissor testing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the scissor test state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableScissorTest, GLEnableScissorTest, GLDisable, GLEnable

void GLEnableStencilTest ( void ) [inline]

Cached version of GLEnable( GL_STENCIL_TEST ).

This function caches the GL_STENCIL_TEST state. It is faster to call this method instead of calling GL[Disable|Enable](GL_STENCIL_TEST) directly.

void GLResetStencilTest ( ) [inline]

Helper function to reset the enable state of stencil testing.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil test state to it's previous state. Otherwise, it is disabled.
See also:
GLDisableStencilTest, GLEnableStencilTest, GLDisable, GLEnable

void GLEnableTexture ( GLenum target ) [inline]

This function caches the texture target type per texture unit. It is faster to call this method instead of calling GL[Disable|Enable]( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ) directly.

void GLResetTexture ( GLenum target ) [inline]

Helper function to reset the enable state of texture target target.

Parameters:
target The texture target for which the enable state has to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the texture target target to it's previous state. Otherwise, it is disabled.
See also:
GLDisableTexture, GLEnableTexture, GLDisable, GLEnable

void GLEnableTextureGen ( GLenum target ) [inline]

Cached version of GLEnable( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

This function caches the texture generation type per texture unit. It is faster to call this method instead of calling GL[Disable|Enable]( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ) directly.

void GLEnable ( GLenum cap ) [inline]

Replacement of glEnable.

This function caches on some cap values and asserts on the result before returning.

void GLEnableColorArray ( void ) [inline]

Cached version of GLEnableClientState( GL_COLOR_ARRAY ).

This function caches the GL_COLOR_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_COLOR_ARRAY ) directly.

void GLEnableFogCoordinateArray ( void ) [inline]

Cached version of GLEnableClientState( GL_FOG_COORDINATE_ARRAY ).

This function caches the GL_FOG_COORDINATE_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_FOG_COORDINATE_ARRAY ) directly.

void GLEnableNormalArray ( void ) [inline]

Cached version of GLEnableClientState( GL_NORMAL_ARRAY ).

This function caches the GL_NORMAL_ARRAY client state. PIt is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_NORMAL_ARRAY ) directly.

void GLEnableSecondaryColorArray ( void ) [inline]

Cached version of GLEnableClientState( GL_SECONDARY_COLOR_ARRAY ).

This function caches the GL_SECONDARY_COLOR_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_SECONDARY_COLOR_ARRAY ) directly.

void GLEnableTextureCoordArray ( void ) [inline]

Cached version of GLEnableClientState( GL_TEXTURE_COORD_ARRAY ).

This function caches the GL_TEXTURE_COORD_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_TEXTURE_COORD_ARRAY ) directly.

void GLEnableVertexArray ( void ) [inline]

Cached version of GLEnableClientState( GL_VERTEX_ARRAY ).

This function caches the GL_VERTEX_ARRAY client state. It is faster to call this method instead of calling GL[Disable|Enable]ClientState( GL_VERTEX_ARRAY ) directly.

void GLEnableClientState ( GLenum array ) [inline]

Replacement of glEnableClientState.

This function caches on some cap values and asserts on the result before returning.

void GLEnableVertexAttribArray ( GLuint index ) [inline]

Replacement of glEnableVertexAttribArray.

void GLEnd ( void ) [inline]

Replacement of glEnd.

This function asserts on the result before returning.

void GLEndList ( void ) [inline]

Replacement of glEndList.

This function asserts on the result before returning.

void GLEndOcclusionQuery ( void ) [inline]

Replacement of glEndOcclusionQueryNV.

This function asserts on the result before returning.

void GLEndQuery ( GLenum target ) [inline]

Replacement of glEndQuery.

This function asserts on the result before returning.

void GLEndTransformFeedback ( ) [inline]

Replacement of glEndTransformFeedbackNV.

This function asserts on the result before returning.

void GLEvalCoord1d ( GLdouble u ) [inline]

Replacement of glEvalCoord1d.

This function asserts on the result before returning.

void GLEvalCoord1f ( GLfloat u ) [inline]

Replacement of glEvalCoord1f.

This function asserts on the result before returning.

void GLEvalCoord2d | ( | GLdouble | u,
 |  | GLdouble | v
 | ) | [inline]

Replacement of glEvalCoord2d.

This function asserts on the result before returning.

void GLEvalCoord2f | ( | GLfloat | u,
 |  | GLfloat | v
 | ) | [inline]

Replacement of glEvalCoord2f.

This function asserts on the result before returning.

void GLEvalMesh1 | ( | GLenum | mode,
 |  | GLint | i1,
 |  | GLint | i2
 | ) | [inline]

Replacement of glEvalMesh1.

This function asserts on the result before returning.

void GLEvalMesh2 | ( | GLenum | mode,
 |  | GLint | i1,
 |  | GLint | i2,
 |  | GLint | j1,
 |  | GLint | j2
 | ) | [inline]

Replacement of glEvalMesh2.

This function asserts on the result before returning.

void GLEvalPoint1 ( GLint i ) [inline]

Replacement of glEvalPoint1.

This function asserts on the result before returning.

void GLEvalPoint2 | ( | GLint | i,
 |  | GLint | j
 | ) | [inline]

Replacement of glEvalPoint2.

This function asserts on the result before returning.

void GLExecuteProgram | ( | GLenum | target,
 |  | GLuint | id,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glExecuteProgramNV.

This function asserts on the result before returning.

void GLFeedbackBuffer | ( | GLsizei | size,
 |  | GLenum | type,
 |  | GLfloat * | buffer
 | ) | [inline]

Replacement of glFeedbackBuffer.

This function asserts on the result before returning.

void GLFinalCombinerInput | ( | GLenum | variable,
 |  | GLenum | input,
 |  | GLenum | mapping,
 |  | GLenum | componentUsage
 | ) | [inline]

Replacement of glFinalCombinerInput.

This function asserts on the result before returning.

void GLFinish ( void ) [inline]

Replacement of glFinish.

This function asserts on the result before returning.

void GLFinishFence ( GLuint fence ) [inline]

Replacement of glFinishFenceNV.

void GLFlush ( void ) [inline]

Replacement of glFlush.

This function asserts on the result before returning.

void GLFlushPixelDataRange ( GLenum target ) [inline]

Replacement of glFlushPixelDataRangeNV.

This functions asserts on the result before returning.

void GLFlushVertexArrayRange ( ) [inline]

Replacement of glFlushVertexArrayRange.

This functions asserts on the result before returning.

void GLFogColor ( const GLfloat * color ) [inline]

Cached version of GLFog[fv|iv]( GL_FOG_COLOR, params ).

This function caches the GL_FOG_COLOR value. It is faster to call this method instead of GLFog[fv|iv]( GL_FOG_COLOR, params ) directly.

void GLResetFogColor ( ) [inline]

Helper function to reset the fog color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog color to it's previous state. Otherwise, it is set to (0,0,0,0).
See also:
GLFogColor

void GLFogCoordd ( GLdouble fog ) [inline]

Replacement of glFogCoordd.

This function asserts on the result before returning.

void GLFogCoorddv ( const GLdouble * fog ) [inline]

Replacement of glFogCoorddv.

This function asserts on the result before returning.

void GLFogCoordf ( GLfloat fog ) [inline]

Replacement of glFogCoordf.

This function asserts on the result before returning.

void GLFogCoordfv ( const GLfloat * fog ) [inline]

Replacement of glFogCoordfv.

This function asserts on the result before returning.

void GLFogCoordh ( GLhalf fog ) [inline]

Replacement of glFogCoordh.

This function asserts on the result before returning.

void GLFogCoordhv ( const GLhalf * fog ) [inline]

Replacement of glFogCoordhv.

This function asserts on the result before returning.

void GLFogCoordPointer | ( | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glFogCoordPointer.

This function caches the fog coordinate pointer setting and asserts on the result before returning.

void GLFogDensity ( GLfloat density ) [inline]

Cached version of GLFog[f|fv|i|iv]( GL_FOG_DENSITY, param[s] ).

This function caches the GL_FOG_DENSITY value. It is faster to call this method instead of GLFog[f|fv|i|iv]( GL_FOG_MODE, param[s] ) directly.

void GLResetFogDensity ( ) [inline]

Helper function to reset the fog density.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog density to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLFogDensity

void GLFogEnd ( GLfloat end ) [inline]

Cached version of GLFog[f|fv|i|iv]( GL_FOG_END, param[s] ).

This function caches the GL_FOG_END value. It is faster to call this method instead of GLFog[f|fv|i|iv]( GL_FOG_END, param[s] ) directly.

void GLResetFogEnd ( ) [inline]

Helper function to reset the fog end value.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog end value to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLFogDensity

void GLFogf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glFogf.

This function asserts on the result before returning.

void GLFogfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glFogfv.

This function asserts on the result before returning.

void GLFogi | ( | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glFogi.

This function asserts on the result before returning.

void GLFogiv | ( | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glFogiv.

This function asserts on the result before returning.

void GLFogMode ( GLenum mode ) [inline]

Cached version of GLFog[f|fv|i|iv]( GL_FOG_MODE, param[s] ).

This function caches the GL_FOG_MODE value. It is faster to call this method instead of GLFog[f|fv|i|iv]( GL_FOG_MODE, param[s] ) directly.

void GLResetFogMode ( ) [inline]

Helper function to reset the fog mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog mode to it's previous state. Otherwise, it is set to GL_EXP.
See also:
GLFogMode

void GLFogStart ( GLfloat start ) [inline]

Cached version of GLFog[f|fv|i|iv]( GL_FOG_START, param[s] ).

This function caches the GL_FOG_START value. It is faster to call this method instead of GLFog[f|fv|i|iv]( GL_FOG_START, param[s] ) directly.

void GLResetFogStart ( ) [inline]

Helper function to reset the fog start value.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the fog start value to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLFogStart

void GLFramebufferTexture | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level
 | ) | [inline]

Replacement of glFramebufferTextureEXT.

This function asserts on the result before returning.

void GLFramebufferTextureFace | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLenum | face
 | ) | [inline]

Replacement of glFramebufferTextureFaceEXT.

This function asserts on the result before returning.

void GLFrontFace ( GLenum mode ) [inline]

Replacement of glFrontFace.

This function caches the front face setting and asserts on the result before returning.

void GLResetFrontFace ( ) [inline]

Helper function to reset the front face state.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the front face state to it's previous state. Otherwise, it is set to GL_CCW.
See also:
GLFrontFace

void GLFrustum | ( | GLdouble | left,
 |  | GLdouble | right,
 |  | GLdouble | bottom,
 |  | GLdouble | top,
 |  | GLdouble | zNear,
 |  | GLdouble | zFar
 | ) | [inline]

Replacement of glFrustum.

This function asserts on the result before returning.

GLuint GLGenLists ( GLsizei range ) [inline]

Replacement of glGenLists.

This function asserts on the result and updates some caches.

void GLGenOcclusionQueries | ( | GLsizei | n,
 |  | GLuint * | ids
 | ) | [inline]

Replacement of glGenOcclusionQueriesNV.

This function asserts on the result, and updates some caches.

void GLGenPrograms | ( | GLsizei | n,
 |  | GLuint * | ids
 | ) | [inline]

Replacement of glGenProgramsNV.

This function hides the extension character of glGenProgramsNV and asserts on the result, and updates some caches.

void GLGenQueries | ( | GLsizei | n,
 |  | GLuint * | ids
 | ) | [inline]

Replacement of glGenQueries.

This function asserts on the result, and updates some caches.

void GLGenTextures | ( | GLsizei | n,
 |  | GLuint * | textures
 | ) | [inline]

Replacement of glGenTextures.

This function asserts on the result and updates some caches.

void GLGetActiveAttrib | ( | GLuint | program,
 |  | GLuint | index,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLsizei * | size,
 |  | GLenum * | type,
 |  | GLchar * | name
 | ) | [inline]

Replacement of glGetActiveAttrib.

This function asserts on the result before returning.

void GLGetActiveUniform | ( | GLuint | program,
 |  | GLuint | index,
 |  | GLsizei | maxLength,
 |  | GLsizei * | length,
 |  | GLsizei * | size,
 |  | GLenum * | type,
 |  | GLcharARB * | name
 | ) | [inline]

Replacement of glGetActiveUniform.

This function asserts on the result before returning.

void GLGetActiveVarying | ( | GLuint | program,
 |  | GLuint | index,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLsizei * | size,
 |  | GLenum * | type,
 |  | GLchar * | name
 | ) | [inline]

Replacement of glGetActiveVaryingNV.

This function asserts on the result before returning.

void GLGetAttachedObjects | ( | GLhandleARB | containerObj,
 |  | GLsizei | maxCount,
 |  | GLsizei * | count,
 |  | GLhandleARB * | obj
 | ) | [inline]

Replacement of glGetAttachedObjectsARB.

This function asserts on the result before returning.

void GLGetAttachedShaders | ( | GLuint | program,
 |  | GLsizei | maxCount,
 |  | GLsizei * | count,
 |  | GLuint * | shaders
 | ) | [inline]

Replacement of glGetAttachedShaders.

This function asserts on the result before returning.

GLint GLGetAttribLocation | ( | GLuint | program,
 |  | const GLchar * | name
 | ) | [inline]

Replacement of glGetAttribLocation.

This function asserts on the result before returning.

void GLGetBooleanv | ( | GLenum | pname,
 |  | GLboolean * | params
 | ) | [inline]

Replacement of glGetBooleanv.

This function asserts on the result before returning.

void GLGetBooleanIndexedv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLboolean * | data
 | ) | [inline]

Replacement of glGetBooleanIndexedvEXT.

This function asserts on the result before returning.

void GLGetColorTable | ( | GLenum | target,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | table
 | ) | [inline]

Replacement of glGetColorTable.

This function asserts on the result before returning.

void GLGetColorTableParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetColorTableParameterfv.

This function asserts on the result before returning.

void GLGetColorTableParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetColorTableParameteriv.

This function asserts on the result before returning.

void GLGetCombinerInputParameterfv | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | variable,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetCombinerInputParameterfv.

This function asserts on the result before returning.

void GLGetCombinerInputParameteriv | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | variable,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetCombinerInputParameteriv.

This function asserts on the result before returning.

void GLGetCombinerOutputParameterfv | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetCombinerOutputParameterfv.

This function asserts on the result before returning.

void GLGetCombinerOutputParameteriv | ( | GLenum | stage,
 |  | GLenum | portion,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetCombinerOutputParameteriv.

This function asserts on the result before returning.

void GLGetCombinerStageParameterfv | ( | GLenum | stage,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetCombinerStageParameterfv.

This function asserts on the result before returning.

void GLGetCompressedTexImage | ( | GLenum | target,
 |  | GLint | lod,
 |  | GLvoid * | img
 | ) | [inline]

Replacement of glGetCompressedTexImage.

This function asserts on the result before returning.

void GLGetConvolutionFilter | ( | GLenum | target,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | image
 | ) | [inline]

Replacement of glGetConvolutionFilter.

This function asserts on the result before returning.

void GLGetConvolutionParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetConvolutionParameterfv.

This function asserts on the result before returning.

void GLGetConvolutionParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetConvolutionParameteriv.

This function asserts on the result before returning.

void GLGetDoublev | ( | GLenum | pname,
 |  | GLdouble * | params
 | ) | [inline]

Replacement of glGetDoublev.

This function asserts on the result before returning.

void GLGetFenceiv | ( | GLuint | fence,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetFenceivNV.

This function asserts on the result before returning.

void GLGetFinalCombinerInputParameterfv | ( | GLenum | variable,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetFinalCombinerInputParamterfv.

This function asserts on the result before returning.

void GLGetFinalCombinerInputParameteriv | ( | GLenum | variable,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetFinalCombinerInputParamteriv.

This function asserts on the result before returning.

void GLGetFloatv | ( | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetFloatv.

This function asserts on the result before returning.

GLint GLGetFragDataLocation | ( | GLuint | program,
 |  | const GLchar * | name
 | ) | [inline]

Replacement of glGetFragDataLocationEXT.

This function asserts on the result before returning.

GLhandleARB GLGetHandle ( GLenum pname ) [inline]

Replacement of glGetHandleARB.

This function asserts on the result before returning.

void GLGetHistogram | ( | GLenum | target,
 |  | GLboolean | reset,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | values
 | ) | [inline]

Replacement of glGetHistogram.

This function asserts on the result before returning.

void GLGetHistogramParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetHistogramParameterfv.

This function asserts on the result before returning.

void GLGetHistogramParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetHistogramParameteriv.

This function asserts on the result before returning.

void GLGetInfoLog | ( | GLhandleARB | obj,
 |  | GLsizei | maxLength,
 |  | GLsizei * | length,
 |  | GLcharARB * | infoLog
 | ) | [inline]

Replacement of glGetInfoLogARB.

This function asserts on the result before returning.

void GLGetIntegerv | ( | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetIntegerv.

This function asserts on the result before returning.

void GLGetIntegerIndexedv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint * | data
 | ) | [inline]

Replacement of glGetIntegerIndexedvEXT.

This function asserts on the result before returning.

void GLGetBufferParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetBufferParameteriv.

This function asserts on the result before returning.

void GLGetBufferPointerv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLvoid ** | params
 | ) | [inline]

Replacement of glGetBufferPointerv.

This function asserts on the result before returning.

void GLGetBufferSubData | ( | GLenum | target,
 |  | GLintptrARB | offset,
 |  | GLsizeiptrARB | size,
 |  | GLvoid * | data
 | ) | [inline]

Replacement of glGetBufferSubData.

This function asserts on the result before returning.

void GLGetClipPlane | ( | GLenum | plane,
 |  | GLdouble * | equation
 | ) | [inline]

Replacement of glGetClipPlane.

This function asserts on the result before returning.

void GLGetLightfv | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetLightfv.

This function asserts on the result before returning.

void GLGetLightiv | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetLightiv.

This function asserts on the result before returning.

void GLGetMapdv | ( | GLenum | target,
 |  | GLenum | query,
 |  | GLdouble * | v
 | ) | [inline]

Replacement of glGetMapdv.

This function asserts on the result before returning.

void GLGetMapfv | ( | GLenum | target,
 |  | GLenum | query,
 |  | GLfloat * | v
 | ) | [inline]

Replacement of glGetMapfv.

This function asserts on the result before returning.

void GLGetMapiv | ( | GLenum | target,
 |  | GLenum | query,
 |  | GLint * | v
 | ) | [inline]

Replacement of glGetMapiv.

This function asserts on the result before returning.

void GLGetMaterialfv | ( | GLenum | face,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetMaterialfv.

This function asserts on the result before returning.

void GLGetMaterialiv | ( | GLenum | face,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetMaterialiv.

This function asserts on the result before returning.

GLint GLGetMaxTexCoords ( void ) [inline]

Get the maximal number of texture coordinate slots.

GLint GLGetMaxTexUnits ( void ) [inline]

Get the maximal number of texture units.

GLint GLGetMaxTexImageUnits ( void ) [inline]

Get the maximal number of texture image units.

void GLGetMinmax | ( | GLenum | target,
 |  | GLboolean | reset,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | values
 | ) | [inline]

Replacement of glGetMinmax.

This function asserts on the result before returning.

void GLGetMinmaxParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetMinmaxParameterfv.

This function asserts on the result before returning.

void GLGetMinmaxParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetMinmaxParameteriv.

This function asserts on the result before returning.

void GLGetObjectParameterfv | ( | GLhandleARB | obj,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetObjectParameterfvARB.

This function asserts on the result before returning.

void GLGetObjectParameteriv | ( | GLhandleARB | obj,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetObjectParameterivARB.

This function asserts on the result before returning.

void GLGetOcclusionQueryiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetOcclusionQueryivNV.

This function asserts on the result before returning.

void GLGetOcclusionQueryuiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetOcclusionQueryuivNV.

This function asserts on the result before returning.

void GLGetPixelMapfv | ( | GLenum | map,
 |  | GLfloat * | values
 | ) | [inline]

Replacement of glGetPixelMapfv.

This function asserts on the result before returning.

void GLGetPixelMapuiv | ( | GLenum | map,
 |  | GLuint * | values
 | ) | [inline]

Replacement of glGetPixelMapuiv.

This function asserts on the result before returning.

void GLGetPixelMapusv | ( | GLenum | map,
 |  | GLushort * | values
 | ) | [inline]

Replacement of glGetPixelMapusv.

This function asserts on the result before returning.

void GLGetPointerv | ( | GLenum | pname,
 |  | GLvoid ** | params
 | ) | [inline]

Replacement of glGetPointerv.

This function asserts on the result before returning.

void GLGetPolygonStipple ( GLubyte * mask ) [inline]

Replacement of glGetPolygonStipple.

This function asserts on the result before returning.

void GLGetProgramEnvParameterdv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble * | params
 | ) | [inline]

Replacement of glGetProgramEnvParameterdvARB.

This function asserts on the result before returning.

void GLGetProgramEnvParameterfv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetProgramEnvParameterfvARB.

This function asserts on the result before returning.

void GLGetProgramiv | ( | GLuint | program,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetProgramiv.

This function asserts on the result before returning.

void GLGetProgramLocalParameterdv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble * | params
 | ) | [inline]

Replacement of glGetProgramLocalParameterdvARB.

This function asserts on the result before returning.

void GLGetProgramLocalParameterfv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetProgramLocalParameterfvARB.

This function asserts on the result before returning.

void GLGetProgramInfoLog | ( | GLuint | program,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLchar * | infoLog
 | ) | [inline]

Replacement of glGetProgramInfoLog.

This function asserts on the result before returning.

void GLGetProgramEnvParameterIiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetProgramEnvParameterIivNV.

This function asserts on the result before returning.

void GLGetProgramEnvParameterIuiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetProgramEnvParameterIuivNV.

This function asserts on the result before returning.

void GLGetProgramLocalParameterIiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetProgramLocalParameterIivNV.

This function asserts on the result before returning.

void GLGetProgramLocalParameterIuiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetProgramLocalParameterIuivNV.

This function asserts on the result before returning.

void GLGetProgramNamedParameterdv | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLdouble * | params
 | ) | [inline]

Replacement of glGetProgramNamedParameterdvNV.

This function asserts on the result before returning.

void GLGetProgramNamedParameterfv | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetProgramNamedParameterfvNV.

This function asserts on the result before returning.

void GLGetProgramParameterdv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLenum | pname,
 |  | GLdouble * | params
 | ) | [inline]

Replacement of glGetProgramParameterdvNV.

This function asserts on the result before returning.

void GLGetProgramParameterfv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetProgramParameterfvNV.

This function asserts on the result before returning.

void GLGetProgramString | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLubyte * | program
 | ) | [inline]

Replacement of glGetProgramStringNV.

This function asserts on the result before returning.

void GLGetQueryiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetQueryiv.

This function asserts on the result before returning.

void GLGetQueryObjecti64v | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLint64EXT * | params
 | ) | [inline]

Replacement of glGetQueryObjecti64vEXT.

This function asserts on the result before returning.

void GLGetQueryObjectiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetQueryObjectiv.

This function asserts on the result before returning.

void GLGetQueryObjectui64v | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint64EXT * | params
 | ) | [inline]

Replacement of glGetQueryObjectui64vEXT.

This function asserts on the result before returning.

void GLGetQueryObjectuiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetQueryObjectuiv.

This function asserts on the result before returning.

void GLGetSeparableFilter | ( | GLenum | target,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | row,
 |  | GLvoid * | column,
 |  | GLvoid * | span
 | ) | [inline]

Replacement of glGetSeparableFilter.

This asserts on the result before returning.

void GLGetShaderiv | ( | GLuint | shader,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetShaderiv.

This asserts on the result before returning.

void GLGetShaderInfoLog | ( | GLuint | shader,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLchar * | infoLog
 | ) | [inline]

Replacement of glGetShaderInfoLog.

This asserts on the result before returning.

void GLGetShaderSource | ( | GLuint | shader,
 |  | GLsizei | bufSize,
 |  | GLsizei * | length,
 |  | GLcharARB * | source
 | ) | [inline]

Replacement of glGetShaderSource.

This asserts on the result before returning.

const GLubyte* GLGetString ( GLenum name ) [inline]

Replacement of glGetString.

This function asserts on the result before returning.

void GLGetTexEnvfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetTexEnvfv.

This function asserts on the result before returning.

void GLGetTexEnviv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetTexEnviv.

This function asserts on the result before returning.

void GLGetTexGendv | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLdouble * | params
 | ) | [inline]

Replacement of glGetTexGendv.

This function asserts on the result before returning.

void GLGetTexGenfv | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetTexGenfv.

This function asserts on the result before returning.

void GLGetTexGeniv | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetTexGeniv.

This function asserts on the result before returning.

void GLGetTexImage | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | pixels
 | ) | [inline]

Replacement of glGetTexImage.

This function updates the active texture and asserts on the result before returning.

void GLGetTexLevelParameterfv | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetTexLevelParameterfv.

This function asserts on the result before returning.

void GLGetTexLevelParameteriv | ( | GLenum | target,
 |  | GLint | level,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetTexLevelParameteriv.

This function asserts on the result before returning.

void GLGetTexParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetTexParameterfv.

This function asserts on the result before returning.

void GLGetTexParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetTexParameteriv.

This function asserts on the result before returning.

void GLGetTexParameterIiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetTexParameterIivEXT.

This function asserts on the result before returning.

void GLGetTexParameterIuiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetTexParameterIuivEXT.

This function asserts on the result before returning.

void GLGetTrackMatrixiv | ( | GLenum | target,
 |  | GLuint | address,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetTrackMatrixivNV.

This function asserts on the result before returning.

void GLGetTransformFeedbackVarying | ( | GLuint | program,
 |  | GLuint | index,
 |  | GLint * | location
 | ) | [inline]

Replacement of glGetTransformFeedbackVaryingNV.

This function asserts on the result before returning.

void GLGetUniformfv | ( | GLuint | program,
 |  | GLint | location,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetUniformfv.

This function asserts on the result before returning.

void GLGetUniformiv | ( | GLuint | program,
 |  | GLint | location,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetUniformiv.

This function asserts on the result before returning.

void GLGetUniformuiv | ( | GLuint | program,
 |  | GLint | location,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetUniformuiv.

This function asserts on the result before returning.

GLint GLGetUniformBufferSize | ( | GLuint | program,
 |  | GLint | location
 | ) | [inline]

Replacement of glGetUniformBufferSizeEXT.

This function asserts on the result before returning.

GLint GLGetUniformLocation | ( | GLuint | program,
 |  | const GLcharARB * | name
 | ) | [inline]

Replacement of glGetUniformLocation.

This function asserts on the result before returning.

GLintptr GLGetUniformOffset | ( | GLuint | program,
 |  | GLint | location
 | ) | [inline]

Replacement of glGetUniformOffsetEXT.

This function asserts on the result before returning.

GLint GLGetVaryingLocation | ( | GLuint | program,
 |  | const GLchar * | name
 | ) | [inline]

Replacement of glGetVaryingLocationNV.

This function asserts on the result before returning.

void GLGetVertexAttribdv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLdouble * | params
 | ) | [inline]

Replacement of glGetVertexAttribdv.

This function asserts on the result before returning.

void GLGetVertexAttribfv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetVertexAttribfv.

This function asserts on the result before returning.

void GLGetVertexAttribiv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetVertexAttribiv.

This function asserts on the result before returning.

void GLGetVertexAttribIiv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetVertexAttribIivEXT.

This function asserts on the result before returning.

void GLGetVertexAttribIuiv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetVertexAttribIuivEXT.

This function asserts on the result before returning.

void GLGetVertexAttribPointerv | ( | GLuint | index,
 |  | GLenum | pname,
 |  | GLvoid ** | pointer
 | ) | [inline]

Replacement of glGetVertexAttribPointer.

This function asserts on the result before returning.

void GLHint | ( | GLenum | target,
 |  | GLenum | mode
 | ) | [inline]

Replacement of glHint.

This function asserts on the result before returning.

void GLHistogram | ( | GLenum | target,
 |  | GLsizei | width,
 |  | GLenum | internalformat,
 |  | GLboolean | sink
 | ) | [inline]

Replacement of glHistogram.

This function asserts on the result before returning.

void GLIndexd ( GLdouble c ) [inline]

Replacement of glIndexd.

This function asserts on the result before returning.

void GLIndexf ( GLfloat c ) [inline]

Replacement of glIndexf.

This function asserts on the result before returning.

void GLIndexi ( GLint c ) [inline]

Replacement of glIndexi.

This function asserts on the result before returning.

void GLIndexMask ( GLuint mask ) [inline]

Replacement of glIndexMask.

This function asserts on the result before returning.

void GLIndexPointer | ( | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glIndexPointer.

This function asserts on the result before returning.

void GLIndexs ( GLshort c ) [inline]

Replacement of glIndexs.

This function asserts on the result before returning.

void GLIndexub ( GLubyte c ) [inline]

Replacement of glIndexub.

This function asserts on the result before returning.

void GLInitNames ( void ) [inline]

Replacement of glInitNames.

This function asserts on the result before returning.

void GLInterleavedArrays | ( | GLenum | format,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glInterleavedArrays.

This function asserts on the result before returning.

GLboolean GLIsEnabled ( GLenum cap ) [inline]

Replacement of glIsEnabled.

This function returns the state of the queried capability.

GLboolean GLIsEnabledAlphaTest ( ) [inline]

Replacement of glIsEnabled( GL_ALPHA_TEST ).

This function returns the state of the GL_ALPHA_TEST capability.

GLboolean GLIsEnabledAutoNormal ( ) [inline]

Replacement of glIsEnabled( GL_AUTO_NORMAL ).

This function returns the state of the GL_AUTO_NORMAL capability.

GLboolean GLIsEnabledBlend ( ) [inline]

Replacement of glIsEnabled( GL_BLEND ).

This function returns the state of the GL_BLEND capability.

GLboolean GLIsEnabledClipPlane ( GLenum plane ) [inline]

Replacement of glIsEnabled( GL_CLIP_PLANEi ).

This function returns the state of the GL_CLIP_PLANEi capability.

GLboolean GLIsEnabledColorLogicOp ( ) [inline]

Replacement of glIsEnabled( GL_COLOR_LOGIC_OP ).

This function returns the state of the GL_COLOR_LOGIC_OP capability.

GLboolean GLIsEnabledColorMaterial ( ) [inline]

Replacement of glIsEnabled( GL_COLOR_MATERIAL ).

This function returns the state of the GL_COLOR_MATERIAL capability.

GLboolean GLIsEnabledCullFace ( ) [inline]

Replacement of glIsEnabled( GL_CULL_FACE ).

This function returns the state of the GL_CULL_FACE capability.

GLboolean GLIsEnabledDepthTest ( ) [inline]

Replacement of glIsEnabled( GL_DEPTH_TEST ).

This function returns the state of the GL_DEPTH_TEST capability.

GLboolean GLIsEnabledDither ( ) [inline]

Replacement of glIsEnabled( GL_DITHER ).

This function returns the state of the GL_DITHER capability.

GLboolean GLIsEnabledFog ( ) [inline]

Replacement of glIsEnabled( GL_FOG ).

This function returns the state of the GL_FOG capability.

GLboolean GLIsEnabledIndexed | ( | GLenum | target,
 |  | GLuint | index
 | ) | [inline]

Replacement of glIsEnabledIndexed.

This functions asserts on the result before returning.

GLboolean GLIsEnabledLight ( GLenum light ) [inline]

Replacement of glIsEnabled( GL_LIGHTi ).

This function returns the state of the GL_LIGHTi capability.

GLboolean GLIsEnabledLighting ( ) [inline]

Replacement of glIsEnabled( GL_LIGHTING ).

This function returns the state of the GL_LIGHTING capability.

GLboolean GLIsEnabledLineSmooth ( ) [inline]

Replacement of glIsEnabled( GL_LINE_SMOOTH ).

This function returns the state of the GL_LINE_SMOOTH capability.

GLboolean GLIsEnabledLineStipple ( ) [inline]

Replacement of glIsEnabled( GL_LINE_STIPPLE ).

This function returns the state of the GL_LINE_STIPPLE capability.

GLboolean GLIsEnabledLogicOp ( ) [inline]

Replacement of glIsEnabled( GL_LOGIC_OP ).

This function returns the state of the GL_LOGIC_OP capability.

GLboolean GLIsEnabledNormalize ( ) [inline]

Replacement of glIsEnabled( GL_NORMALIZE ).

This function returns the state of the GL_NORMALIZE capability.

GLboolean GLIsEnabledPointSmooth ( ) [inline]

Replacement of glIsEnabled( GL_POINT_SMOOTH ).

This function returns the state of the GL_POINT_SMOOTH capability.

GLboolean GLIsEnabledPolygonOffsetFill ( ) [inline]

Replacement of glIsEnabled( GL_POLYGON_OFFSET_FILL ).

This function returns the state of the GL_POLYGON_OFFSET_FILL capability.

GLboolean GLIsEnabledPolygonOffsetLine ( ) [inline]

Replacement of glIsEnabled( GL_POLYGON_OFFSET_LINE ).

This function returns the state of the GL_POLYGON_OFFSET_LINE capability.

GLboolean GLIsEnabledPolygonOffsetPoint ( ) [inline]

Replacement of glIsEnabled( GL_POLYGON_OFFSET_POINT ).

This function returns the state of the GL_POLYGON_OFFSET_POINT capability.

GLboolean GLIsEnabledPolygonSmooth ( ) [inline]

Replacement of glIsEnabled( GL_POLYGON_SMOOTH ).

This function returns the state of the GL_POLYGON_SMOOTH capability.

GLboolean GLIsEnabledPolygonStipple ( ) [inline]

Replacement of glIsEnabled( GL_POLYGON_STIPPLE ).

This function returns the state of the GL_POLYGON_STIPPLE capability.

GLboolean GLIsEnabledScissorTest ( ) [inline]

Replacement of glIsEnabled( GL_SCISSOR_TEST ).

This function returns the state of the GL_SCISSOR_TEST capability.

GLboolean GLIsEnabledStencilTest ( ) [inline]

Replacement of glIsEnabled( GL_STENCIL_TEST ).

This function returns the state of the GL_STENCIL_TEST capability.

GLboolean GLIsEnabledTexture ( GLenum target ) [inline]

Replacement of glIsEnabled( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

This function returns the state of the [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] capability.

GLboolean GLIsEnabledTextureGen ( GLenum target ) [inline]

Replacement of glIsEnabled( [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] ).

This function returns the state of the [GL_TEXTURE_GEN_S|GL_TEXTURE_GEN_T|GL_TEXTURE_GEN_R|GL_TEXTURE_GEN_Q] capability.

GLint GLGetVersion ( ) [inline]

Returns the version of the OpenGL available on the target system.

Returns:
The floating point version of the OpenGL with the representation major.minor is returned as an integer calculated as 10*major+minor.

The OpenGL version 1.4, for example, will be reported as 14.

GLboolean GLIsExtensionAvailable ( const std::string & extension ) [inline]

Test if a given extension is available on the current context.

Note:
Not all exported extensions might be available.
Returns:
true, if all functions of extension are available, otherwise false

GLboolean GLIsExtensionExported ( const std::string & extension ) [inline]

Test if a given extension is exported on the current context.

Note:
Not all exported extensions might be available.
Returns:
true, if extension is exported, otherwise false

GLboolean GLIsFence ( GLuint fence ) [inline]

Replacement of glIsFenceNV.

This function asserts on the result before returning.

GLboolean GLIsList ( GLuint list ) [inline]

Replacement of glIsList.

This function tests if for the current context, list denotes a valid display list and asserts on the result before returning.

GLboolean GLIsOcclusionQuery ( GLuint id ) [inline]

Replacement of glIsOcclusionQueryNV.

This function tests if for the current context, id denotes a valid query and asserts on the result before returning.

GLboolean GLIsProgram ( GLuint program ) [inline]

Replacement of glIsProgram.

This function tests if for the current context, id denotes a valid program and asserts on the result before returning.

GLboolean GLIsQuery ( GLuint id ) [inline]

Replacement of glIsQuery.

This function tests if for the current context, id denotes a valid query and asserts on the result before returning.

GLboolean GLIsShader ( GLuint shader ) [inline]

Replacement of glIsShader.

This function asserts on the result before returning.

GLboolean GLIsTexture ( GLuint texture ) [inline]

Replacement of glIsTexture.

This function tests if for the current context, texture denotes a valid texture and asserts on the result before returning.

void GLLightAmbient | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLLightfv( light, GL_AMBIENT, param ).

This function caches the GL_AMBIENT value on the light. It is faster to call this method instead of GLLightfv( light, GL_AMBIENT, param ) directly.

void GLResetLightAmbient ( GLenum light ) [inline]

Helper function to reset the ambient light color.

Parameters:
light The id of the light for which the ambient color is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the ambient light to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLLightAmbient

void GLLightConstantAttenuation | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [inline]

Cached version of GLLightf( light, GL_CONSTANT_ATTENUATION, param ).

This function caches the GL_CONSTANT_ATTENUATION value on the light. It is faster to call this method instead of GLLightf( light, GL_CONSTANT_ATTENUATION, param ) directly.

void GLResetLightConstantAttenuation ( GLenum light ) [inline]

Helper function to reset the constant attenuation of the light light.

Parameters:
light The id of the light for which the constant attenuation is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the constant attenuation of the light light to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLLightConstantAttenuation

void GLLightDiffuse | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLLightfv( light, GL_DIFFUSE, param ).

This function caches the GL_DIFFUSE value on the light. It is faster to call this method instead of GLLightfv( light, GL_DIFFUSE, param ) directly.

void GLResetLightDiffuse ( GLenum light ) [inline]

Helper function to reset the diffuse color of the light light.

Parameters:
light The id of the light for which the diffuse color is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the diffuse lighting to it's previous state. Otherwise, it is set to (1,1,1,1) if light is GL_LIGHT0, or (0,0,0,1) otherwise.
See also:
GLLightDiffuse

void GLLightLinearAttenuation | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [inline]

Cached version of GLLightf( light, GL_LINEAR_ATTENUATION, param ).

This function caches the GL_LINEAR_ATTENUATION value on the light. It is faster to call this method instead of GLLightf( light, GL_LINEAR_ATTENUATION, param ) directly.

void GLResetLightLinearAttenuation ( GLenum light ) [inline]

Helper function to reset the linear attenuation of the light light.

Parameters:
light The id of the light for which the linear attenuation is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the linear attenuation of the light light to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLLightLinearAttenuation

void GLLightPosition | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLLightfv( light, GL_POSITION, param ).

The light position is not cached, and it should not be. This function just exists for completeness.

void GLResetLightPosition ( GLenum light ) [inline]

Helper function to reset the position of the light light.

Parameters:
light The id of the light for which the position is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the position of the light light to it's previous state. Otherwise, it is set to (0,0,1,0).
See also:
GLLightPosition

void GLLightQuadraticAttenuation | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [inline]

Cached version of GLLightf( light, GL_QUADRATIC_ATTENUATION, param ).

This function caches the GL_QUADRATIC_ATTENUATION value on the light. It is faster to call this method instead of GLLightf( light, GL_QUADRATIC_ATTENUATION, param ) directly.

void GLResetLightQuadraticAttenuation ( GLenum light ) [inline]

Helper function to reset the quadratic attenuation of the light light.

Parameters:
light The id of the light for which the quadratic attenuation is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the quadratic attenuation of the light light to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLLightQuadraticAttenuation

void GLLightSpecular | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLLightfv( light, GL_SPECULAR, param ).

This function caches the GL_SPECULAR value on the light. It is faster to call this method instead of GLLightfv( light, GL_SPECULAR, param ) directly.

void GLResetLightSpecular ( GLenum light ) [inline]

Helper function to reset the specular color of the light light.

Parameters:
light The id of the light for which the specular color is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the specular color of the light light to it's previous state. Otherwise, it is set to (1,1,1,1) if light is GL_LIGHT0, or (0,0,0,1) otherwise.
See also:
GLLightSpecular

void GLLightSpotCutoff | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [inline]

Cached version of GLLightf( light, GL_SPOT_CUTOFF, param ).

This function caches the GL_SPOT_CUTOFF value on the light. It is faster to call this method instead of GLLightf( light, GL_SPOT_CUTOFF, param ) directly.

void GLResetLightSpotCutoff ( GLenum light ) [inline]

Helper function to reset the spot cutoff of the light light.

Parameters:
light The id of the light for which the spot cutoff is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the spot cutoff of the light light to it's previous state. Otherwise, it is set to 180.0f.
See also:
GLLightSpotCutoff

void GLLightSpotDirection | ( | GLenum | light,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLLightfv( light, GL_SPOT_DIRECTION, param ).

The light spot direction is not cached, and it should not be. This function just exists for completeness.

void GLResetLightSpotDirection ( GLenum light ) [inline]

Helper function to reset the spot cutoff of the light light.

Parameters:
light The id of the light for which the spot cutoff is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the spot cutoff of the light light to it's previous state. Otherwise, it is set to 180.0f.
See also:
GLLightSpotCutoff

void GLLightSpotExponent | ( | GLenum | light,
 |  | GLfloat | param
 | ) | [inline]

Cached version of GLLightf( light, GL_SPOT_EXPONENT, param ).

This function caches the GL_SPOT_EXPONENT value on the light. It is faster to call this method instead of GLLightf( light, GL_SPOT_EXPONENT, param ) directly.

void GLResetLightSpotExponent ( GLenum light ) [inline]

Helper function to reset the spot exponent of the light light.

Parameters:
light The id of the light for which the spot exponent is to be reset.
Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the spot exponent of the light light to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLLightSpotExponent

void GLLightf | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glLightf.

This function caches on some pname values and asserts on the result.

void GLLightfv | ( | GLenum | light,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glLightfv.

This function caches on some pname values and asserts on the result.

void GLLighti | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glLighti.

This function caches on some pname values and asserts on the result.

void GLintToGLfloat | ( | const GLint * | params,
 |  | GLfloat * | fParams
 | ) | [inline]

Convert GLInt to GLFloat.

void GLLightiv | ( | GLenum | light,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glLightiv.

This function caches on some pname values and asserts on the result.

void GLLightModelAmbient ( const GLfloat * params ) [inline]

Replacement of glLightModelfv( GL_LIGHT_MODEL_AMBIENT, params ).

This function caches the light model settings and asserts on the result before returning.

void GLResetLightModelAmbient ( ) [inline]

Helper function to reset the ambient light color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the ambient light color to it's previous state. Otherwise, it is set to (0.2,0.2,0.2,1.0).
See also:
GLLightSpotExponent

void GLLightModelLocalViewer ( GLint param ) [inline]

Replacement of GLLightModelLocalViewer.

This function caches the light model settings and asserts on the result before returning.

void GLResetLightModelLocalViewer ( ) [inline]

Helper function to reset the local viewer setting.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the local viewer to it's previous state. Otherwise, it is set to GL_FALSE.
See also:
GLLightModelLocalViewer

void GLLightModelTwoSide ( GLint param ) [inline]

Replacement of GLLightModelTwoSide.

This function caches the light model settings and asserts on the result before returning.

void GLResetLightModelTwoSide ( ) [inline]

Helper function to reset the two sided lighting state.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the two sided lighting to it's previous state. Otherwise, it is set to GL_FALSE.
See also:
GLLightModelTwoSide

void GLLightModelTwoSideLock ( GLint param ) [inline]

Helper function to set two sided lighting and lock it.

Parameters:
param The value to set and lock two sided lighting to.
Remarks:
This function sets two sided lighting to param and locks it. Any subsequent calls to GLLightModelTwoSide or GLLightModel{if}(GL_LIGHT_MODEL_TWO_SIDE,) will not change that setting, until the next call to GLLightModelTwoSideUnlock.
See also:
GLLightModelTwoSide, GLLightModelTwoSideUnlock

void GLLightModelTwoSideUnlock ( GLint param ) [inline]

Helper function to unlock the two sided lighting and set it.

Parameters:
param The value to set the unlocked two sided lighting to.
Remarks:
This function unlocks two sided lighting and sets it to param.
See also:
GLLightModelTwoSide, GLLightModelTwoSideLock

void GLLightModelf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glLightModelf.

This function caches some of the light model settings and asserts on the result before returning.

void GLLightModelfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glLightModelfv.

This function caches some the light model settings and asserts on the result before returning.

void GLLightModeli | ( | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glLightModeli.

This function caches some of the light model settings and asserts on the result before returning.

void GLLightModeliv | ( | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glLightModeliv.

This function caches some of the light model settings and asserts on the result before returning.

void GLLineStipple | ( | GLint | factor,
 |  | GLushort | pattern
 | ) | [inline]

Replacement of glLineStipple.

This function caches the line stipple settings and asserts on the result before returning.

void GLResetLineStippleDefinition ( ) [inline]

Helper function to reset line stipple repeat and pattern.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the line stipple repeat and pattern to it's previous state. Otherwise, it is set to 1 and 0xFFFF, respectively.
See also:
GLLineStipple

void GLLineWidth ( GLfloat width ) [inline]

Replacement of glLineWidth.

This function caches the line width setting and asserts on the result before returning.

void GLResetLineWidth ( ) [inline]

Helper function to reset the line width.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the line width to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLLineWidth

void GLLinkProgram ( GLuint program ) [inline]

Replacement of glLinkProgram.

This function asserts on the result before returning.

void GLListBase ( GLuint base ) [inline]

Replacement of glListBase.

This function asserts on the result before returning.

void GLLoadIdentity ( void ) [inline]

Replacement of glLoadItentity.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLLoadMatrixd ( const GLdouble * m ) [inline]

Replacement of glLoadMatrixd.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLLoadMatrixf ( const GLfloat * m ) [inline]

Replacement of glLoadMatrixf.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLLoadTransposedMatrixd ( const GLdouble * m ) [inline]

Replacement of glLoadTransposeMatrixd.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLLoadTransposeMatrixf ( const GLfloat * m ) [inline]

Replacement of glLoadTransposMatrixf.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLLoadName ( GLuint name ) [inline]

Replacement of glLoadName.

This function asserts on the result before returning.

void GLLoadProgram | ( | GLenum | target,
 |  | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | program
 | ) | [inline]

Replacement of glLoadProgramNV.

This function hides the extension character of glLoadProgramNV and asserts on the result before returning.

void GLLockArrays | ( | GLint | first,
 |  | GLsizei | count
 | ) | [inline]

Replacement of glLockArrays.

This function asserts on the result before returning.

void GLLogicOp ( GLenum opcode ) [inline]

Replacement of glLogicOp.

This function asserts on the result before returning.

void GLMap1d | ( | GLenum | target,
 |  | GLdouble | u1,
 |  | GLdouble | u2,
 |  | GLint | stride,
 |  | GLint | order,
 |  | const GLdouble * | points
 | ) | [inline]

Replacement of glMap1d.

This function asserts on the result before returning.

void GLMap1f | ( | GLenum | target,
 |  | GLfloat | u1,
 |  | GLfloat | u2,
 |  | GLint | stride,
 |  | GLint | order,
 |  | const GLfloat * | points
 | ) | [inline]

Replacement of glMap1f.

This function asserts on the result before returning.

void GLMap2d | ( | GLenum | target,
 |  | GLdouble | u1,
 |  | GLdouble | u2,
 |  | GLint | ustride,
 |  | GLint | uorder,
 |  | GLdouble | v1,
 |  | GLdouble | v2,
 |  | GLint | vstride,
 |  | GLint | vorder,
 |  | const GLdouble * | points
 | ) | [inline]

Replacement of glMap2d.

This function asserts on the result before returning.

void GLMap2f | ( | GLenum | target,
 |  | GLfloat | u1,
 |  | GLfloat | u2,
 |  | GLint | ustride,
 |  | GLint | uorder,
 |  | GLfloat | v1,
 |  | GLfloat | v2,
 |  | GLint | vstride,
 |  | GLint | vorder,
 |  | const GLfloat * | points
 | ) | [inline]

Replacement of glMap2f.

This function asserts on the result before returning.

void GLMapGrid1d | ( | GLint | un,
 |  | GLdouble | u1,
 |  | GLdouble | u2
 | ) | [inline]

Replacement of glMapGrid1d.

This function asserts on the result before returning.

void GLMapGrid1f | ( | GLint | un,
 |  | GLfloat | u1,
 |  | GLfloat | u2
 | ) | [inline]

Replacement of glMapGrid1f.

This function asserts on the result before returning.

void GLMapGrid2d | ( | GLint | un,
 |  | GLdouble | u1,
 |  | GLdouble | u2,
 |  | GLint | vn,
 |  | GLdouble | v1,
 |  | GLdouble | v2
 | ) | [inline]

Replacement of glMapGrid2d.

This function asserts on the result before returning.

void GLMapGrid2f | ( | GLint | un,
 |  | GLfloat | u1,
 |  | GLfloat | u2,
 |  | GLint | vn,
 |  | GLfloat | v1,
 |  | GLfloat | v2
 | ) | [inline]

Replacement of glMapGrid2f.

This function asserts on the result before returning.

void GLMaterialShininessBack ( GLfloat param ) [inline]

Cached version of GLMaterialf( GL_BACK, GL_SHININESS, param ).

This function caches the GL_SHININESS value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_SHININESS, param ) directly.

void GLResetMaterialShininessBack ( ) [inline]

Helper function to reset the material back face shininess.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face shininess to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLMaterialShininessBack

void GLMaterialShininessFront ( GLfloat param ) [inline]

Cached version of GLMaterialf( GL_FRONT, GL_SHININESS, param ).

This function caches the GL_SHININESS value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_SHININESS, param ) directly.

void GLResetMaterialShininessFront ( ) [inline]

Helper function to reset the material front face shininess.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face shininess to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLMaterialShininessFront

void GLMaterialShininessFrontAndBack ( GLfloat param ) [inline]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, param ).

This function caches the GL_SHININESS value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, param ) directly.

void GLResetMaterialShininessFrontAndBack ( ) [inline]

Helper function to reset the material back and front face shininess.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face shininess to it's previous state. Otherwise, it is set to 0.0f.
See also:
GLMaterialShininessFrontAndBack

void GLMaterialShininess | ( | GLenum | face,
 |  | GLfloat | param
 | ) | [inline]

Cached version of GLMaterialf( face, GL_SHININESS, param ).

This function caches the GL_SHININESS value of the material. It is faster to call this method instead of GLMaterialf(face,GL_SHININESS,param) directly.

void GLMaterialAmbientBack ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_BACK, GL_AMBIENT, param ).

This function caches the GL_AMBIENT value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_AMBIENT, param ) directly.

void GLResetMaterialAmbientBack ( ) [inline]

Helper function to reset the material back face ambient color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face ambient color to it's previous state. Otherwise, it is set to (0.2,0.2,0.2,1.0).
See also:
GLMaterialAmbientBack

void GLMaterialAmbientFront ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_FRONT, GL_AMBIENT, param ).

This function caches the GL_AMBIENT value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_AMBIENT, param ) directly.

void GLResetMaterialAmbientFront ( ) [inline]

Helper function to reset the material front face ambient color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face ambient color to it's previous state. Otherwise, it is set to (0.2,0.2,0.2,1.0).
See also:
GLMaterialAmbientFront

void GLMaterialAmbientFrontAndBack ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_AMBIENT, param ).

This function caches the GL_AMBIENT value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_AMBIENT, param ) directly.

void GLResetMaterialAmbientFrontAndBack ( ) [inline]

Helper function to reset the material back and front face ambient color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face ambient color to it's previous state. Otherwise, it is set to (0.2,0.2,0.2,1.0).
See also:
GLMaterialAmbientFrontAndBack

void GLMaterialAmbient | ( | GLenum | face,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLMaterialfv( face, GL_AMBIENT, params ).

This function caches the GL_AMBIENT value of the material. It is faster to call this method instead of GLMaterialfv(face,GL_AMBIENT,params) directly.

void GLMaterialDiffuseBack ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_BACK, GL_DIFFUSE, param ).

This function caches the GL_DIFFUSE value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_DIFFUSE, param ) directly.

void GLResetMaterialDiffuseBack ( ) [inline]

Helper function to reset the material back face diffuse color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face diffuse color to it's previous state. Otherwise, it is set to (0.8,0.8,0.8,1.0).
See also:
GLMaterialDiffuseBack

void GLMaterialDiffuseFront ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_FRONT, GL_DIFFUSE, param ).

This function caches the GL_DIFFUSE value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_DIFFUSE, param ) directly.

void GLResetMaterialDiffuseFront ( ) [inline]

Helper function to reset the material front face diffuse color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face diffuse color to it's previous state. Otherwise, it is set to (0.8,0.8,0.8,1.0).
See also:
GLMaterialDiffuseFront

void GLMaterialDiffuseFrontAndBack ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_DIFFUSE, param ).

This function caches the GL_DIFFUSE value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_DIFFUSE, param ) directly.

void GLResetMaterialDiffuseFrontAndBack ( ) [inline]

Helper function to reset the material back and front face diffuse color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face diffuse color to it's previous state. Otherwise, it is set to (0.8,0.8,0.8,1.0).
See also:
GLMaterialDiffuseFrontAndBack

void GLMaterialDiffuse | ( | GLenum | face,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLMaterialfv( face, GL_DIFFUSE, params ).

This function caches the GL_DIFFUSE value of the material. It is faster to call this method instead of GLMaterialfv(face,GL_DIFFUSE,params) directly.

void GLMaterialEmissionBack ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_BACK, GL_EMISSION, param ).

This function caches the GL_EMISSION value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_EMISSION, param ) directly.

void GLResetMaterialEmissionBack ( ) [inline]

Helper function to reset the material back face emission color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face emission color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialEmissionBack

void GLMaterialEmissionFront ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_FRONT, GL_EMISSION, param ).

This function caches the GL_EMISSION value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_EMISSION, param ) directly.

void GLResetMaterialEmissionFront ( ) [inline]

Helper function to reset the material front face emission color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face emission color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialEmissionFront

void GLMaterialEmissionFrontAndBack ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_EMISSION, param ).

This function caches the GL_EMISSION value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_EMISSION, param ) directly.

void GLResetMaterialEmissionFrontAndBack ( ) [inline]

Helper function to reset the material back and front face emission color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face emission color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialEmissionFrontAndBack

void GLMaterialEmission | ( | GLenum | face,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLMaterialfv( face, GL_EMISSION, params ).

This function caches the GL_EMISSION value of the material. It is faster to call this method instead of GLMaterialfv(face,GL_EMISSION,params) directly.

void GLMaterialSpecularBack ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_BACK, GL_SPECULAR, param ).

This function caches the GL_SPECULAR value on the GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_BACK, GL_SPECULAR, param ) directly.

void GLResetMaterialSpecularBack ( ) [inline]

Helper function to reset the material back face specular color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back face specular color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialSpecularBack

void GLMaterialSpecularFront ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_FRONT, GL_SPECULAR, param ).

This function caches the GL_SPECULAR value on the GL_FRONT face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT, GL_SPECULAR, param ) directly.

void GLResetMaterialSpecularFront ( ) [inline]

Helper function to reset the material front face specular color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material front face specular color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialSpecularFront

void GLMaterialSpecularFrontAndBack ( const GLfloat * params ) [inline]

Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SPECULAR, param ).

This function caches the GL_SPECULAR value on both the GL_FRONT and GL_BACK face of the material. It is faster to call this method instead of GLMaterialf( GL_FRONT_AND_BACK, GL_SPECULAR, param ) directly.

void GLResetMaterialSpecularFrontAndBack ( ) [inline]

Helper function to reset the material back and front face specular color.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the material back and front face specular color to it's previous state. Otherwise, it is set to (0,0,0,1).
See also:
GLMaterialSpecularFrontAndBack

void GLMaterialSpecular | ( | GLenum | face,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLMaterialfv( face, GL_SPECULAR, params ).

This function caches the GL_SPECULAR value of the material. It is faster to call this method instead of GLMaterialfv(face,GL_SPECULAR,params) directly.

void GLMaterialf | ( | GLenum | face,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glMaterialf.

This function caches on some face and pname values and asserts on the result before returning.

void GLMaterialfv | ( | GLenum | face,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glMaterialfv.

This function caches on some face and pname values and asserts on the result before returning.

void GLMateriali | ( | GLenum | face,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glMateriali.

This function caches on some face and pname values and asserts on the result before returning.

void GLMaterialiv | ( | GLenum | face,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glMaterialiv.

This function caches on some face and pname values and asserts on the result before returning.

void GLMatrixMode ( GLenum mode ) [inline]

Replacement of glMatrixMode.

This function caches the matrix mode setting and asserts on the result before returning.

void GLMinmax | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLboolean | sink
 | ) | [inline]

Replacement of glMinmax.

This function asserts on the result before returning.

void GLMultiTexCoord1d | ( | GLenum | target,
 |  | GLdouble | s
 | ) | [inline]

Replacement of glMultiTexCoord1d.

This function asserts on the result before returning.

void GLMultiTexCoord1dv | ( | GLenum | target,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glMultiTexCoord1dv.

This function asserts on the result before returning.

void GLMultiTexCoord1f | ( | GLenum | target,
 |  | GLfloat | s
 | ) | [inline]

Replacement of glMultiTexCoord1f.

This function asserts on the result before returning.

void GLMultiTexCoord1fv | ( | GLenum | target,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glMultiTexCoord1fv.

This function asserts on the result before returning.

void GLMultiTexCoord1h | ( | GLenum | target,
 |  | GLhalf | s
 | ) | [inline]

Replacement of glMultiTexCoord1hNV.

This function asserts on the result before returning.

void GLMultiTexCoord1hv | ( | GLenum | target,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glMultiTexCoord1hv.

This function asserts on the result before returning.

void GLMultiTexCoord1i | ( | GLenum | target,
 |  | GLint | s
 | ) | [inline]

Replacement of glMultiTexCoord1i.

This function asserts on the result before returning.

void GLMultiTexCoord1iv | ( | GLenum | target,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glMultiTexCoord1iv.

This function asserts on the result before returning.

void GLMultiTexCoord1s | ( | GLenum | target,
 |  | GLshort | s
 | ) | [inline]

Replacement of glMultiTexCoord1s.

This function asserts on the result before returning.

void GLMultiTexCoord1sv | ( | GLenum | target,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glMultiTexCoord1sv.

This function asserts on the result before returning.

void GLMultiTexCoord2d | ( | GLenum | target,
 |  | GLdouble | s,
 |  | GLdouble | t
 | ) | [inline]

Replacement of glMultiTexCoord2d.

This function asserts on the result before returning.

void GLMultiTexCoord2dv | ( | GLenum | target,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glMultiTexCoord2dv.

This function asserts on the result before returning.

void GLMultiTexCoord2f | ( | GLenum | target,
 |  | GLfloat | s,
 |  | GLfloat | t
 | ) | [inline]

Replacement of glMultiTexCoord2f.

This function asserts on the result before returning.

void GLMultiTexCoord2fv | ( | GLenum | target,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glMultiTexCoord2fv.

This function asserts on the result before returning.

void GLMultiTexCoord2h | ( | GLenum | target,
 |  | GLhalf | s,
 |  | GLhalf | t
 | ) | [inline]

Replacement of glMultiTexCoord2hNV.

This function asserts on the result before returning.

void GLMultiTexCoord2hv | ( | GLenum | target,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glMultiTexCoord2hv.

This function asserts on the result before returning.

void GLMultiTexCoord2i | ( | GLenum | target,
 |  | GLint | s,
 |  | GLint | t
 | ) | [inline]

Replacement of glMultiTexCoord2i.

This function asserts on the result before returning.

void GLMultiTexCoord2iv | ( | GLenum | target,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glMultiTexCoord2iv.

This function asserts on the result before returning.

void GLMultiTexCoord2s | ( | GLenum | target,
 |  | GLshort | s,
 |  | GLshort | t
 | ) | [inline]

Replacement of glMultiTexCoord2s.

This function asserts on the result before returning.

void GLMultiTexCoord2sv | ( | GLenum | target,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glMultiTexCoord2sv.

This function asserts on the result before returning.

void GLMultiTexCoord3d | ( | GLenum | target,
 |  | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r
 | ) | [inline]

Replacement of glMultiTexCoord3d.

This function asserts on the result before returning.

void GLMultiTexCoord3dv | ( | GLenum | target,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glMultiTexCoord3dv.

This function asserts on the result before returning.

void GLMultiTexCoord3f | ( | GLenum | target,
 |  | GLfloat | s,
 |  | GLfloat | t,
 |  | GLfloat | r
 | ) | [inline]

Replacement of glMultiTexCoord3f.

This function asserts on the result before returning.

void GLMultiTexCoord3fv | ( | GLenum | target,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glMultiTexCoord3fv.

This function asserts on the result before returning.

void GLMultiTexCoord3h | ( | GLenum | target,
 |  | GLhalf | s,
 |  | GLhalf | t,
 |  | GLhalf | r
 | ) | [inline]

Replacement of glMultiTexCoord3hNV.

This function asserts on the result before returning.

void GLMultiTexCoord3hv | ( | GLenum | target,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glMultiTexCoord3hv.

This function asserts on the result before returning.

void GLMultiTexCoord3i | ( | GLenum | target,
 |  | GLint | s,
 |  | GLint | t,
 |  | GLint | r
 | ) | [inline]

Replacement of glMultiTexCoord3i.

This function asserts on the result before returning.

void GLMultiTexCoord3iv | ( | GLenum | target,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glMultiTexCoord3iv.

This function asserts on the result before returning.

void GLMultiTexCoord3s | ( | GLenum | target,
 |  | GLshort | s,
 |  | GLshort | t,
 |  | GLshort | r
 | ) | [inline]

Replacement of glMultiTexCoord3s.

This function asserts on the result before returning.

void GLMultiTexCoord3sv | ( | GLenum | target,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glMultiTexCoord3sv.

This function asserts on the result before returning.

void GLMultiTexCoord4d | ( | GLenum | target,
 |  | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r,
 |  | GLdouble | q
 | ) | [inline]

Replacement of glMultiTexCoord4d.

This function asserts on the result before returning.

void GLMultiTexCoord4dv | ( | GLenum | target,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glMultiTexCoord4dv.

This function asserts on the result before returning.

void GLMultiTexCoord4f | ( | GLenum | target,
 |  | GLfloat | s,
 |  | GLfloat | t,
 |  | GLfloat | r,
 |  | GLfloat | q
 | ) | [inline]

Replacement of glMultiTexCoord4f.

This function asserts on the result before returning.

void GLMultiTexCoord4fv | ( | GLenum | target,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glMultiTexCoord4fv.

This function asserts on the result before returning.

void GLMultiTexCoord4h | ( | GLenum | target,
 |  | GLhalf | s,
 |  | GLhalf | t,
 |  | GLhalf | r,
 |  | GLhalf | q
 | ) | [inline]

Replacement of glMultiTexCoord4hNV.

This function asserts on the result before returning.

void GLMultiTexCoord4hv | ( | GLenum | target,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glMultiTexCoord4hv.

This function asserts on the result before returning.

void GLMultiTexCoord4i | ( | GLenum | target,
 |  | GLint | s,
 |  | GLint | t,
 |  | GLint | r,
 |  | GLint | q
 | ) | [inline]

Replacement of glMultiTexCoord4i.

This function asserts on the result before returning.

void GLMultiTexCoord4iv | ( | GLenum | target,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glMultiTexCoord4iv.

This function asserts on the result before returning.

void GLMultiTexCoord4s | ( | GLenum | target,
 |  | GLshort | s,
 |  | GLshort | t,
 |  | GLshort | r,
 |  | GLshort | q
 | ) | [inline]

Replacement of glMultiTexCoord4s.

This function asserts on the result before returning.

void GLMultiTexCoord4sv | ( | GLenum | target,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glMultiTexCoord4sv.

This function asserts on the result before returning.

void GLMultiTexCoordPointer | ( | GLenum | target,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glMultiTexCoordPointer.

This function asserts on the result before returning.

void GLMultMatrixd ( const GLdouble * m ) [inline]

Replacement of glMultMatrixd.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLMultMatrixf ( const GLfloat * m ) [inline]

Replacement of glMultMatrixf.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLMultTransposeMatrixd ( const GLdouble * m ) [inline]

Replacement of glMultTransposeMatrixd.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLMultTransposeMatrixf ( const GLfloat * m ) [inline]

Replacement of glMultTransposeMatrixf.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLNewList | ( | GLuint | list,
 |  | GLenum | mode
 | ) | [inline]

Replacement of glNewList.

This function asserts on the result before returning.

void GLNormal3b | ( | GLbyte | nx,
 |  | GLbyte | ny,
 |  | GLbyte | nz
 | ) | [inline]

Replacement of glNormal3b.

This function asserts on the result before returning.

void GLNormal3bv ( const GLbyte * v ) [inline]

Replacement of glNormal3bv.

This function asserts on the result before returning.

void GLNormal3d | ( | GLdouble | nx,
 |  | GLdouble | ny,
 |  | GLdouble | nz
 | ) | [inline]

Replacement of glNormal3d.

This function asserts on the result before returning.

void GLNormal3dv ( const GLdouble * v ) [inline]

Replacement of glNormal3dv.

This function asserts on the result before returning.

void GLNormal3f | ( | GLfloat | nx,
 |  | GLfloat | ny,
 |  | GLfloat | nz
 | ) | [inline]

Replacement of glNormal3f.

This function asserts on the result before returning.

void GLNormal3fv ( const GLfloat * v ) [inline]

Replacement of glNormal3fv.

This function asserts on the result before returning.

void GLNormal3h | ( | GLhalf | nx,
 |  | GLhalf | ny,
 |  | GLhalf | nz
 | ) | [inline]

Replacement of glNormal3hNV.

This function asserts on the result before returning.

void GLNormal3hv ( const GLhalf * v ) [inline]

Replacement of glNormal3hv.

This function asserts on the result before returning.

void GLNormal3i | ( | GLint | nx,
 |  | GLint | ny,
 |  | GLint | nz
 | ) | [inline]

! Replacement of glNormal3i

This function asserts on the result before returning.

void GLNormal3iv ( const GLint * v ) [inline]

Replacement of glNormal3iv.

This function asserts on the result before returning.

void GLNormal3s | ( | GLshort | nx,
 |  | GLshort | ny,
 |  | GLshort | nz
 | ) | [inline]

Replacement of glNormal3s.

This function asserts on the result before returning.

void GLNormal3sv ( const GLshort * v ) [inline]

Replacement of glNormal3sv.

This function asserts on the result before returning.

void GLNormalPointer | ( | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glNormalPointer.

This function caches the normal pointer and asserts on the result before returning.

void GLOrtho | ( | GLdouble | left,
 |  | GLdouble | right,
 |  | GLdouble | bottom,
 |  | GLdouble | top,
 |  | GLdouble | zNear,
 |  | GLdouble | zFar
 | ) | [inline]

Replacement of glOrtho.

This function asserts on the result before returning.

void GLPassThrough ( GLfloat token ) [inline]

Replacement of glPassThrough.

This function asserts on the result before returning.

void GLPixelDataRange | ( | GLenum | target,
 |  | GLsizei | size,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glPixelDataRangeNV.

This function asserts on the result before returning.

void GLPixelMapfv | ( | GLenum | map,
 |  | GLsizei | mapsize,
 |  | const GLfloat * | values
 | ) | [inline]

Replacement of glPixelMapfv.

This function asserts on the result before returning.

void GLPixelMapuiv | ( | GLenum | map,
 |  | GLsizei | mapsize,
 |  | const GLuint * | values
 | ) | [inline]

Replacement of glPixelMapuiv.

This function asserts on the result before returning.

void GLPixelMapusv | ( | GLenum | map,
 |  | GLsizei | mapsize,
 |  | const GLushort * | values
 | ) | [inline]

Replacement of glPixelMapusv.

This function asserts on the result before returning.

void GLPixelStoref | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glPixelStoref.

This function asserts on the result before returning.

void GLPixelStorei | ( | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glPixelStorei.

This function asserts on the result before returning.

void GLPixelTransferf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glPixelTransferf.

This function asserts on the result before returning.

void GLPixelTransferi | ( | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glPixelTransferi.

This function asserts on the result before returning.

void GLPixelZoom | ( | GLfloat | xfactor,
 |  | GLfloat | yfactor
 | ) | [inline]

Replacement of glPixelZoom.

This function asserts on the result before returning.

void GLPointParameterf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glPointParameterf.

This function asserts on the result before returning.

void GLPointParameterfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glPointParameterfv.

This function asserts on the result before returning.

void GLPointParameteri | ( | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glPointParameteri.

This function asserts on the result before returning.

void GLPointParameteriv | ( | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glPointParameteriv.

This function asserts on the result before returning.

void GLPointSize ( GLfloat size ) [inline]

Replacement of glPointSize.

This function caches the point size setting and asserts on the result before returning.

void GLResetPointSize ( ) [inline]

Helper function to reset the point size.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the point size to it's previous state. Otherwise, it is set to 1.0f.
See also:
GLPointSize

void GLPolygonModeBack ( GLenum mode ) [inline]

Cached version of GLPolygonMode( GL_BACK, mode ).

This function caches the polygon mode on the GL_BACK face of polygon. It is faster to call this method instead of GLPolygonMode( GL_BACK, mode ) directly.

void GLResetPolygonModeBack ( ) [inline]

Helper function to reset back face polygon mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the back face polygon mode to it's previous state. Otherwise, it is set to GL_FILL.
See also:
GLPolygonModeBack

void GLPolygonModeFront ( GLenum mode ) [inline]

Cached version of GLPolygonMode( GL_FRONT, mode ).

This function caches the polygon mode on the GL_FRONT face of polygon. It is faster to call this method instead of GLPolygonMode( GL_FRONT, mode ) directly.

void GLResetPolygonModeFront ( ) [inline]

Helper function to reset front face polygon mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the front face polygon mode to it's previous state. Otherwise, it is set to GL_FILL.
See also:
GLPolygonModeFront

void GLPolygonModeFrontAndBack ( GLenum mode ) [inline]

Cached version of GLPolygonMode( GL_FRONT_AND_BACK, mode ).

This function caches the polygon mode on both the GL_FRONT and GL_BACK face of polygon. It is faster to call this method instead of GLPolygonMode( GL_FRONT_AND_BACK, mode ) directly.

void GLResetPolygonModeFrontAndBack ( ) [inline]

Helper function to reset back and front face polygon mode.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the back and front face polygon mode to it's previous state. Otherwise, it is set to GL_FILL.
See also:
GLPolygonModeFrontAndBack, GLPolygonModeFront, GLPolygonMode Back

void GLPolygonMode | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [inline]

Cached version of GLPolygonMode( face, mode ).

This function caches the polygon mode and assert on the result.

void GLPolygonModeLock | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [inline]

Helper function to set the polygon mode and lock it.

Parameters:
face | The face for which the polygon mode is to set and lock.
mode | The polygon mode to set and lock.
Remarks:
This function sets the polygon mode for face to mode and locks it. Any subsequent calls to GLPolygonMode, GLPolygonModeBack, or GLPolygonModeFront on the same face will not change that setting, until the next call to GLPolygonModeUnlock.
See also:
GLPolygonMode, GLPolygonModeUnlock

void GLPolygonModeUnlock | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [inline]

Helper function to unlock the polygon mode and set it.

Parameters:
face | The face for which the polygon mode is to be unlocked and set.
mode | The polygon mode to set.
Remarks:
This function unlocks the polygon mode for face and sets it to mode.
See also:
GLPolygonMode, GLPolygonModeLock

void GLPolygonOffset | ( | GLfloat | factor,
 |  | GLfloat | units
 | ) | [inline]

Replacement of glPolygonOffset.

This function caches the polygon offset settings and asserts on the result before returning.

void GLResetPolygonOffset ( ) [inline]

Helper function to reset the polygon offset.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the polygon offset to it's previous state. Otherwise, it is set to (0,0).
See also:
GLPolygonOffset

void GLPolygonStipple ( const GLubyte * mask ) [inline]

Replacement of glPolygonStipple.

This function asserts on the result before returning.

void GLPopAttrib ( void ) [inline]

Replacement of glPopAttrib.

This function asserts on the result before returning.

Note:
Currently we don't hold a stack of cached GL states, so GLPushAttrib/GLPopAttrib doesn't affect our cached values. It is therefore recommended to used GLPushAttrib/GLPopAttrib very local and to not use other potentially caching GL* functions (with uppercase GL), inbetween such a pair.

void GLPopClientAttrib ( void ) [inline]

Replacement of glPopClientAttrib.

This function asserts on the result before returning.

Note:
Currently we don't hold a stack of cached GL states, so GLPushClientAttrib/GLPopClientAttrib doesn't affect our cached values. It is therefore recommended to used GLPushAttrib/GLPopAttrib very local and to not use other potentially caching GL* functions (with uppercase GL), inbetween such a pair.

void GLPopMatrix ( void ) [inline]

Replacement of glPopMatrix.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLPopName ( void ) [inline]

Replacement of glPopName.

This function asserts on the result before returning.

void GLPrimitiveRestart ( ) [inline]

Replacement of glPrimitiveRestart.

This function asserts on the result before returning.

void GLPrimitiveRestartIndex ( GLuint index ) [inline]

Replacement of glPrimitiveRestartIndex.

This function caches the primitive restart index and asserts on the result before returning.

void GLPrioritizeTextures | ( | GLsizei | n,
 |  | const GLuint * | textures,
 |  | const GLclampf * | priorities
 | ) | [inline]

Replacement of glPrioritizeTextures.

This function asserts on the result before returning.

void GLProgramBufferParametersfv | ( | GLenum | target,
 |  | GLuint | buffer,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glProgramBufferParametersfvNV.

This function asserts on the result before returning.

void GLProgramBufferParametersIiv | ( | GLenum | target,
 |  | GLuint | buffer,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glProgramBufferParametersIivNV.

This function asserts on the result before returning.

void GLProgramBufferParametersIuiv | ( | GLenum | target,
 |  | GLuint | buffer,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLuint * | params
 | ) | [inline]

Replacement of glProgramBufferParametersIuivNV.

This function asserts on the result before returning.

void GLProgramEnvParameter4d | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [inline]

Replacement of glProgramEnvParameter4dARB.

This function asserts on the result before returning.

void GLProgramEnvParameter4dv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLdouble * | params
 | ) | [inline]

Replacement of glProgramEnvParameter4dvARB.

This function asserts on the result before returning.

void GLProgramEnvParameter4f | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [inline]

Replacement of glProgramEnvParameter4fARB.

This function asserts on the result before returning.

void GLProgramEnvParameter4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glProgramEnvParameter4fvARB.

This function asserts on the result before returning.

void GLProgramEnvParametersI4iv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glProgramEnvParametersI4ivNV.

This function asserts on the result before returning.

void GLProgramEnvParametersI4uiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLuint * | params
 | ) | [inline]

Replacement of glProgramEnvParametersI4uivNV.

This function asserts on the result before returning.

void GLProgramEnvParameterI4i | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [inline]

Replacement of glProgramEnvParameterI4iNV.

This function asserts on the result before returning.

void GLProgramEnvParameterI4iv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glProgramEnvParameterI4ivNV.

This function asserts on the result before returning.

void GLProgramEnvParameterI4ui | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y,
 |  | GLuint | z,
 |  | GLuint | w
 | ) | [inline]

Replacement of glProgramEnvParameterI4uiNV.

This function asserts on the result before returning.

void GLProgramEnvParameterI4uiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLuint * | params
 | ) | [inline]

Replacement of glProgramEnvParameterI4uivNV.

This function asserts on the result before returning.

void GLProgramEnvParameters4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glProgramEnvParameters4fvEXT.

This function asserts on the result before returning.

void GLProgramLocalParameter4d | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [inline]

Replacement of glProgramLocalParameter4dARB.

This function asserts on the result before returning.

void GLProgramLocalParameter4dv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLdouble * | params
 | ) | [inline]

Replacement of glProgramLocalParameter4dvARB.

This function asserts on the result before returning.

void GLProgramLocalParameter4f | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [inline]

Replacement of glProgramLocalParameter4fARB.

This function asserts on the result before returning.

void GLProgramLocalParameter4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glProgramLocalParameter4fvARB.

This function asserts on the result before returning.

void GLProgramLocalParametersI4iv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glProgramLocalParametersI4ivNV.

This function asserts on the result before returning.

void GLProgramLocalParametersI4uiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLuint * | params
 | ) | [inline]

Replacement of glProgramLocalParametersI4uivNV.

This function asserts on the result before returning.

void GLProgramLocalParameterI4i | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [inline]

Replacement of glProgramLocalParameterI4iNV.

This function asserts on the result before returning.

void GLProgramLocalParameterI4iv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glProgramLocalParameterI4ivNV.

This function asserts on the result before returning.

void GLProgramLocalParameterI4ui | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y,
 |  | GLuint | z,
 |  | GLuint | w
 | ) | [inline]

Replacement of glProgramLocalParameterI4uiNV.

This function asserts on the result before returning.

void GLProgramLocalParameterI4uiv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLuint * | params
 | ) | [inline]

Replacement of glProgramLocalParameterI4uivNV.

This function asserts on the result before returning.

void GLProgramLocalParameters4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | params
 | ) | [inline]

Replacement of glProgramLocalParameters4fvEXT.

This function asserts on the result before returning.

void GLProgramNamedParameter4d | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [inline]

Replacement of glProgramNamedParameter4dNV.

This function asserts on the result before returning.

void GLProgramNamedParameter4dv | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glProgramNamedParameter4dvNV.

This function asserts on the result before returning.

void GLProgramNamedParameter4f | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [inline]

Replacement of glProgramNamedParameter4fNV.

This function asserts on the result before returning.

void GLProgramNamedParameter4fv | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glProgramNamedParameter4fvNV.

This function asserts on the result before returning.

void GLProgramParameter4d | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [inline]

Replacement of glProgramParameter4dNV.

This function asserts on the result before returning.

void GLProgramParameter4dv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glProgramParameter4dvNV.

This function asserts on the result before returning.

void GLProgramParameter4f | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [inline]

Replacement of glProgramParameter4fNV.

This function asserts on the result before returning.

void GLProgramParameter4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glProgramParameter4fvNV.

This function asserts on the result before returning.

void GLProgramParameteri | ( | GLuint | program,
 |  | GLenum | pname,
 |  | GLint | value
 | ) | [inline]

Replacement of glProgramParameteriEXT.

This function asserts on the result before returning.

void GLProgramParameters4dv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glProgramParameters4dvNV.

This function asserts on the result before returning.

void GLProgramParameters4fv | ( | GLenum | target,
 |  | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glProgramParameters4fvNV.

This function asserts on the result before returning.

void GLProgramString | ( | GLenum | target,
 |  | GLenum | format,
 |  | GLsizei | len,
 |  | const GLvoid * | string
 | ) | [inline]

Replacement of glProgramStringARB.

This function asserts on the result before returning.

void GLProgramVertexLimit | ( | GLenum | target,
 |  | GLint | limit
 | ) | [inline]

Replacement of glProgramVertexLimitNV.

This function asserts on the result before returning.

void GLPushAttrib ( GLbitfield mask ) [inline]

Replacement of glPushAttrib.

This function asserts on the result before returning.

Note:
Currently we don't hold a stack of cached GL states, so GLPushAttrib/GLPopAttrib doesn't affect our cached values. It is therefore recommended to used GLPushAttrib/GLPopAttrib very local and to not use other potentially caching GL* functions (with uppercase GL), inbetween such a pair.

void GLPushClientAttrib ( GLbitfield mask ) [inline]

Replacement of glPushClientAttrib.

This function asserts on the result before returning.

Note:
Currently we don't hold a stack of cached GL states, so GLPushClientAttrib/GLPopClientAttrib doesn't affect our cached values. It is therefore recommended to used GLPushAttrib/GLPopAttrib very local and to not use other potentially caching GL* functions (with uppercase GL), inbetween such a pair.

void GLPushMatrix ( void ) [inline]

Replacement of glPushMatrix.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLPushName ( GLuint name ) [inline]

Replacement of glPushName.

This function asserts on the result before returning.

void GLRasterPos2d | ( | GLdouble | x,
 |  | GLdouble | y
 | ) | [inline]

Replacement of glRasterPos2d.

This function asserts on the result before returning.

void GLRasterPos2f | ( | GLfloat | x,
 |  | GLfloat | y
 | ) | [inline]

Replacement of glRasterPos2f.

This function asserts on the result before returning.

void GLRasterPos2i | ( | GLint | x,
 |  | GLint | y
 | ) | [inline]

Replacement of glRasterPos2i.

This function asserts on the result before returning.

void GLRasterPos2s | ( | GLshort | x,
 |  | GLshort | y
 | ) | [inline]

Replacement of glRasterPos2s.

This function asserts on the result before returning.

void GLRasterPos3d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [inline]

Replacement of glRasterPos3d.

This function asserts on the result before returning.

void GLRasterPos3f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [inline]

Replacement of glRasterPos3f.

This function asserts on the result before returning.

void GLRasterPos3i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [inline]

Replacement of glRasterPos3i.

This function asserts on the result before returning.

void GLRasterPos3s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z
 | ) | [inline]

Replacement of glRasterPos3s.

This function asserts on the result before returning.

void GLRasterPos4d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [inline]

Replacement of glRasterPos4d.

This function asserts on the result before returning.

void GLRasterPos4f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [inline]

Replacement of glRasterPos4f.

This function asserts on the result before returning.

void GLRasterPos4i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [inline]

Replacement of glRasterPos4i.

This function asserts on the result before returning.

void GLRasterPos4s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z,
 |  | GLshort | w
 | ) | [inline]

Replacement of glRasterPos4s.

This function asserts on the result before returning.

void GLReadBuffer ( GLenum mode ) [inline]

Replacement of glReadBuffer.

This function asserts on the result before returning.

void GLReadPixels | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | GLvoid * | pixels
 | ) | [inline]

Replacement of glReadPixels.

This function asserts on the result before returning.

void GLRectd | ( | GLdouble | x1,
 |  | GLdouble | y1,
 |  | GLdouble | x2,
 |  | GLdouble | y2
 | ) | [inline]

Replacement of glRectd.

This function asserts on the result before returning.

void GLRectf | ( | GLfloat | x1,
 |  | GLfloat | y1,
 |  | GLfloat | x2,
 |  | GLfloat | y2
 | ) | [inline]

Replacement of glRectf.

This function asserts on the result before returning.

void GLRecti | ( | GLint | x1,
 |  | GLint | y1,
 |  | GLint | x2,
 |  | GLint | y2
 | ) | [inline]

Replacement of glRecti.

This function asserts on the result before returning.

void GLRects | ( | GLshort | x1,
 |  | GLshort | y1,
 |  | GLshort | x2,
 |  | GLshort | y2
 | ) | [inline]

Replacement of glRects.

This function asserts on the result before returning.

void GLRenderMode ( GLenum mode ) [inline]

Replacement of glRenderMode.

This function asserts on the result before returning.

void GLRequestResidentPrograms | ( | GLsizei | n,
 |  | const GLuint * | programs
 | ) | [inline]

Replacement of glRequestResidentProgramsNV.

This function asserts on the result before returning.

void GLResetHistogram ( GLenum target ) [inline]

Replacement of glResetHistogram.

This function asserts on the result before returning.

void GLResetMinmax ( GLenum target ) [inline]

Replacement of glResetMinmax.

This function asserts on the result before returning.

void GLRotated | ( | GLdouble | angle,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [inline]

Replacement of glRotated.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLRotatef | ( | GLfloat | angle,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [inline]

Replacement of glRotatef.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLScaled | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [inline]

Replacement of glScaled.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLScalef | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [inline]

Replacement of glScalef.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLSampleCoverage | ( | GLclampf | value,
 |  | GLboolean | invert
 | ) | [inline]

Replacement of glSampleCoverage.

This function asserts on the result before returning.

void GLScissor | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glScissor.

This function caches the scissor settings and asserts on the result before returning.

void GLResetScissor ( ) [inline]

Helper function to reset the scissor rectangle.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the scissor rectangle to it's previous state. Otherwise, it does nothing.
See also:
GLScissor

void GLSecondaryColor3b | ( | GLbyte | red,
 |  | GLbyte | green,
 |  | GLbyte | blue
 | ) | [inline]

Replacement of glSecondaryColor3b.

This function asserts on the result before returning.

void GLSecondaryColor3bv ( const GLbyte * v ) [inline]

Replacement of glSecondaryColor3bv.

This function asserts on the result before returning.

void GLSecondaryColor3d | ( | GLdouble | red,
 |  | GLdouble | green,
 |  | GLdouble | blue
 | ) | [inline]

Replacement of glSecondaryColor3d.

This function asserts on the result before returning.

void GLSecondaryColor3dv ( const GLdouble * v ) [inline]

Replacement of glSecondaryColor3dv.

This function asserts on the result before returning.

void GLSecondaryColor3f | ( | GLfloat | red,
 |  | GLfloat | green,
 |  | GLfloat | blue
 | ) | [inline]

Replacement of glSecondaryColor3f.

This function asserts on the result before returning.

void GLSecondaryColor3fv ( const GLfloat * v ) [inline]

Replacement of glSecondaryColor3fv.

This function asserts on the result before returning.

void GLSecondaryColor3h | ( | GLhalf | red,
 |  | GLhalf | green,
 |  | GLhalf | blue
 | ) | [inline]

Replacement of glSecondaryColor3h.

This function asserts on the result before returning.

void GLSecondaryColor3hv ( const GLhalf * v ) [inline]

Replacement of glSecondaryColor3hv.

This function asserts on the result before returning.

void GLSecondaryColor3i | ( | GLint | red,
 |  | GLint | green,
 |  | GLint | blue
 | ) | [inline]

Replacement of glSecondaryColor3i.

This function asserts on the result before returning.

void GLSecondaryColor3iv ( const GLint * v ) [inline]

Replacement of glSecondaryColor3iv.

This function asserts on the result before returning.

void GLSecondaryColor3s | ( | GLshort | red,
 |  | GLshort | green,
 |  | GLshort | blue
 | ) | [inline]

Replacement of glSecondaryColor3s.

This function asserts on the result before returning.

void GLSecondaryColor3sv ( const GLshort * v ) [inline]

Replacement of glSecondaryColor3sv.

This function asserts on the result before returning.

void GLSecondaryColor3ub | ( | GLubyte | red,
 |  | GLubyte | green,
 |  | GLubyte | blue
 | ) | [inline]

Replacement of glSecondaryColor3ub.

This function asserts on the result before returning.

void GLSecondaryColor3ubv ( const GLubyte * v ) [inline]

Replacement of glSecondaryColor3ubv.

This function asserts on the result before returning.

void GLSecondaryColor3ui | ( | GLuint | red,
 |  | GLuint | green,
 |  | GLuint | blue
 | ) | [inline]

Replacement of glSecondaryColor3ui.

This function asserts on the result before returning.

void GLSecondaryColor3uiv ( const GLuint * v ) [inline]

Replacement of glSecondaryColor3uiv.

This function asserts on the result before returning.

void GLSecondaryColor3us | ( | GLushort | red,
 |  | GLushort | green,
 |  | GLushort | blue
 | ) | [inline]

Replacement of glSecondaryColor3us.

This function asserts on the result before returning.

void GLSecondaryColor3usv ( const GLushort * v ) [inline]

Replacement of glSecondaryColor3usv.

This function asserts on the result before returning.

void GLSecondaryColorPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glSecondaryColorPointer.

This function caches the secondary color pointer setting and asserts on the result before returning.

void GLSelectBuffer | ( | GLsizei | size,
 |  | GLuint * | buffer
 | ) | [inline]

Replacement of glSelectBuffer.

This function asserts on the result before returning.

void GLSelectTexture ( GLenum target ) [inline]

Replacement of glSelectTexture.

This function simply maps to GLActiveTexture.

void GLSelectTextureCoordSet ( GLenum target ) [inline]

Replacement of GLSelectTextureCoordSet.

This function simply maps to GLClientActiveTexture.

void GLSeparableFilter2D | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | row,
 |  | const GLvoid * | column
 | ) | [inline]

Replacement of glSeparableFilter2D.

This function asserts on the result before returning.

void GLSetFence | ( | GLuint | fence,
 |  | GLenum | condition
 | ) | [inline]

Replacement of glSetFenceNV.

void GLSetWindowStereoMode ( GLboolean displayMode ) [inline]

Replacement of glSetWindowStereoModeNV.

This function asserts on the result before returning.

void GLShadeModel ( GLenum mode ) [inline]

Replacement of glShadeModel.

This function caches the shade model setting and asserts on the result before returning.

void GLResetShadeModel ( ) [inline]

Helper function to reset the shade model.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the shade model to it's previous state. Otherwise, it is set to GL_SMOOTH.
See also:
GLShadeModel

void GLShaderSource | ( | GLuint | shader,
 |  | GLsizei | count,
 |  | const GLcharARB ** | string,
 |  | const GLint * | length
 | ) | [inline]

Replacement of glShaderSource.

void GLStencilClearTag | ( | GLsizei | tagBits,
 |  | GLuint | clearTag
 | ) | [inline]

Replacement of glStencilClearTag.

void GLStencilFunc | ( | GLenum | func,
 |  | GLint | ref,
 |  | GLuint | mask
 | ) | [inline]

Replacement of glStencilFunc.

This function caches the stencil function setting and asserts on the result before returning.

void GLStencilFuncSeparate | ( | GLenum | face,
 |  | GLenum | func,
 |  | GLint | ref,
 |  | GLuint | mask
 | ) | [inline]

Replacement of glStencilFuncSeparate.

void GLStencilOpSeparate | ( | GLenum | face,
 |  | GLenum | fail,
 |  | GLenum | zfail,
 |  | GLenum | zpass
 | ) | [inline]

Replacement of glStencilOpSeparate.

void GLStencilMaskSeparate | ( | GLenum | face,
 |  | GLuint | mask
 | ) | [inline]

Replacement of glStencilMaskSeparate.

void GLResetStencilFunc ( ) [inline]

Helper function to reset the stencil function values.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil function values to it's previous state. Otherwise, it sets the function, reference value, and mask to GL_ALWAYS, 0, and ~0, respectively.
See also:
GLStencilFunc

void GLStencilMask ( GLuint mask ) [inline]

Replacement of glStencilMask.

This function caches the stencil mask setting and asserts on the result before returning.

void GLResetStencilMask ( ) [inline]

Helper function to reset the stencil mask.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil mask to it's previous state. Otherwise, it is set to ~0.
See also:
GLStencilMask

void GLStencilOp | ( | GLenum | fail,
 |  | GLenum | zfail,
 |  | GLenum | zpass
 | ) | [inline]

Replacement of glStencilOp.

This function caches the stencil operation setting and asserts on the result before returning.

void GLResetStencilOp ( ) [inline]

Helper function to reset the stencil operation values.

Remarks:
If GL_SUPPORT_RESET is defined (per default, it is), this function sets the stencil operation values to it's previous state. Otherwise, it sets each value (fail, zfail, zpass) to GL_KEEP.
See also:
GLStencilMask

void GLStringMarker | ( | GLsizei | len,
 |  | const GLvoid * | string
 | ) | [inline]

Replacement of glStringMarkerGREMEDY.

This function simply does nothing if the extension is not available

void GLFrameTerminator ( void ) [inline]

Replacement of glFrameTerminatorGREMEDY.

This function simply does nothing if the extension is not available

GLboolean GLTestFence ( GLuint fence ) [inline]

Replacement of glTestFenceNV.

This function asserts on the result before returning.

void GLTexBuffer | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLuint | buffer
 | ) | [inline]

Replacement of glTexBufferEXT.

This function asserts on the result before returning.

void GLTexCoord1d ( GLdouble s ) [inline]

Replacement of glTexCoord1d.

This function asserts on the result before returning.

void GLTexCoord1dv ( const GLdouble * v ) [inline]

Replacement of glTexCoord1dv.

This function asserts on the result before returning.

void GLTexCoord1f ( GLfloat s ) [inline]

Replacement of glTexCoord1f.

This function asserts on the result before returning.

void GLTexCoord1fv ( const GLfloat * v ) [inline]

Replacement of glTexCoord1fv.

This function asserts on the result before returning.

void GLTexCoord1h ( GLhalf s ) [inline]

Replacement of glTexCoord1hNV.

This function asserts on the result before returning.

void GLTexCoord1hv ( const GLhalf * v ) [inline]

Replacement of glTexCoord1hv.

This function asserts on the result before returning.

void GLTexCoord1i ( GLint s ) [inline]

Replacement of glTexCoord1i.

This function asserts on the result before returning.

void GLTexCoord1iv ( const GLint * v ) [inline]

Replacement of glTexCoord1iv.

This function asserts on the result before returning.

void GLTexCoord1s ( GLshort s ) [inline]

Replacement of glTexCoord1s.

This function asserts on the result before returning.

void GLTexCoord1sv ( const GLshort * v ) [inline]

Replacement of glTexCoord1sv.

This function asserts on the result before returning.

void GLTexCoord2d | ( | GLdouble | s,
 |  | GLdouble | t
 | ) | [inline]

Replacement of glTexCoord2d.

This function asserts on the result before returning.

void GLTexCoord2dv ( const GLdouble * v ) [inline]

Replacement of glTexCoord2dv.

This function asserts on the result before returning.

void GLTexCoord2f | ( | GLfloat | s,
 |  | GLfloat | t
 | ) | [inline]

Replacement of glTexCoord2f.

This function asserts on the result before returning.

void GLTexCoord2fv ( const GLfloat * v ) [inline]

Replacement of glTexCoord2fv.

This function asserts on the result before returning.

void GLTexCoord2h | ( | GLhalf | s,
 |  | GLhalf | t
 | ) | [inline]

Replacement of glTexCoord2hNV.

This function asserts on the result before returning.

void GLTexCoord2hv ( const GLhalf * v ) [inline]

Replacement of glTexCoord2hv.

This function asserts on the result before returning.

void GLTexCoord2i | ( | GLint | s,
 |  | GLint | t
 | ) | [inline]

Replacement of glTexCoord2i.

This function asserts on the result before returning.

void GLTexCoord2iv ( const GLint * v ) [inline]

Replacement of glTexCoord2iv.

This function asserts on the result before returning.

void GLTexCoord2s | ( | GLshort | s,
 |  | GLshort | t
 | ) | [inline]

Replacement of glTexCoord2s.

This function asserts on the result before returning.

void GLTexCoord2sv ( const GLshort * v ) [inline]

Replacement of glTexCoord2sv.

This function asserts on the result before returning.

void GLTexCoord3d | ( | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r
 | ) | [inline]

Replacement of glTexCoord3d.

This function asserts on the result before returning.

void GLTexCoord3dv ( const GLdouble * v ) [inline]

Replacement of glTexCoord3dv.

This function asserts on the result before returning.

void GLTexCoord3f | ( | GLfloat | s,
 |  | GLfloat | t,
 |  | GLfloat | r
 | ) | [inline]

Replacement of glTexCoord3f.

This function asserts on the result before returning.

void GLTexCoord3fv ( const GLfloat * v ) [inline]

Replacement of glTexCoord3fv.

This function asserts on the result before returning.

void GLTexCoord3h | ( | GLhalf | s,
 |  | GLhalf | t,
 |  | GLhalf | r
 | ) | [inline]

Replacement of glTexCoord3hNV.

This function asserts on the result before returning.

void GLTexCoord3hv ( const GLhalf * v ) [inline]

Replacement of glTexCoord3hv.

This function asserts on the result before returning.

void GLTexCoord3i | ( | GLint | s,
 |  | GLint | t,
 |  | GLint | r
 | ) | [inline]

Replacement of glTexCoord3i.

This function asserts on the result before returning.

void GLTexCoord3iv ( const GLint * v ) [inline]

Replacement of glTexCoord3iv.

This function asserts on the result before returning.

void GLTexCoord3s | ( | GLshort | s,
 |  | GLshort | t,
 |  | GLshort | r
 | ) | [inline]

Replacement of glTexCoord3s.

This function asserts on the result before returning.

void GLTexCoord3sv ( const GLshort * v ) [inline]

Replacement of glTexCoord3sv.

This function asserts on the result before returning.

void GLTexCoord4d | ( | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r,
 |  | GLdouble | q
 | ) | [inline]

Replacement of glTexCoord4d.

This function asserts on the result before returning.

void GLTexCoord4dv ( const GLdouble * v ) [inline]

Replacement of glTexCoord4dv.

This function asserts on the result before returning.

void GLTexCoord4f | ( | GLfloat | s,
 |  | GLfloat | t,
 |  | GLfloat | r,
 |  | GLfloat | q
 | ) | [inline]

Replacement of glTexCoord4f.

This function asserts on the result before returning.

void GLTexCoord4fv ( const GLfloat * v ) [inline]

Replacement of glTexCoord4fv.

This function asserts on the result before returning.

void GLTexCoord4h | ( | GLhalf | s,
 |  | GLhalf | t,
 |  | GLhalf | r,
 |  | GLhalf | q
 | ) | [inline]

Replacement of glTexCoord4hNV.

This function asserts on the result before returning.

void GLTexCoord4hv ( const GLhalf * v ) [inline]

Replacement of glTexCoord4hv.

This function asserts on the result before returning.

void GLTexCoord4i | ( | GLint | s,
 |  | GLint | t,
 |  | GLint | r,
 |  | GLint | q
 | ) | [inline]

Replacement of glTexCoord4i.

This function asserts on the result before returning.

void GLTexCoord4iv ( const GLint * v ) [inline]

Replacement of glTexCoord4iv.

This function asserts on the result before returning.

void GLTexCoord4s | ( | GLshort | s,
 |  | GLshort | t,
 |  | GLshort | r,
 |  | GLshort | q
 | ) | [inline]

Replacement of glTexCoord4s.

This function asserts on the result before returning.

void GLTexCoord4sv ( const GLshort * v ) [inline]

Replacement of glTexCoord4sv.

This function asserts on the result before returning.

void GLTexCoordPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glTexCoordPointer.

This function caches the tex coord pointer setting and asserts on the result before returning.

void GLTextureEnvColor ( const GLfloat * params ) [inline]

Cached version of GLTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params ).

This function caches the GL_TEXTURE_ENV_COLOR value of the active texture unit. It is faster to call this method instead of GLTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params) directly.

void GLTextureEnvMode ( GLint param ) [inline]

Cached version of GLTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, param ).

This function caches the GL_TEXTURE_ENV_MODE value of the active texture unit. It is faster to call this method instead of GLTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, param) directly.

void GLTexEnvf | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Cached version of glTexEnvf( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

void GLTexEnvfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of glTexEnvf( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

void GLTexEnvi | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Cached version of glTexEnvi( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

void GLTexEnviv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Cached version of glTexEnviv( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

void GLTexGend | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLdouble | param
 | ) | [inline]

Replacement of glTexGend.

This function updates the active texture and asserts on the result before returning.

void GLTexGenf | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Replacement of glTexGenf.

This function updates the active texture and asserts on the result before returning.

void GLTexGenfv | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | const GLfloat * | param
 | ) | [inline]

Replacement of glTexGenfv.

This function updates the active texture and asserts on the result before returning.

void GLTexGeni | ( | GLenum | coord,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Replacement of glTexGeni.

This function updates the active texture and asserts on the result before returning.

void GLTexImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | internalformat,
 |  | GLsizei | width,
 |  | GLint | border,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [inline]

Replacement of glTexImage1D.

This function updates the active texture and asserts on the result before returning.

void GLTexImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLint | border,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [inline]

Replacement of glTexImage2D.

This function updates the active texture and asserts on the result before returning.

void GLTexImage3D | ( | GLenum | target,
 |  | int | level,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLsizei | depth,
 |  | int | border,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const void * | pixels
 | ) | [inline]

Replacement of glTexImage3D.

This function hides the extension character of glTexImage3D, updates the active texture, and asserts on the result before returning.

void GLTextureBorderColor | ( | GLenum | target,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of GLTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, params ).

This function caches the GL_TEXTURE_BORDER_COLOR values of the texture currently bound to target. It is faster to call this method instead of GLTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, params) directly.

void GLTextureMagFilter | ( | GLenum | target,
 |  | GLint | param
 | ) | [inline]

Cached version of GLTexParameteri( target, GL_TEXTURE_MAG_FILTER, param ).

This function caches the GL_TEXTURE_MAG_FILTER values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_MAG_FILTER, param) directly.

void GLTextureMinFilter | ( | GLenum | target,
 |  | GLint | param
 | ) | [inline]

Cached version of GLTexParameteri( target, GL_TEXTURE_MIN_FILTER, param ).

This function caches the GL_TEXTURE_MIN_FILTER values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_MIN_FILTER, param) directly.

void GLTextureWrapR | ( | GLenum | target,
 |  | GLint | param
 | ) | [inline]

Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_R, param ).

This function caches the GL_TEXTURE_WRAP_R values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_WRAP_R, param) directly.

void GLTextureWrapS | ( | GLenum | target,
 |  | GLint | param
 | ) | [inline]

Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_S, param ).

This function caches the GL_TEXTURE_WRAP_S values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_WRAP_S, param) directly.

void GLTextureWrapT | ( | GLenum | target,
 |  | GLint | param
 | ) | [inline]

Cached version of GLTexParameteri( target, GL_TEXTURE_WRAP_T, param ).

This function caches the GL_TEXTURE_WRAP_T values of the texture currently bound to target. It is faster to call this method instead of GLTexParameteri(target, GL_TEXTURE_WRAP_T, param) directly.

void GLTrackMatrix | ( | GLenum | target,
 |  | GLuint | address,
 |  | GLenum | matrix,
 |  | GLenum | transform
 | ) | [inline]

Cached version of glTrackMatrixNV.

This function asserts on the result before returning.

void GLTransformFeedbackAttribs | ( | GLuint | count,
 |  | const GLint * | attribs,
 |  | GLenum | bufferMode
 | ) | [inline]

Cached version of glTransformFeedbackAttribsNV.

This function asserts on the result before returning.

void GLTransformFeedbackVaryings | ( | GLuint | program,
 |  | GLsizei | count,
 |  | const GLint * | locations,
 |  | GLenum | bufferMode
 | ) | [inline]

Cached version of glTransformFeedbackVaryingsNV.

This function asserts on the result before returning.

void GLTexParameterf | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLfloat | param
 | ) | [inline]

Cached version of glTexParameterf( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

void GLTexParameterfv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLfloat * | params
 | ) | [inline]

Cached version of glTexParameterfv( target, pname, params ).

This function caches some of the texture environment parameters and asserts on the result before returning.

void GLTexParameteri | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint | param
 | ) | [inline]

Cached version of glTexParameteri( target, pname, param ).

This function caches some of the texture environment parameters and asserts on the result before returning.

void GLTexParameterIiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Replacement of glTexParameterIivEXT.

This function asserts on the result before returning.

void GLTexParameterIuiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLuint * | params
 | ) | [inline]

Replacement of glTexParameterIuivEXT.

This function asserts on the result before returning.

void GLTexParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | const GLint * | params
 | ) | [inline]

Cached version of glTexParameteriv( target, pname, params ).

This function caches some of the texture environment parameters and asserts on the result before returning.

void GLTexSubImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [inline]

Replacement of glTexSubImage1D.

This function updates the active texture and asserts on the result before returning.

void GLTexSubImage2D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [inline]

Replacement of glTexSubImage2D.

This function updates the active texture and asserts on the result before returning.

void GLTexSubImage3D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLint | yoffset,
 |  | GLint | zoffset,
 |  | GLsizei | width,
 |  | GLsizei | height,
 |  | GLsizei | depth,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [inline]

Replacement of glTexSubImage3D.

This function updates the active texture and asserts on the result before returning.

void GLTranslated | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [inline]

Replacement of glTranslated.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

void GLTranslatef | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [inline]

Replacement of glTranslatef.

This function updates the active texture if the matrix mode is GL_TEXTURE and asserts on the result before returning.

GLboolean GLValidBackBufferHint | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glValidBackBufferHintAutodesk.

void GLVertex2d | ( | GLdouble | x,
 |  | GLdouble | y
 | ) | [inline]

Replacement of glVertex2d.

This function asserts on the result before returning.

void GLVertex2dv ( const GLdouble * v ) [inline]

Replacement of glVertex2dv.

This function asserts on the result before returning.

void GLVertex2f | ( | GLfloat | x,
 |  | GLfloat | y
 | ) | [inline]

Replacement of glVertex2f.

This function asserts on the result before returning.

void GLVertex2fv ( const GLfloat * v ) [inline]

Replacement of glVertex2fv.

This function asserts on the result before returning.

void GLVertex2h | ( | GLhalf | x,
 |  | GLhalf | y
 | ) | [inline]

Replacement of glVertex2hNV.

This function asserts on the result before returning.

void GLVertex2hv ( const GLhalf * v ) [inline]

Replacement of glVertex2hv.

This function asserts on the result before returning.

void GLVertex2i | ( | GLint | x,
 |  | GLint | y
 | ) | [inline]

Replacement of glVertex2i.

This function asserts on the result before returning.

void GLVertex2iv ( const GLint * v ) [inline]

Replacement of glVertex2iv.

This function asserts on the result before returning.

void GLVertex2s | ( | GLshort | x,
 |  | GLshort | y
 | ) | [inline]

Replacement of glVertex2s.

This function asserts on the result before returning.

void GLVertex2sv ( const GLshort * v ) [inline]

Replacement of glVertex2sv.

This function asserts on the result before returning.

void GLVertex3d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [inline]

Replacement of glVertex3d.

This function asserts on the result before returning.

void GLVertex3dv ( const GLdouble * v ) [inline]

Replacement of glVertex3dv.

This function asserts on the result before returning.

void GLVertex3f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [inline]

Replacement of glVertex3f.

This function asserts on the result before returning.

void GLVertex3fv ( const GLfloat * v ) [inline]

Replacement of glVertex3fv.

This function asserts on the result before returning.

void GLVertex3h | ( | GLhalf | x,
 |  | GLhalf | y,
 |  | GLhalf | z
 | ) | [inline]

Replacement of glVertex3hNV.

This function asserts on the result before returning.

void GLVertex3hv ( const GLhalf * v ) [inline]

Replacement of glVertex3hv.

This function asserts on the result before returning.

void GLVertex3i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [inline]

Replacement of glVertex3i.

This function asserts on the result before returning.

void GLVertex3iv ( const GLint * v ) [inline]

Replacement of glVertex3iv.

This function asserts on the result before returning.

void GLVertex3s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z
 | ) | [inline]

Replacement of glVertex3s.

This function asserts on the result before returning.

void GLVertex3sv ( const GLshort * v ) [inline]

Replacement of glVertex3sv.

This function asserts on the result before returning.

void GLVertex4d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [inline]

Replacement of glVertex4d.

This function asserts on the result before returning.

void GLVertex4dv ( const GLdouble * v ) [inline]

Replacement of glVertex4dv.

This function asserts on the result before returning.

void GLVertex4f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [inline]

Replacement of glVertex4f.

This function asserts on the result before returning.

void GLVertex4fv ( const GLfloat * v ) [inline]

Replacement of glVertex4fv.

This function asserts on the result before returning.

void GLVertex4h | ( | GLhalf | x,
 |  | GLhalf | y,
 |  | GLhalf | z,
 |  | GLhalf | w
 | ) | [inline]

Replacement of glVertex4hNV.

This function asserts on the result before returning.

void GLVertex4hv ( const GLhalf * v ) [inline]

Replacement of glVertex4hv.

This function asserts on the result before returning.

void GLVertex4i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [inline]

Replacement of glVertex4i.

This function asserts on the result before returning.

void GLVertex4iv ( const GLint * v ) [inline]

Replacement of glVertex4iv.

This function asserts on the result before returning.

void GLVertex4s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z,
 |  | GLshort | w
 | ) | [inline]

Replacement of glVertex4s.

This function asserts on the result before returning.

void GLVertex4sv ( const GLshort * v ) [inline]

Replacement of glVertex4sv.

This function asserts on the result before returning.

void GLVertexArrayRange | ( | GLsizei | size,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glVertexArrayRange.

This function asserts on the result before returning.

void GLVertexAttrib1d | ( | GLuint | index,
 |  | GLdouble | x
 | ) | [inline]

Replacement of glVertexAttrib1d.

void GLVertexAttrib1dv | ( | GLuint | index,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glVertexAttrib1dv.

void GLVertexAttrib1f | ( | GLuint | index,
 |  | GLfloat | x
 | ) | [inline]

Replacement of glVertexAttrib1f.

void GLVertexAttrib1fv | ( | GLuint | index,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glVertexAttrib1fv.

void GLVertexAttrib1h | ( | GLuint | index,
 |  | GLhalf | x
 | ) | [inline]

Replacement of glVertexAttrib1h.

void GLVertexAttrib1hv | ( | GLuint | index,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glVertexAttrib1nv.

void GLVertexAttrib1s | ( | GLuint | index,
 |  | GLshort | x
 | ) | [inline]

Replacement of glVertexAttrib1s.

void GLVertexAttrib1sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttrib1sv.

void GLVertexAttrib2d | ( | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y
 | ) | [inline]

Replacement of glVertexAttrib2d.

void GLVertexAttrib2dv | ( | GLuint | index,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glVertexAttrib2dv.

void GLVertexAttrib2f | ( | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y
 | ) | [inline]

Replacement of glVertexAttrib2f.

void GLVertexAttrib2fv | ( | GLuint | index,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glVertexAttrib2fv.

void GLVertexAttrib2h | ( | GLuint | index,
 |  | GLhalf | x,
 |  | GLhalf | y
 | ) | [inline]

Replacement of glVertexAttrib2h.

void GLVertexAttrib2hv | ( | GLuint | index,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glVertexAttrib2hv.

void GLVertexAttrib2s | ( | GLuint | index,
 |  | GLshort | x,
 |  | GLshort | y
 | ) | [inline]

Replacement of glVertexAttrib2s.

void GLVertexAttrib2sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttrib2sv.

void GLVertexAttrib3d | ( | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [inline]

Replacement of glVertexAttrib3d.

void GLVertexAttrib3dv | ( | GLuint | index,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glVertexAttrib3dv.

void GLVertexAttrib3f | ( | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [inline]

Replacement of glVertexAttrib3f.

void GLVertexAttrib3fv | ( | GLuint | index,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glVertexAttrib3fv.

void GLVertexAttrib3h | ( | GLuint | index,
 |  | GLhalf | x,
 |  | GLhalf | y,
 |  | GLhalf | z
 | ) | [inline]

Replacement of glVertexAttrib3h.

void GLVertexAttrib3hv | ( | GLuint | index,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glVertexAttrib3hv.

void GLVertexAttrib3s | ( | GLuint | index,
 |  | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z
 | ) | [inline]

Replacement of glVertexAttrib3s.

void GLVertexAttrib3sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttrib3sv.

void GLVertexAttrib4bv | ( | GLuint | index,
 |  | const GLbyte * | v
 | ) | [inline]

Replacement of glVertexAttrib3bv.

void GLVertexAttrib4d | ( | GLuint | index,
 |  | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [inline]

Replacement of glVertexAttrib4d.

void GLVertexAttrib4dv | ( | GLuint | index,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glVertexAttrib4dv.

void GLVertexAttrib4f | ( | GLuint | index,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [inline]

Replacement of glVertexAttrib4f.

void GLVertexAttrib4fv | ( | GLuint | index,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glVertexAttrib4fv.

void GLVertexAttrib4h | ( | GLuint | index,
 |  | GLhalf | x,
 |  | GLhalf | y,
 |  | GLhalf | z,
 |  | GLhalf | w
 | ) | [inline]

Replacement of glVertexAttrib4h.

void GLVertexAttrib4hv | ( | GLuint | index,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glVertexAttrib4hv.

void GLVertexAttrib4iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glVertexAttrib4iv.

void GLVertexAttrib4s | ( | GLuint | index,
 |  | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z,
 |  | GLshort | w
 | ) | [inline]

Replacement of glVertexAttrib4s.

void GLVertexAttrib4sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttrib4sv.

void GLVertexAttrib4ub | ( | GLuint | index,
 |  | GLubyte | x,
 |  | GLubyte | y,
 |  | GLubyte | z,
 |  | GLubyte | w
 | ) | [inline]

Replacement of glVertexAttrib4ub.

void GLVertexAttrib4ubv | ( | GLuint | index,
 |  | const GLubyte * | v
 | ) | [inline]

Replacement of glVertexAttrib4ubv.

void GLVertexAttrib4uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [inline]

Replacement of glVertexAttrib4uiv.

void GLVertexAttrib4usv | ( | GLuint | index,
 |  | const GLushort * | v
 | ) | [inline]

Replacement of glVertexAttrib4usv.

void GLVertexAttrib4Nbv | ( | GLuint | index,
 |  | const GLbyte * | v
 | ) | [inline]

Replacement of glVertexAttrib4Nbv.

void GLVertexAttrib4Niv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glVertexAttrib4Niv.

void GLVertexAttrib4Nsv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttrib4Nsv.

void GLVertexAttrib4Nub | ( | GLuint | index,
 |  | GLubyte | x,
 |  | GLubyte | y,
 |  | GLubyte | z,
 |  | GLubyte | w
 | ) | [inline]

Replacement of glVertexAttrib4Nub.

void GLVertexAttrib4Nubv | ( | GLuint | index,
 |  | const GLubyte * | v
 | ) | [inline]

Replacement of glVertexAttrib4Nubv.

void GLVertexAttrib4Nuiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [inline]

Replacement of glVertexAttrib4Nuiv.

void GLVertexAttrib4Nusv | ( | GLuint | index,
 |  | const GLushort * | v
 | ) | [inline]

Replacement of glVertexAttrib4Nusv.

void GLVertexAttribI1i | ( | GLuint | index,
 |  | GLint | x
 | ) | [inline]

Replacement of glVertexAttribI1iEXT.

void GLVertexAttribI2i | ( | GLuint | index,
 |  | GLint | x,
 |  | GLint | y
 | ) | [inline]

Replacement of glVertexAttribI2iEXT.

void GLVertexAttribI3i | ( | GLuint | index,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [inline]

Replacement of glVertexAttribI3iEXT.

void GLVertexAttribI4i | ( | GLuint | index,
 |  | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [inline]

Replacement of glVertexAttribI4iEXT.

void GLVertexAttribI1ui | ( | GLuint | index,
 |  | GLuint | x
 | ) | [inline]

Replacement of glVertexAttribI1uiExt.

void GLVertexAttribI2ui | ( | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y
 | ) | [inline]

Replacement of glVertexAttribI2uiExt.

void GLVertexAttribI3ui | ( | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y,
 |  | GLuint | z
 | ) | [inline]

Replacement of glVertexAttribI3uiExt.

void GLVertexAttribI4ui | ( | GLuint | index,
 |  | GLuint | x,
 |  | GLuint | y,
 |  | GLuint | z,
 |  | GLuint | w
 | ) | [inline]

Replacement of glVertexAttribI4uiExt.

void GLVertexAttribI1iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glVertexAttribI1ivEXT.

void GLVertexAttribI2iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glVertexAttribI2ivEXT.

void GLVertexAttribI3iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glVertexAttribI3ivEXT.

void GLVertexAttribI4iv | ( | GLuint | index,
 |  | const GLint * | v
 | ) | [inline]

Replacement of glVertexAttribI4ivEXT.

void GLVertexAttribI1uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [inline]

Replacement of glVertexAttribI1iuvEXT.

void GLVertexAttribI2uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [inline]

Replacement of glVertexAttribI2uivEXT.

void GLVertexAttribI3uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [inline]

Replacement of glVertexAttribI3uivEXT.

void GLVertexAttribI4uiv | ( | GLuint | index,
 |  | const GLuint * | v
 | ) | [inline]

Replacement of glVertexAttribI4uivEXT.

void GLVertexAttribI4bv | ( | GLuint | index,
 |  | const GLbyte * | v
 | ) | [inline]

Replacement of glVertexAttribI4bvEXT.

void GLVertexAttribI4ubv | ( | GLuint | index,
 |  | const GLubyte * | v
 | ) | [inline]

Replacement of glVertexAttribI4ubvEXT.

void GLVertexAttribI4sv | ( | GLuint | index,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttribI4svEXT.

void GLVertexAttribI4usv | ( | GLuint | index,
 |  | const GLushort * | v
 | ) | [inline]

Replacement of glVertexAttribI4usvEXT.

void GLVertexAttribIPointer | ( | GLuint | index,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glVertexAttribIPointerEXT.

void GLVertexAttribPointer | ( | GLuint | index,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLboolean | normalize,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glVertexAttribPointer.

void GLVertexAttribPointerNV | ( | GLuint | index,
 |  | GLint | fsize,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glVertexAttribPointerNV.

void GLVertexAttribs1dvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glVertexAttribs1dvNV.

void GLVertexAttribs1fvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glVertexAttribs1fvNV.

void GLVertexAttribs1hv | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glVertexAttribs1hv.

void GLVertexAttribs1svNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttribs1svNV.

void GLVertexAttribs2dvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glVertexAttribs2dvNV.

void GLVertexAttribs2fvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glVertexAttribs2fvNV.

void GLVertexAttribs2hv | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glVertexAttribs2hv.

void GLVertexAttribs2svNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttribs2svNV.

void GLVertexAttribs3dvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glVertexAttribs3dvNV.

void GLVertexAttribs3fvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glVertexAttribs3fvNV.

void GLVertexAttribs3hv | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glVertexAttribs3hv.

void GLVertexAttribs3svNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttribs3svNV.

void GLVertexAttribs4dvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLdouble * | v
 | ) | [inline]

Replacement of glVertexAttribs4dvNV.

void GLVertexAttribs4fvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLfloat * | v
 | ) | [inline]

Replacement of glVertexAttribs4fvNV.

void GLVertexAttribs4hv | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLhalf * | v
 | ) | [inline]

Replacement of glVertexAttribs4hv.

void GLVertexAttribs4svNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLshort * | v
 | ) | [inline]

Replacement of glVertexAttribs4svNV.

void GLVertexAttribs4ubvNV | ( | GLuint | index,
 |  | GLsizei | count,
 |  | const GLubyte * | v
 | ) | [inline]

Replacement of glVertexAttribs4svNV.

void GLVertexPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) | [inline]

Replacement of glVertexPointer.

This function caches the vertex pointer setting and asserts on the result before returning.

void GLViewport | ( | GLint | x,
 |  | GLint | y,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glViewport.

This function asserts on the result before returning.

void GLWindowBackBufferHint ( ) [inline]

Replacement of glWindowBackBufferHintAutodesk.

void GLWindowPos2d | ( | GLdouble | x,
 |  | GLdouble | y
 | ) | [inline]

Replacement of glWindowPos2d.

This function asserts on the result before returning.

void GLWindowPos2dv ( const GLdouble * p ) [inline]

Replacement of glWindowPos2dv.

This function asserts on the result before returning.

void GLWindowPos2f | ( | GLfloat | x,
 |  | GLfloat | y
 | ) | [inline]

Replacement of glWindowPos2f.

This function asserts on the result before returning.

void GLWindowPos2fv ( const GLfloat * p ) [inline]

Replacement of glWindowPos2fv.

This function asserts on the result before returning.

void GLWindowPos2i | ( | GLint | x,
 |  | GLint | y
 | ) | [inline]

Replacement of glWindowPos2i.

This function asserts on the result before returning.

void GLWindowPos2iv ( const GLint * p ) [inline]

Replacement of glWindowPos2iv.

This function asserts on the result before returning.

void GLWindowPos2s | ( | GLshort | x,
 |  | GLshort | y
 | ) | [inline]

Replacement of glWindowPos2s.

This function asserts on the result before returning.

void GLWindowPos2sv ( const GLshort * p ) [inline]

Replacement of glWindowPos2sv.

This function asserts on the result before returning.

void GLWindowPos3d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [inline]

Replacement of glWindowPos3d.

This function asserts on the result before returning.

void GLWindowPos3dv ( const GLdouble * p ) [inline]

Replacement of glWindowPos3dv.

This function asserts on the result before returning.

void GLWindowPos3f | ( | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z
 | ) | [inline]

Replacement of glWindowPos3f.

This function asserts on the result before returning.

void GLWindowPos3fv ( const GLfloat * p ) [inline]

Replacement of glWindowPos3fv.

This function asserts on the result before returning.

void GLWindowPos3i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [inline]

Replacement of glWindowPos3i.

This function asserts on the result before returning.

void GLWindowPos3iv ( const GLint * p ) [inline]

Replacement of glWindowPos3iv.

This function asserts on the result before returning.

void GLWindowPos3s | ( | GLshort | x,
 |  | GLshort | y,
 |  | GLshort | z
 | ) | [inline]

Replacement of glWindowPos3s.

This function asserts on the result before returning.

void GLWindowPos3sv ( const GLshort * p ) [inline]

Replacement of glWindowPos3sv.

This function asserts on the result before returning.

GLboolean GLIsRenderbuffer ( GLuint renderbuffer ) [inline]

Replacement of glIsRenderbufferEXT.

Parameters:
renderbuffer The id to test.
Returns:
TRUE, if renderbuffer is the id of a render buffer, otherwise FALSE.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLRenderbufferStorage, GLGetRenderbufferParameteriv

void GLBindRenderbuffer | ( | GLenum | target,
 |  | GLuint | renderbuffer
 | ) | [inline]

Replacement of glBindRenderbufferEXT.

Parameters:
target | The id of the target to bind the render buffer to. Must be GL_RENDERBUFFER_EXT.
renderbuffer | The id of the unused render buffer to bind.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLRenderbufferStorage, GLGetRenderbufferParameteriv

void GLDeleteRenderbuffers | ( | GLsizei | n,
 |  | const GLuint * | renderbuffers
 | ) | [inline]

Replacement of glDeleteRenderbuffersEXT.

Parameters:
n | The number of render buffer ids to delete.
renderbuffers | A pointer to the render buffer ids to delete.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLGenRenderbuffers, GLRenderbufferStorage, GLGetRenderbufferParameteriv

void GLGenRenderbuffers | ( | GLsizei | n,
 |  | GLuint * | renderbuffers
 | ) | [inline]

Replacement of glGenRenderbuffersEXT.

Parameters:
n | The number of render buffer ids to generate.
renderbuffers | A pointer to the memory to fill with the generated render buffer ids.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLRenderbufferStorage, GLGetRenderbufferParameteriv

void GLRenderbufferStorage | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glRenderbufferStorageEXT.

Parameters:
target | Must be GL_RENDERBUFFER_EXT.
internalformat | Must be color-renderable, depth-renderable, or stencil-renderable.
width | The width of the render buffer in pixels.
height | The height of the render buffer in pixels.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLGetRenderbufferParameteriv

void GLRenderbufferStorageMultisample | ( | GLenum | target,
 |  | GLsizei | samples,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glRenderbufferStorageMultisampleEXT.

Parameters:
target | Must be GL_RENDERBUFFER_EXT.
samples | Is the number of multisample buffers you wish to allocate.
internalformat | Must be color-renderable, depth-renderable, or stencil-renderable.
width | The width of the render buffer in pixels.
height | The height of the render buffer in pixels.
Note:
It is assumed that the extension GL_EXT_framebuffer_multisample is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLGetRenderbufferParameteriv, GLRenderbufferStorage, GLRenderbufferStorageMultisampleCoverage

void GLRenderbufferStorageMultisampleCoverage | ( | GLenum | target,
 |  | GLsizei | coverageSamples,
 |  | GLsizei | colorSamples,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) | [inline]

Replacement of glRenderbufferStorageMultisampleCoverageNV.

Parameters:
target | Must be GL_RENDERBUFFER_EXT.
coverageSamples | Is the number of pseudo multisample buffers to allocate.
colorSamples | Is the number of multisample buffers to allocate.
internalformat | Must be color-renderable, depth-renderable, or stencil-renderable.
width | The width of the render buffer in pixels.
height | The height of the render buffer in pixels.
Note:
It is assumed that the extension GL_NV_framebuffer_multisample_coverage is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLGetRenderbufferParameteriv, GLRenderbufferStorage, GLRenderbufferStorageMultisampleCoverage

void GLGetRenderbufferParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetRenderbufferParameterivEXT.

Parameters:
target | Must be GL_RENDERBUFFER_EXT.
pname | The id of the value to get.
params | Pointer to the memory to write the queried value to.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsRenderbuffer, GLBindRenderbuffer, GLDeleteRenderbuffers, GLGenRenderbuffers, GLRenderbufferStorage

GLboolean GLIsFramebuffer ( GLuint framebuffer ) [inline]

Replacement of glIsFramebufferEXT.

Parameters:
framebuffer The id to test.
Returns:
TRUE, if framebuffer is the id of a frame buffer, otherwise FALSE.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

void GLBindFramebuffer | ( | GLenum | target,
 |  | GLuint | framebuffer
 | ) | [inline]

Replacement of glBindFramebufferEXT.

Parameters:
target | The id of the target to bind the frame buffer to. Must be GL_FRAMEBUFFER_EXT.
framebuffer | The id of the unused frame buffer to bind.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

void GLDeleteFramebuffers | ( | GLsizei | n,
 |  | const GLuint * | framebuffers
 | ) | [inline]

Replacement of glDeleteFramebuffersEXT.

Parameters:
n | The number of frame buffer ids to delete.
framebuffers | A pointer to the frame buffer ids to delete.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

void GLGenFramebuffers | ( | GLsizei | n,
 |  | GLuint * | framebuffers
 | ) | [inline]

Replacement of glGenFramebuffersEXT.

Parameters:
n | The number of frame buffer ids to generate.
framebuffers | A pointer to the memory to fill with the generated frame buffer ids.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

GLenum GLCheckFramebufferStatus ( GLenum target ) [inline]

Replacement of glCheckFramebufferStatusEXT.

Parameters:
target Must be GL_FRAMEBUFFER_EXT.
Returns:
A symbolic value describing the frame buffer status.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

void GLFramebufferTexture1D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level
 | ) | [inline]

Replacement of glFramebufferTexture1DEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
textarget | The texture target.
texture | The id of an existing texture with an target of textarget.
level | The mipmap level of the texture image to be attached.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferTextureLayer GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

void GLFramebufferTexture2D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level
 | ) | [inline]

Replacement of glFramebufferTexture2DEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
textarget | The texture target.
texture | The id of an existing texture with an target of textarget.
level | The mipmap level of the texture image to be attached.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture3D, GLFramebufferTextureLayer GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

void GLFramebufferTexture3D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLint | zoffset
 | ) | [inline]

Replacement of glFramebufferTexture3DEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
textarget | The texture target.
texture | The id of an existing texture with an target of textarget.
level | The mipmap level of the texture image to be attached.
zoffset | Specifies the z-offset of a 2-dimensional image within a 3-dimensional texture.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTextureLayer GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

void GLFramebufferTextureLayer | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLint | layer
 | ) | [inline]

Replacement of glFramebufferTextureLayerEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
texture | The id of an existing texture.
level | The mipmap level of the texture image to be attached.
layer | Specifies the layer/slice of the texture array - or slice of 3D texture.
Note:
It is assumed that the extension GL_EXT_texture_array is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferRenderbuffer, GLGetFramebufferAttachmentParameteriv

void GLFramebufferRenderbuffer | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | renderbuffertarget,
 |  | GLuint | renderbuffer
 | ) | [inline]

Replacement of glFramebufferRenderbufferEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
renderbuffertarget | Must be GL_RENDERBUFFER_EXT.
renderbuffer | The id of the render buffer to be attached to the frame buffer.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLGetFramebufferAttachmentParameteriv

void GLGetFramebufferAttachmentParameteriv | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetFramebufferAttachmentParameterivEXT.

Parameters:
target | Must be GL_FRAMEBUFFER_EXT.
attachment | One of the attachment points of the frame buffer.
pname | The symbolic values of the attachment parameters to query.
params | A pointer to the memory where result of the query is written to.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

See also:
GLIsFramebuffer, GLBindFramebuffer, GLDeleteFramebuffers, GLGenFramebuffers, GLCheckFramebufferStatus, GLFramebufferTexture1D, GLFramebufferTexture2D, GLFramebufferTexture3D, GLFramebufferRenderbuffer

void GLGenerateMipmap ( GLenum target ) [inline]

Replacement of glGenerateMipmapEXT.

Parameters:
target The symbolic value of the texture target to generate mipmaps for.
Note:
It is assumed that the extension GL_EXT_framebuffer_object is supported.

This function asserts on no GL error.

GLenum GLGetTexWrapMode ( nvsg::TextureWrapMode twm ) [inline]

Translate an nvsg::TextureWrapMode into a GL-specific texture wrap mode as a GLenum.

Parameters:
twm The TextureWrapMode to translate.
Returns:
The OpenGL-specific GLenum being a 'best match' of the nvsg::TextureWrapMode.

bool WGLInitializeExtensions ( void ) [inline]

Initialize the wgl-extension functions inside the WGLFunctions class.

Remarks:
This doesn't need to be called more than once from a hardware OpenGL context to make the extended wgl-interface functions available globally to the process (but it can handle being called more than once). The WGL-wrapper functions below don't depend on any GLContext. This returns false if the wglGetExtensionsStringEXT function pointer is not found.

bool WGLIsExtensionAvailable ( const std::string & extstr ) [inline]

Returns whether the specified wgl-extension is available.

Parameters:
extstr Designates the requested wgl-extension.
Returns:
The function returns true if the requested wgl-extension is available and if the corresponding function pointer are initialized properly. Otherwise the function returns false. The function always returns false if called prior to WGLInitializeExtensions.
Remarks:
WGLIsExtensionAvailable should not be called prior to WGLInitializeExtension. Doing so would be entirely meaningless and the function would always return false. It is recommended to test whether a requested wgl-extension is available on the current configuration prior to exploit the specified wgl-extension. Using a not available wgl-extension through the 'WGL' wrapper function provided by the NVSG SDK results in unexpected behavior.
See also:
WGLInitializeExtensions

bool WGLIsExtensionExported ( const std::string & extstr ) [inline]

Returns whether the specified wgl-extension is exported.

Parameters:
extstr Designates the requested wgl-extension.
Returns:
The function returns true if the requested wgl-extension is exported by the current configuration. Otherwise the function returns false. The function always returns false if called prior to WGLInitializeExtensions.
Remarks:
WGLIsExtensionExported should not be called prior to WGLInitializeExtension. Doing so would be entirely meaningless and the function would always return false. If a wgl-extension defines new functions, WGLIsExtensionAvailable should be called instead of WGLIsExtensionExported to ensure that all required function pointers are properly initialized.
See also:
WGLInitializeExtensions, WGLIsExtensionAvailable

BOOL WGLBindTexImage | ( | HPBUFFERARB | hPbuffer,
 |  | int | iBuffer
 | ) | [inline]

Replacement of wglBindTexImageARB.

This function hides the extension character of wglBindTexImageARB and asserts on its result before returning.

BOOL WGLChoosePixelFormat | ( | HDC | hdc,
 |  | const int * | piAttribIList,
 |  | const FLOAT * | pfAttribFList,
 |  | UINT | nMaxFormats,
 |  | int * | piFormats,
 |  | UINT * | nNumFormats
 | ) | [inline]

Replacement of wglChoosePixelFormatARB.

This function hides the extension character of wglChoosePixelFormatARB and asserts on its result before returning.

HGLRC WGLCreateContext ( HDC hdc ) [inline]

Replacement of wglCreateContext.

If this function is used in conjunction with WGLCreateContext, WGLMakeCurrent, and the functions with uppercase GL prefix, then the states and attributes are cached per context. Moreover, the extension functions of OpenGL are used per context (as they really should!).

HPBUFFERARB WGLCreatePbuffer | ( | HDC | hdc,
 |  | int | pixelFormat,
 |  | int | width,
 |  | int | height,
 |  | const int * | attribList
 | ) | [inline]

Replacement of wglCreatePbufferARB.

This function hides the extension character of wglCreatePbufferARB.

Note:
The creation of a PBuffer might fail dependent on available hardware resources. In this case a NULL handle will be returned.

BOOL WGLDeleteContext ( HGLRC hglrc ) [inline]

Replacement of wglDeleteContext.

If this function is used in conjunction with WGLDeleteContext, WGLMakeCurrent, and functions with uppercase 'GL' prefix, the states and attributes are cached per context. Moreover, OpenGL extension functions are used per context (as they really should!).

BOOL WGLDestroyPbuffer ( HPBUFFERARB hPbuffer ) [inline]

Replacement of wglDestroyPbufferARB.

This function hides the extension character of wglDestroyPbufferARB and asserts on its result before returning.

HGLRC WGLGetCurrentContext ( void ) [inline]

Replacement for wglGetCurrenContext.

The function obtains a handle to the current OpenGL rendering context of the calling thread.

Returns:
A handle to the current OpenGL context of the calling thread, or NULL if the calling thread has no current OpenGL context.

HDC WGLGetCurrentDC ( void ) [inline]

Replacement for wglGetCurrentDC.

The function obtains a handle to the device context that is associated with the current OpenGL rendering context of the calling thread.

Returns:
A handle to the device context which is currently associated with the current OpenGL context of the calling thread by means of WGLMakeCurrent, or NULL if the calling thread has no current OpenGL context.

HDC WGLGetPbufferDC ( HPBUFFERARB hPbuffer ) [inline]

Replacement of wglGetPbufferDCARB.

This function hides the extension character of wglGetPbufferDCARB and asserts on its result before returning.

BOOL WGLQueryPbuffer | ( | HPBUFFERARB | hPbuffer,
 |  | int | attribute,
 |  | int * | value
 | ) | [inline]

Replacement of wglQueryPbufferARB.

This function hides the extension character of wglQueryPbufferARB and asserts on its result before returning.

int WGLReleasePbufferDC | ( | HPBUFFERARB | hPbuffer,
 |  | HDC | hdc
 | ) | [inline]

Replacement of wglReleasePbufferDCARB.

This function hides the extension character of wglReleasePbufferDCARB and asserts on its result before returning.

BOOL WGLReleaseTexImage | ( | HPBUFFERARB | hPbuffer,
 |  | int | iBuffer
 | ) | [inline]

Replacement of wglReleaseTexImageARB.

This function hides the extension character of wglReleaseTexImageARB and asserts on its result before returning.

BOOL WGLJoinSwapGroupNV | ( | HDC | hDC,
 |  | GLuint | group
 | ) | [inline]

Replacement of wglJointSwapGroupNV.

BOOL WGLBindSwapBarrierNV | ( | GLuint | group,
 |  | GLuint | barrier
 | ) | [inline]

Replacement of wglBindSwapBarrierNV.

BOOL WGLQuerySwapGroupNV | ( | HDC | hDC,
 |  | GLuint * | group,
 |  | GLuint * | barrier
 | ) | [inline]

Replacement of wglQuerySwapGroupNV.

BOOL WGLQueryMaxSwapGroupsNV | ( | HDC | hDC,
 |  | GLuint * | maxGroups,
 |  | GLuint * | maxBarriers
 | ) | [inline]

Replacement of wglQueryMaxSwapGroupsNV.

BOOL WGLQueryFrameCountNV | ( | HDC | hDC,
 |  | GLuint * | count
 | ) | [inline]

Replacement of wglQueryFrameCountNV.

BOOL WGLResetFrameCountNV ( HDC hDC ) [inline]

Replacement of wglResetFrameCountNV.

BOOL WGLEnumGpus | ( | UINT | iIndex,
 |  | HGPUNV * | hGpu
 | ) | [inline]

Replacement of wglEnumGpusNV.

BOOL WGLEnumGpuDevices | ( | HGPUNV | hGpu,
 |  | UINT | iIndex,
 |  | PGPU_DEVICE | pGpuDevice
 | ) | [inline]

Replacement of wglEnumGpuDevicesNV.

HDC WGLCreateAffinityDC ( const HGPUNV * pGpuList ) [inline]

Replacement for wglCreateAffinityDVNV.

BOOL WGLEnumGpusFromAffinityDC | ( | HDC | hAffinityDC,
 |  | UINT | iIndex,
 |  | HGPUNV * | hGpu
 | ) | [inline]

Replacement for wglEnumGpusFromAffinityDCNV.

BOOL WGLDeleteDC ( HDC hAffinityDC ) [inline]

Replacement for wglDeleteDCNV.

BOOL WGLGetVideoDevice | ( | HDC | hDC,
 |  | INT | iVideoStreams,
 |  | HPVIDEODEVICE * | phpVideoDevice
 | ) | [inline]

Replacement for wglGetVideoDeviceNV.

BOOL WGLReleaseVideoDevice ( HPVIDEODEVICE hpVideoDevice ) [inline]

Replacement for wglReleaseVideoDeviceNV.

BOOL WGLBindVideoImage | ( | HPVIDEODEVICE | hpVideoDevice,
 |  | HPBUFFERARB | hPbuffer,
 |  | INT | iVideoBuffer
 | ) | [inline]

Replacement for wglBindVideoImageNV.

BOOL WGLReleaseVideoImage | ( | HPBUFFERARB | hPbuffer,
 |  | INT | iVideoBuffer
 | ) | [inline]

Replacement for wglReleaseVideoImageNV.

BOOL WGLSendPbufferToVideo | ( | HPBUFFERARB | hPbuffer,
 |  | INT | iBufferType,
 |  | unsigned long * | pulCounterPbuffer,
 |  | BOOL | bBlock
 | ) | [inline]

Replacement for wglSendPbufferToVideoNV.

BOOL WGLGetVideoInfo | ( | HPVIDEODEVICE | hpVideoDevice,
 |  | unsigned long * | pulCounterOutputVideo,
 |  | unsigned long * | pulCounterOutputPbuffer
 | ) | [inline]

Replacement for wglGetVideoInfoNV.

bool GLXInitializeExtensions ( Display * dpy ) [inline]

Initialize the glx-extension functions inside the GLXFunctions class.

Remarks:
This doesn't need to be called more than once from a hardware OpenGL context to make the extended glx-interface functions available globally to the process (but it can handle being called more than once). The GLX-wrapper functions below don't depend on any GLContext. This function returns false if dpy is NULL.

bool GLXIsExtensionAvailable ( const std::string & extstr ) [inline]

Returns whether the specified glx-extension is available.

Parameters:
extstr Designates the requested glx-extension.
Returns:
The function returns true if the requested glx-extension is available and if the corresponding function pointer are initialized properly. Otherwise the function returns false. The function always returns false if called prior to GLXInitializeExtensions.
Remarks:
GLXIsExtensionAvailable should not be called prior to GLXInitializeExtension. Doing so would be entirely meaningless and the function would always return false. It is recommended to test whether a requested glx-extension is available on the current configuration prior to exploit the specified glx-extension. Using a not available glx-extension through the 'GLX' wrapper function provided by the NVSG SDK results in unexpected behavior.
See also:
GLXInitializeExtensions

bool GLXIsExtensionExported ( const std::string & extstr ) [inline]

Returns whether the specified glx-extension is exported.

Parameters:
extstr Designates the requested glx-extension.
Returns:
The function returns true if the requested glx-extension is exported by the current configuration. Otherwise the function returns false. The function always returns false if called prior to GLXInitializeExtensions.
Remarks:
GLXIsExtensionExported should not be called prior to GLXInitializeExtension. Doing so would be entirely meaningless and the function would always return false. If a glx-extension defines new functions, GLXIsExtensionAvailable should be called instead of GLXIsExtensionExported to ensure that all required function pointers are properly initialized.
See also:
GLXInitializeExtensions, GLXIsExtensionAvailable

GLXContext GLXCreateContext | ( | Display * | dpy,
 |  | XVisualInfo * | vis,
 |  | GLXContext | shareList,
 |  | Bool | direct
 | ) | [inline]

Replacement of glXCreateContext.

void GLXDestroyContext | ( | Display * | dpy,
 |  | GLXContext | ctx
 | ) | [inline]

Replacement of glXDestroyContext.

GLXContext GLXGetCurrentContext ( ) [inline]

Replacement of glXGetCurrentContext.

GLXDrawable GLXGetCurrentDrawable ( ) [inline]

Replacement of glXGetCurrentDrawable.

NVSG_API void GLGenVertexBuffer | ( | GLenum | target,
 |  | GLsizeiptr | size,
 |  | GLuint * | buffer
 | ) |

Generates a vertex buffer of requested size.

The function creates a buffer object for vertex data and returns the buffer identifier in the buffer pointed to by buffer.

NVSG_API void GLGenIndexBuffer | ( | GLenum | target,
 |  | GLsizeiptr | size,
 |  | GLuint * | buffer
 | ) |

Generates an index buffer of requested size.

The function creates a buffer object for index data and returns the buffer identifier in the buffer pointed to by buffer.

NVSG_API void GLDeleteVertexBuffer ( GLuint buffer )

Deletes a vertex buffer.

The function deletes the buffer object identified by buffer. The behavior is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenVertexBuffer.

NVSG_API void GLDeleteIndexBuffer ( GLuint buffer )

Deletes an index buffer.

The function deletes the buffer object identified by buffer. The behavior is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenIndexBuffer.

NVSG_API void GLBindVertexBuffer ( GLuint buffer )

Binds the buffer name associated with the identifier buffer to the GL_ARRAY_ELEMENT target.

The behavior is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenVertexBuffer.

NVSG_API void GLBindTransformFeedbackBuffer | ( | GLuint | index,
 |  | GLuint | buffer,
 |  | GLuint | offset
 | ) |

Binds the buffer name associated with the identifier buffer to the GL_TRANSFORM_FEEDBACK_BUFFER_NV target.

The behavior is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenVertexBuffer.

Note:
This method actually calls GLBindBufferOffset()

NVSG_API void GLBindIndexBuffer ( GLuint buffer )

Binds the buffer name associated with the identifier buffer to the GL_ELEMENT_ARRAY_ELEMENT target.

The behavior is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenIndexBuffer.

NVSG_API void GLUploadBuffers ( )

Uploads all pending buffers.

The function uploads the data copied to not yet uploaded vertex or index buffers to Vertex Buffer Objects (VBO) for fast rendering.

Note:
This function must be called immediately before rendering if vertex or index buffers are used for caching strategies. Omitting this call certainly results in undefined runtime behavior!

NVSG_API GLvoid* GLMapVertexBuffer ( GLuint buffer )

Maps the vertex buffer identified by buffer into process memory for write-only access.

The returned pointer can be used to write vertex data to the vertex buffer.

Attempts to read back data from the mapped buffer might result in undefined behavior. Writing more bytes to the buffer than it was specified at buffer creation, results in undefined behavior. The behavior also is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenVertexBuffer.

After data has been written to the buffer, and before the data will be dereferenced by any GL commands, the mapping must be relinquished by calling GLUnmapVertexData.

Returns:
A pointer to the vertex buffer if the memory could be mapped into process memory. Otherwise a null pointer is returned.

NVSG_API GLvoid* GLMapIndexBuffer ( GLuint buffer )

Maps the index buffer identified by buffer into process memory for write-only access.

The returned pointer can be used to write index data to the vertex buffer.

Attempts to read back data from the mapped buffer might result in undefined behavior. Writing more bytes to the buffer than it was specified at buffer creation, results in undefined behavior. The behavior also is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenVertexBuffer.

After data has been written to the buffer, and before the data will be dereferenced by any GL commands, the mapping must be relinquished by calling GLUnmapIndexData.

Returns:
A pointer to the index buffer if the memory could be mapped into process memory. Otherwise a null pointer is returned.

NVSG_API GLboolean GLUnmapVertexBuffer ( GLuint buffer )

Relinquishes a vertex buffer mapping.

The function relinquishes the mapping for the buffer identified by buffer. The behavior is undefined if a mapping for the specified buffer was not initiated before by a call to GLMapVertexBuffer. The behavior also is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenVertexBuffer.

Returns:
The function returns GL_TRUE unless data values in the data store of the buffer have become corrupted during the period that the buffer was mapped.

NVSG_API GLboolean GLUnmapIndexBuffer ( GLuint buffer )

Relinquishes an index buffer mapping.

The function relinquishes the mapping for the buffer identified by buffer. The behavior is undefined if a mapping for the specified buffer was not initiated before by a call to GLMapIndexBuffer. The behavior also is undefined if an invalid identifier is passed through buffer, that is - an identifier that was not returned by GLGenIndexBuffer.

Returns:
The function returns GL_TRUE unless data values in the data store of the buffer have become corrupted during the period that the buffer was mapped.

NVSG_API GLsizeiptr GLGetVertexBufferOffset ( GLuint buffer )

Returns the start offset for the specified buffer.

Vertex buffers might be collected in a higher-level buffer object. This function returns the start offset inside the higher-level buffer object.

Returns:
The start offset inside the higher-level vertex buffer object.

NVSG_API void GLBuildVertexBufferCache | ( | nvgl::GLArrayBufferCache * | vi,
 |  | GLuint | whichBuffer,
 |  | const nvsg::VertexAttributeSet * | vas
 | ) |

VBO / Cache Filling Methods.

Build the caches from the attributes sent.

Returns:
A buffer cache.

NVSG_API GLsizeiptr GLGetIndexBufferOffset ( GLuint buffer )

Returns the start offset for the specified buffer.

Index buffers might be collected in a higher-level buffer object. This function returns the start offset inside the higher-level buffer object.

Returns:
The start offset inside the higher-level vertex buffer object.

NVSG_API GLboolean GLIsVertexBuffer ( GLuint buffer )

Returns whether buffer identifies a valid vertex buffer for the current context.

Returns:
GL_TRUE if buffer identifies a valid vertex buffer for the current context. GL_FALSE otherwise.

NVSG_API GLboolean GLIsIndexBuffer ( GLuint buffer )

Returns whether buffer identifies a valid index buffer for the current context.

Returns:
GL_TRUE if buffer identifies a valid index buffer for the current context. GL_FALSE otherwise.

Variable Documentation

NVSG_API GLenum glError

holds the current OpenGL error code to ease debugging

Generated on Tue Jan 15 10:28:50 2008 for NVSGSDK by NVIDIA


nvmath Namespace Reference

Namespace for mathematical helper functions and classes. More...

Classes

class | Boxnt
Represents an axis-aligned box. More...

class | Matnnt
Matrix class of fixed size and type. More...

class | Planent
Plane class. More...

class | Quatt
Quaternion class. More...

class | Spherent
Sphere class. More...

class | Trafo
Transformation class. More...

class | Vecnt
Vector class of fixed size and type. More...

Typedefs

typedef Boxnt< 3, float > | Box3f
typedef Boxnt< 3, double > | Box3d
typedef Matnnt< 3, float > | Mat33f
typedef Matnnt< 3, double > | Mat33d
typedef Matnnt< 4, float > | Mat44f
typedef Matnnt< 4, double > | Mat44d
typedef Planent< 3, float > | Plane3f
typedef Planent< 3, double > | Plane3d
typedef Quatt< float > | Quatf
typedef Quatt< double > | Quatd
typedef Spherent< 3, float > | Sphere3f
typedef Spherent< 3, double > | Sphere3d
typedef Vecnt< 2, float > | Vec2f
typedef Vecnt< 2, double > | Vec2d
typedef Vecnt< 3, float > | Vec3f
typedef Vecnt< 3, double > | Vec3d
typedef Vecnt< 4, float > | Vec4f
typedef Vecnt< 4, double > | Vec4d

Functions

template<unsigned int n, typename T> Boxnt< n, T > | boundingBox (const Vecnt< n, T > *points, unsigned int numberOfPoints)
Instantiates an axis-aligned bounding box from a set of points.

template<unsigned int n, typename T> Boxnt< n, T > | boundingBox (const Vecnt< n, T > *points, const unsigned int *indices, unsigned int numberOfIndices)
Instantiates an axis-aligned bounding box from a set of points.

template<unsigned int n, typename T> Boxnt< n, T > | boundingBox (const Boxnt< n, T > &b0, const Boxnt< n, T > &b1)
Instantiates an axis-aligned bounding box as the union of two boxes.

template<unsigned int n, typename T> bool | isEmpty (const Boxnt< n, T > &bbox)
Tests if the specified bounding box is empty.

template<unsigned int n, typename T> bool | operator== (const Boxnt< n, T > &lhs, const Boxnt< n, T > &rhs)
Compares two bounding boxes.

template<unsigned int n, typename T> bool | operator!= (const Boxnt< n, T > &lhs, const Boxnt< n, T > &rhs)
Compares two bounding boxes.

template<unsigned int n, typename T> Boxnt< n, T > | boundingBox (const Vecnt< n, T > *points, const std::vector< unsigned int > *strips, unsigned int numberOfStrips)
template<unsigned int n, typename T> bool | isIdentity (const Matnnt< n, T > &m, T eps=std::numeric_limits< T >::epsilon())
Test if a matrix is the identity.

template<unsigned int n, typename T> bool | isNormalized (const Matnnt< n, T > &m, T eps=std::numeric_limits< T >::epsilon())
Test if a matrix is normalized.

template<unsigned int n, typename T> bool | isNull (const Matnnt< n, T > &m, T eps=std::numeric_limits< T >::epsilon())
Test if a matrix is null.

template<unsigned int n, typename T> bool | isOrthogonal (const Matnnt< n, T > &m, T eps=std::numeric_limits< T >::epsilon())
Test if a matrix is orthogonal.

template<unsigned int n, typename T> T | maxElement (const Matnnt< n, T > &m)
Get the value of the maximal absolute element of a matrix.

template<unsigned int n, typename T> T | minElement (const Matnnt< n, T > &m)
Get the value of the minimal absolute element of a matrix.

template<unsigned int n, typename T> bool | operator== (const Matnnt< n, T > &m0, const Matnnt< n, T > &m1)
Matrix equality operator.

template<unsigned int n, typename T> bool | operator!= (const Matnnt< n, T > &m0, const Matnnt< n, T > &m1)
Matrix inequality operator.

template<unsigned int n, typename T> Matnnt< n, T > | operator~ (const Matnnt< n, T > &m)
Matrix transpose operator.

template<unsigned int n, typename T> Matnnt< n, T > | operator+ (const Matnnt< n, T > &m0, const Matnnt< n, T > &m1)
Matrix addition operator.

template<unsigned int n, typename T> Matnnt< n, T > | operator- (const Matnnt< n, T > &m)
Matrix negation operator.

template<unsigned int n, typename T> Matnnt< n, T > | operator- (const Matnnt< n, T > &m0, const Matnnt< n, T > &m1)
Matrix subtraction operator.

template<unsigned int n, typename T> Matnnt< n, T > | operator * (const Matnnt< n, T > &m, T s)
Scalar multiplication operator.

template<unsigned int n, typename T> Matnnt< n, T > | operator * (T s, const Matnnt< n, T > &m)
Scalar multiplication operator.

template<unsigned int n, typename T> Vecnt< n, T > | operator * (const Matnnt< n, T > &m, const Vecnt< n, T > &v)
Vector multiplication operator.

template<unsigned int n, typename T> Vecnt< n, T > | operator * (const Vecnt< n, T > &v, const Matnnt< n, T > &m)
Vector multiplication operator.

template<unsigned int n, typename T> Matnnt< n, T > | operator * (const Matnnt< n, T > &m0, const Matnnt< n, T > &m1)
Matrix multiplication operator.

template<unsigned int n, typename T> Matnnt< n, T > | operator/ (const Matnnt< n, T > &m, T s)
Scalar division operator.

template<unsigned int n, typename T> void | setIdentity (Matnnt< n, T > &m)
Set a matrix to be the identity.

template<typename T> T | determinant (const Matnnt< 3, T > &m)
Determine the determinant of a 3 by 3 matrix.

template<typename T> bool | isRotation (const Matnnt< 3, T > &m, T eps=9 *std::numeric_limits< T >::epsilon())
Test if a 3 by 3 matrix represents a rotation.

template<typename T> Matnnt< 3, T > & | setMat (Matnnt< 3, T > &m, T m00, T m01, T m02, T m10, T m11, T m12, T m20, T m21, T m22)
Set the values of a 3 by 3 matrix by nine scalars.

template<typename T> Matnnt< 3, T > & | setMat (Matnnt< 3, T > &m, const Vecnt< 3, T > &v0, const Vecnt< 3, T > &v1, const Vecnt< 3, T > &v2)
Set the values of a 3 by 3 matrix by three vectors.

template<typename T> Matnnt< 3, T > & | setMat (Matnnt< 3, T > &m, const Quatt< T > &q)
Set the values of a 3 by 3 matrix using a normalized quaternion.

template<typename T> Matnnt< 3, T > & | setMat (Matnnt< 3, T > &m, const Vecnt< 3, T > &axis, T angle)
Set the values of a 3 by 3 matrix using a normalized rotation axis and an angle.

NVSG_API void | decompose (const Matnnt< 3, float > &m, Quatt< float > &orientation, Vecnt< 3, float > &scaling, Quatt< float > &scaleOrientation)
Decompose a 3 by 3 matrix.

template<typename T> Matnnt< 4, T > & | setMat (Matnnt< 4, T > &m, T m00, T m01, T m02, T m03, T m10, T m11, T m12, T m13, T m20, T m21, T m22, T m23, T m30, T m31, T m32, T m33)
Set the values of a 4 by 4 matrix by sixteen scalars.

template<typename T> Matnnt< 4, T > & | setMat (Matnnt< 4, T > &m, const Vecnt< 4, T > &v0, const Vecnt< 4, T > &v1, const Vecnt< 4, T > &v2, const Vecnt< 4, T > &v3)
Set the values of a 4 by 4 matrix by four vectors.

template<typename T> Matnnt< 4, T > & | setMat (Matnnt< 4, T > &m, const Quatt< T > &ori, const Vecnt< 3, T > &trans=Vecnt< 3, T >(0, 0, 0), const Vecnt< 3, T > &scale=Vecnt< 3, T >(1, 1, 1))
Set the values of a 4 by 4 matrix by the constituents of a transformation.

NVSG_API void | decompose (const Matnnt< 4, float > &m, Vecnt< 3, float > &translation, Quatt< float > &orientation, Vecnt< 3, float > &scaling, Quatt< float > &scaleOrientation)
Decompose a 4 by 4 matrix of floats.

template<> Matnnt< 4, float > | operator * (const Matnnt< 4, float > &m0, const Matnnt< 4, float > &m1)
template<class T> T | clamp (T v, T l, T u)
Template to clamp an object of type T to a lower and an upper limit.

template<typename T> T | degToRad (T angle)
Transform an angle in degrees to radians.

template<typename T> int | highestBit (T i)
Returns the highest bit set for the specified input value.

template<typename T> T | highestBitValue (T i)
Returns the highest bit value for the specified input value.

template<typename T> bool | isPowerOfTwo (T n)
Determine if an integer is a power of two.

template<typename T> T | lerp (float alpha, const T &v0, const T &v1)
Linear interpolation between two values v0 and v1.

template<typename T> void | lerp (float alpha, const T &v0, const T &v1, T &vr)
template<typename T> const T & | max (const T &a, const T &b, const T &c)
Determine the maximal value out of three.

template<typename T> const T & | min (const T &a, const T &b, const T &c)
Determine the minimal value out of three.

template<typename T> T | powerOfTwoAbove (T n)
Determine the smallest power of two equal to or larger than n.

template<typename T> T | powerOfTwoBelow (T n)
Determine the largest power of two equal to or smaller than n.

template<typename T> T | powerOfTwoNearest (T n)
Calculates the nearest power of two for the specified integer.

float | radToDeg (float angle)
Transform an angle in radian to degree.

template<typename T> int | sign (const T &t)
Determine the sign of a scalar.

template<typename T> T | square (const T &t)
Template to square an object of Type T.

template<typename T> int | compare (T lhs, T rhs)
Compares two numerical values.

template<> int | compare (float lhs, float rhs)
Compares two float values.

template<> int | compare (double lhs, double rhs)
Compares two double values.

template<unsigned int n, typename T> bool | areOnOppositeSides (const Planent< n, T > &pl, const Vecnt< n, T > &p0, const Vecnt< n, T > &p1)
Test if two points are on opposite sides of a plane.

template<unsigned int n, typename T> bool | areOnSameSide (const Planent< n, T > &pl, const Vecnt< n, T > &p0, const Vecnt< n, T > &p1)
Test if two points are on the same side of a plane.

template<unsigned int n, typename T> T | distance (const Planent< n, T > &pl, const Vecnt< n, T > &p)
Calculate the distance of a point to a plane.

template<unsigned int n, typename T> Vecnt< n, T > | nearestPoint (const Planent< n, T > &pl, const Vecnt< n, T > &p)
Calculate the point on a plane nearest to a give point.

template<unsigned int n, typename T> bool | operator== (const Planent< n, T > &pl0, const Planent< n, T > &pl1)
Test for equality of two planes.

template<unsigned int n, typename T> bool | operator!= (const Planent< n, T > &pl0, const Planent< n, T > &pl1)
Test for inequality of two planes.

template<unsigned int n, typename T> T | signedDistance (const Planent< n, T > &pl, const Vecnt< n, T > &p)
Calculate the signed distance of a point to a plane.

template<typename T> void | decompose (const Quatt< T > &q, Vecnt< 3, T > &axis, T &angle)
Decompose a quaternion into an axis and an angle.

template<typename T> T | distance (const Quatt< T > &q0, const Quatt< T > &q1)
Determine the distance between two quaternions.

template<typename T> bool | isNormalized (const Quatt< T > &q, T eps=std::numeric_limits< T >::epsilon())
Test if a quaternion is normalized.

template<typename T> bool | isNull (const Quatt< T > &q, T eps=std::numeric_limits< T >::epsilon())
Test if a quaternion is null.

template<typename T> T | magnitude (const Quatt< T > &q)
Determine the magnitude of a quaternion.

template<typename T> bool | operator== (const Quatt< T > &q0, const Quatt< T > &q1)
Quaternion equality operator.

template<typename T> bool | operator!= (const Quatt< T > &q0, const Quatt< T > &q1)
Quaternion inequality operator.

template<typename T> Quatt< T > | operator~ (const Quatt< T > &q)
Quaternion conjugation operator.

template<typename T> Quatt< T > | operator- (const Quatt< T > &q)
Negation operator.

template<typename T> Quatt< T > | operator * (const Quatt< T > &q0, const Quatt< T > &q1)
Quaternion multiplication operator.

template<typename T> Vecnt< 3, T > | operator * (const Quatt< T > &q, const Vecnt< 3, T > &v)
Quaternion multiplication operator with a vector.

template<typename T> Vecnt< 3, T > | operator * (const Vecnt< 3, T > &v, const Quatt< T > &q)
Vector multiplication operator with a quaternion.

template<typename T> Quatt< T > | operator/ (const Quatt< T > &q0, const Quatt< T > &q1)
Quaternion division operator.

NVSG_API Quatt< float > | lerp (float alpha, const Quatt< float > &q0, const Quatt< float > &q1)
Spherical linear interpolation between two quaternions q0 and q1.

template<unsigned int n, typename T> Spherent< n, T > | boundingSphere (const Vecnt< n, T > *points, unsigned int numberOfPoints)
Determine the bounding sphere of a number of points.

template<unsigned int n, typename T> Spherent< n, T > | boundingSphere (const Vecnt< n, T > *points, const unsigned int *indices, unsigned int numberOfIndices)
Determine the bounding sphere of a number of indexed points.

template<unsigned int n, typename T> Spherent< n, T > | boundingSphere (const Vecnt< n, T > *points, const std::vector< unsigned int > *strips, unsigned int numberOfStrips)
Determine the bounding sphere of a number of strip-indexed points.

template<unsigned int n, typename T> Spherent< n, T > | boundingSphere (const Spherent< n, T > &s, const Vecnt< n, T > &p)
Determine the bounding sphere of a sphere and a point.

template<unsigned int n, typename T> Spherent< n, T > | boundingSphere (const Spherent< n, T > &s0, const Spherent< n, T > &s1)
Determine the bounding sphere around two spheres.

template<unsigned int n, typename T> Spherent< n, T > | intersectingSphere (const Spherent< n, T > &s0, const Spherent< n, T > &s1)
Determine the bounding sphere of the intersection of two spheres.

template<unsigned int n, typename T> bool | isEmpty (const Spherent< n, T > &s)
Determine if a sphere is empty.

template<unsigned int n, typename T> bool | operator== (const Spherent< n, T > &s0, const Spherent< n, T > &s1)
Test for equality of two spheres.

template<unsigned int n, typename T> bool | operator!= (const Spherent< n, T > &s0, const Spherent< n, T > &s1)
Test for inequality of two spheres.

NVSG_API void | lerp (float alpha, const Trafo &t0, const Trafo &t1, Trafo &tr)
template<unsigned int n, typename T> void | boundingBox (const Vecnt< n, T > *points, size_t numberOfPoints, Vecnt< n, T > &min, Vecnt< n, T > &max)
Determine the bounding box of a number of points.

template<unsigned int n, typename T> bool | areOpposite (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1, T eps=std::numeric_limits< T >::epsilon())
Determine if two vectors point in opposite directions.

template<unsigned int n, typename T> bool | areOrthogonal (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1, T eps=2 *std::numeric_limits< T >::epsilon())
Determine if two vectors are orthogonal.

template<unsigned int n, typename T> bool | areOrthonormal (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1, T eps=2 *std::numeric_limits< T >::epsilon())
Determine if two vectors are orthonormal.

template<unsigned int n, typename T> bool | areSimilar (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1, T eps)
Determine if two vectors differ less than a given epsilon in each component.

template<unsigned int n, typename T> T | distance (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1)
Determine the distance between vectors.

template<unsigned int n, typename T> bool | isNormalized (const Vecnt< n, T > &v, T eps=std::numeric_limits< T >::epsilon())
Determine if a vector is normalized.

template<unsigned int n, typename T> bool | isNull (const Vecnt< n, T > &v, T eps=std::numeric_limits< T >::epsilon())
Determine if a vector is the null vector.

template<unsigned int n, typename T> T | length (const Vecnt< n, T > &v)
Determine the length of a vector.

template<unsigned int n, typename T> T | lengthSquared (const Vecnt< n, T > &v)
Determine the squared length of a vector.

template<unsigned int n, typename T> T | maxElement (const Vecnt< n, T > &v)
Determine the maximal element of a vector.

template<unsigned int n, typename T> T | minElement (const Vecnt< n, T > &v)
Determine the minimal element of a vector.

template<unsigned int n, typename T> T | normalize (Vecnt< n, T > &v)
Normalize a vector.

template<unsigned int n, typename T> bool | operator== (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1)
Test for equality of two vectors.

template<unsigned int n, typename T> bool | operator!= (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1)
Test for inequality of two vectors.

template<unsigned int n, typename T> Vecnt< n, T > | operator+ (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1)
Vector addition operator.

template<unsigned int n, typename T> Vecnt< n, T > | operator- (const Vecnt< n, T > &v)
Unary vector negation operator.

template<unsigned int n, typename T> Vecnt< n, T > | operator- (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1)
Vector subtraction operator.

template<unsigned int n, typename T> Vecnt< n, T > | operator * (const Vecnt< n, T > &v, T s)
Scalar multiplication of a vector.

template<unsigned int n, typename T> Vecnt< n, T > | operator * (T s, const Vecnt< n, T > &v)
Scalar multiplication of a vector.

template<unsigned int n, typename T> T | operator * (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1)
Vector multiplication.

template<unsigned int n, typename T> Vecnt< n, T > | operator/ (const Vecnt< n, T > &v, T s)
Scalar division of a vector.

template<unsigned int n, typename T> Vecnt< n, T > | orthonormalize (const Vecnt< n, T > &v0, const Vecnt< n, T > &v1)
Determine the orthonormal vector of v1 with respect to v0.

template<typename T> Vecnt< 2, T > & | setVec (Vecnt< 2, T > &v, T x, T y)
Set the values of a two-component vector.

template<typename T> bool | areCollinear (const Vecnt< 3, T > &v0, const Vecnt< 3, T > &v1, T eps=std::numeric_limits< T >::epsilon())
Determine if two vectors are collinear.

template<typename T> Vecnt< 3, T > | operator^ (const Vecnt< 3, T > &v0, const Vecnt< 3, T > &v1)
Cross product operator.

template<typename T> Vecnt< 3, T > & | setVec (Vecnt< 3, T > &v, T x, T y, T z)
Set the values of a three-component vector.

template<typename T> void | smoothNormals (const std::vector< Vecnt< 3, T > > &vertices, const Spherent< 3, T > &sphere, T creaseAngle, std::vector< Vecnt< 3, T > > &normals)
Determine smoothed normals for a set of vertices.

template<typename T> Vecnt< 4, T > & | setVec (Vecnt< 4, T > &v, T x, T y, T z, T w)
Set the values of a four-component vector.

template<unsigned int n> float | normalize (Vecnt< n, float > &v)
template<typename T> Vecnt< 3, T > | orthonormalize (const Vecnt< 3, T > &v0, const Vecnt< 3, T > &v1)
template<typename T> size_t | _hash (const Vecnt< 3, T > &vertex, const Vecnt< 3, T > &base, const Vecnt< 3, T > &scale, size_t numVertices)
NVSG_API void | lerp (float alpha, const nvsg::VertexAttribute &va0, const nvsg::VertexAttribute &va1, nvsg::VertexAttribute &var)
Linear interpolation between two VertexAttributes.

nvsg::VNVector | lerp (float alpha, const nvsg::VNVector &v0, const nvsg::VNVector &v1)
Linear interpolation between two VNVector.

Variables

NVSG_API const Mat44f | cIdentity44f
global identity matrix.

const float | PI = 3.14159265358979323846f
constant PI

const float | PI_HALF = 1.57079632679489661923f
constant PI half

const float | PI_QUARTER = 0.78539816339744830962f
constant PI quarter

const float | SQRT_TWO = 1.41421356237309504880f
constant square root two

const float | SQRT_TWO_HALF = 0.70710678118654752440f
constant square root two half

Detailed Description

Namespace for mathematical helper functions and classes.

Function Documentation

Boxnt< n, T > boundingBox | ( | const Vecnt< n, T > * | points,
 |  | unsigned int | numberOfPoints
 | ) | [inline]

Instantiates an axis-aligned bounding box from a set of points.

Parameters:
points | Start address of input points.
numberOfPoints | Number of input points.
Returns:
Returns the bounding box calculated from the input points.

Boxnt< n, T > boundingBox | ( | const Vecnt< n, T > * | points,
 |  | const unsigned int * | indices,
 |  | unsigned int | numberOfIndices
 | ) | [inline]

Instantiates an axis-aligned bounding box from a set of points.

Parameters:
points | Start address of input points.
indices | Start address of indices referencing the input points.
numberOfIndices | Number of indices.
Returns:
Returns the bounding box calculated from the input points referenced by the specified indices.

Boxnt< n, T > boundingBox | ( | const Boxnt< n, T > & | b0,
 |  | const Boxnt< n, T > & | b1
 | ) | [inline]

Instantiates an axis-aligned bounding box as the union of two boxes.

Parameters:
b0 | Specifies the first bounding box.
b1 | Specifies the second bounding box.
Returns:
Returns the bounding box calculated as the union of b0 and b1.

bool isEmpty ( const Boxnt< n, T > & bbox ) [inline]

Tests if the specified bounding box is empty.

Parameters:
bbox Bounding box to test.
Returns:
The function returns true if the specified bounding box is empty.
Remarks:
A bounding box is considered empty, if for at least one direction in space, the lower edge is greater than the upper edge.

bool operator== | ( | const Boxnt< n, T > & | lhs,
 |  | const Boxnt< n, T > & | rhs
 | ) | [inline]

Compares two bounding boxes.

Parameters:
lhs | Specifies the left-hand bounding box.
rhs | Specifies the right-hand bounding box.
Returns:
The function returns true if both bounding boxes are equal.

bool operator!= | ( | const Boxnt< n, T > & | lhs,
 |  | const Boxnt< n, T > & | rhs
 | ) | [inline]

Compares two bounding boxes.

Parameters:
lhs | Specifies the left-hand bounding box.
rhs | Specifies the right-hand bounding box.
Returns:
The function returns true if both bounding boxes differ.

bool isIdentity | ( | const Matnnt< n, T > & | m,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Test if a matrix is the identity.

Parameters:
m | A constant reference to the matrix to test for identity.
eps | An optional value giving the allowed epsilon. The default is a type dependent value.
Returns:
true, if the matrix is the identity, otherwise false.
Remarks:
A matrix is considered to be the identity, if each of the diagonal elements differ less than eps from one, and each of the other matrix elements differ less than eps from zero.
See also:
isNormalized, isNull, isOrthogonal

bool isNormalized | ( | const Matnnt< n, T > & | m,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Test if a matrix is normalized.

Parameters:
m | A constant reference to the matrix to test.
eps | An optional value giving the allowed epsilon. The default is a type dependent value.
Returns:
true if the matrix is normalized, otherwise false.
Remarks:
A matrix is considered to be normalized, if each row and each column is normalized.
See also:
isIdentity, isNull, isOrthogonal

bool isNull | ( | const Matnnt< n, T > & | m,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Test if a matrix is null.

Parameters:
m | A constant reference to the matrix to test.
eps | An optional value giving the allowed epsilon. The default is a type dependent value.
Returns:
true if the matrix is null, otherwise false.
Remarks:
A matrix is considered to be null, if each row is null.
See also:
isIdentity, isNormalized, isOrthogonal

bool isOrthogonal | ( | const Matnnt< n, T > & | m,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Test if a matrix is orthogonal.

Parameters:
m | A constant reference to the matrix to test.
eps | An optional value giving the allowed epsilon. The default is a type dependent value.
Returns:
true, if the matrix is orthogonal, otherwise false.
Remarks:
A matrix is considered to be orthogonal, if each pair of rows and each pair of columns are orthogonal to each other.
See also:
isIdentity, isNormalized, isNull

T maxElement ( const Matnnt< n, T > & m ) [inline]

Get the value of the maximal absolute element of a matrix.

Parameters:
m A constant reference to a matrix to get the maximal element from.
Returns:
The value of the maximal absolute element of m.
See also:
minElement

T minElement ( const Matnnt< n, T > & m ) [inline]

Get the value of the minimal absolute element of a matrix.

Parameters:
m A constant reference to a matrix to get the minimal element from.
Returns:
The value of the minimal absolute element of m.
See also:
maxElement

bool operator== | ( | const Matnnt< n, T > & | m0,
 |  | const Matnnt< n, T > & | m1
 | ) | [inline]

Matrix equality operator.

Parameters:
m0 | A constant reference to the first matrix to compare.
m1 | A constant reference to the second matrix to compare.
Returns:
true, if m0 and m1 are equal, otherwise false.
Remarks:
Two matrices are considered to be equal, if each element of m0 differs less than the type dependent epsilon from the the corresponding element of m1.

bool operator!= | ( | const Matnnt< n, T > & | m0,
 |  | const Matnnt< n, T > & | m1
 | ) | [inline]

Matrix inequality operator.

Parameters:
m0 | A constant reference to the first matrix to compare.
m1 | A constant reference to the second matrix to compare.
Returns:
true, if m0 and m1 are not equal, otherwise false.
Remarks:
Two matrices are considered to be not equal, if at least one element of m0 differs more than the type dependent epsilon from the the corresponding element of m1.

Matnnt< n, T > operator~ ( const Matnnt< n, T > & m ) [inline]

Matrix transpose operator.

Parameters:
m A constant reference to the matrix to transpose.
Returns:
The transposed version of m.

Matnnt< n, T > operator+ | ( | const Matnnt< n, T > & | m0,
 |  | const Matnnt< n, T > & | m1
 | ) | [inline]

Matrix addition operator.

Parameters:
m0 | A constant reference to the first matrix to add.
m1 | A constant reference to the second matrix to add.
Returns:
A matrix representing the sum of
 m0 + m1
.

Matnnt< n, T > operator- ( const Matnnt< n, T > & m ) [inline]

Matrix negation operator.

Parameters:
m A constant reference to the matrix to negate.
Returns:
A matrix representing the negation of m.

Matnnt< n, T > operator- | ( | const Matnnt< n, T > & | m0,
 |  | const Matnnt< n, T > & | m1
 | ) | [inline]

Matrix subtraction operator.

Parameters:
m0 | A constant reference to the first argument of the subtraction.
m1 | A constant reference to the second argument of the subtraction.
Returns:
A matrix representing the difference
 m0 - m1
.

Matnnt< n, T > operator * | ( | const Matnnt< n, T > & | m,
 |  | T | s
 | ) | [inline]

Scalar multiplication operator.

Parameters:
m | A constant reference to the matrix to multiply.
s | The scalar value to multiply with.
Returns:
A matrix representing the product
 m * s
.

Matnnt< n, T > operator * | ( | T | s,
 |  | const Matnnt< n, T > & | m
 | ) | [inline]

Scalar multiplication operator.

Parameters:
s | The scalar value to multiply with.
m | A constant reference to the matrix to multiply.
Returns:
A matrix representing the product
 s * m
.

Vecnt< n, T > operator * | ( | const Matnnt< n, T > & | m,
 |  | const Vecnt< n, T > & | v
 | ) | [inline]

Vector multiplication operator.

Parameters:
m | A constant reference to the matrix to multiply.
v | A constant reference to the vector to multiply with.
Returns:
A vector representing the product
 m * v
.

Vecnt< n, T > operator * | ( | const Vecnt< n, T > & | v,
 |  | const Matnnt< n, T > & | m
 | ) | [inline]

Vector multiplication operator.

Parameters:
v | A constant reference to the vector to multiply with.
m | A constant reference to the matrix to multiply.
Returns:
A vector representing the product
 v * m
.

Matnnt< n, T > operator * | ( | const Matnnt< n, T > & | m0,
 |  | const Matnnt< n, T > & | m1
 | ) | [inline]

Matrix multiplication operator.

Parameters:
m0 | A constant reference to the first operand of the multiplication.
m1 | A constant reference to the second operand of the multiplication.
Returns:
A matrix representing the product m0 * m1 .

Matnnt< n, T > operator/ | ( | const Matnnt< n, T > & | m,
 |  | T | s
 | ) | [inline]

Scalar division operator.

Parameters:
m | A constant reference to the matrix to divide.
s | The scalar value to divide by.
Returns:
A matrix representing the matrix m divided by s.

void setIdentity ( Matnnt< n, T > & m )

Set a matrix to be the identity.

Parameters:
m The matrix to set to identity.
Remarks:
Each diagonal element of m is set to one, each other element is set to zero.

T determinant ( const Matnnt< 3, T > & m ) [inline]

Determine the determinant of a 3 by 3 matrix.

Parameters:
m A constant reference to the matrix to determine the determinant from.
Returns:
The determinant of m.

bool isRotation | ( | const Matnnt< 3, T > & | m,
 |  | T | eps = 9 * std::numeric_limits<T>::epsilon()
 | ) |

Test if a 3 by 3 matrix represents a rotation.

Parameters:
m | A constant reference to the matrix to test.
eps | An optional value giving the allowed epsilon. The default is a type dependent value.
Returns:
true, if the matrix represents a rotation, otherwise false.
Remarks:
A 3 by 3 matrix is considered to be a rotation, if it is normalized, orthogonal, and its determinant is one.
See also:
isIdentity, isNull, isNormalized, isOrthogonal

Matnnt< 3, T > & setMat | ( | Matnnt< 3, T > & | m,
 |  | T | m00,
 |  | T | m01,
 |  | T | m02,
 |  | T | m10,
 |  | T | m11,
 |  | T | m12,
 |  | T | m20,
 |  | T | m21,
 |  | T | m22
 | ) | [inline]

Set the values of a 3 by 3 matrix by nine scalars.

Parameters:
m | A reference to the matrix to set with the nine values.
m00 | The scalar for the first value in the first row.
m01 | The scalar for the second value in the first row.
m02 | The scalar for the third value in the first row.
m10 | The scalar for the first value in the second row.
m11 | The scalar for the second value in the second row.
m12 | The scalar for the third value in the second row.
m20 | The scalar for the first value in the third row.
m21 | The scalar for the second value in the third row.
m22 | The scalar for the third value in the third row.
Returns:
A reference to m.

Matnnt< 3, T > & setMat | ( | Matnnt< 3, T > & | m,
 |  | const Vecnt< 3, T > & | v0,
 |  | const Vecnt< 3, T > & | v1,
 |  | const Vecnt< 3, T > & | v2
 | ) | [inline]

Set the values of a 3 by 3 matrix by three vectors.

Parameters:
m | A reference to the matrix to set with the three vectors.
v0 | A constant reference to the vector to set as the first row of m.
v1 | A constant reference to the vector to set as the second row of m.
v2 | A constant reference to the vector to set as the third row of m.
Returns:
A reference to m.

Matnnt< 3, T > & setMat | ( | Matnnt< 3, T > & | m,
 |  | const Quatt< T > & | q
 | ) | [inline]

Set the values of a 3 by 3 matrix using a normalized quaternion.

Parameters:
m | A reference to the matrix to set.
q | A constant reference to the normalized quaternion to use.
Returns:
A reference to m.
Remarks:
The matrix is set to represent the same rotation as the normalized quaternion q.
Note:
The behavior is undefined if q is not normalized.

Matnnt< 3, T > & setMat | ( | Matnnt< 3, T > & | m,
 |  | const Vecnt< 3, T > & | axis,
 |  | T | angle
 | ) |

Set the values of a 3 by 3 matrix using a normalized rotation axis and an angle.

Parameters:
m | A reference to the matrix to set.
axis | A constant reference to the normalized rotation axis.
angle | The angle in radians to rotate around axis.
Returns:
A reference to m.
Remarks:
The matrix is set to represent the rotation by angle around axis.
Note:
The behavior is undefined if axis is not normalized.

NVSG_API void decompose | ( | const Matnnt< 3, float > & | m,
 |  | Quatt< float > & | orientation,
 |  | Vecnt< 3, float > & | scaling,
 |  | Quatt< float > & | scaleOrientation
 | ) |

Decompose a 3 by 3 matrix.

Parameters:
m | A constant reference to the matrix to decompose.
orientation | A reference to the quaternion getting the rotational part of the matrix.
scaling | A reference to the vector getting the scaling part of the matrix.
scaleOrientation | A reference to the quaternion getting the orientation of the scaling.
Note:
The behavior is undefined, if the determinant of m is too small, or the rank of m is less than three.

Matnnt< 4, T > & setMat | ( | Matnnt< 4, T > & | m,
 |  | T | m00,
 |  | T | m01,
 |  | T | m02,
 |  | T | m03,
 |  | T | m10,
 |  | T | m11,
 |  | T | m12,
 |  | T | m13,
 |  | T | m20,
 |  | T | m21,
 |  | T | m22,
 |  | T | m23,
 |  | T | m30,
 |  | T | m31,
 |  | T | m32,
 |  | T | m33
 | ) | [inline]

Set the values of a 4 by 4 matrix by sixteen scalars.

Parameters:
m | A reference to the matrix to set with the sixteen values.
m00 | The scalar for the first value in the first row.
m01 | The scalar for the second value in the first row.
m02 | The scalar for the third value in the first row.
m03 | The scalar for the fourth value in the first row.
m10 | The scalar for the first value in the second row.
m11 | The scalar for the second value in the second row.
m12 | The scalar for the third value in the second row.
m13 | The scalar for the fourth value in the second row.
m20 | The scalar for the first value in the third row.
m21 | The scalar for the second value in the third row.
m22 | The scalar for the third value in the third row.
m23 | The scalar for the fourth value in the third row.
m30 | The scalar for the first value in the fourth row.
m31 | The scalar for the second value in the fourth row.
m32 | The scalar for the third value in the fourth row.
m33 | The scalar for the fourth value in the fourth row.
Returns:
A reference to m.

Matnnt< 4, T > & setMat | ( | Matnnt< 4, T > & | m,
 |  | const Vecnt< 4, T > & | v0,
 |  | const Vecnt< 4, T > & | v1,
 |  | const Vecnt< 4, T > & | v2,
 |  | const Vecnt< 4, T > & | v3
 | ) | [inline]

Set the values of a 4 by 4 matrix by four vectors.

Parameters:
m | A reference to the matrix to set with the four vectors.
v0 | A constant reference to the vector to set as the first row of m.
v1 | A constant reference to the vector to set as the second row of m.
v2 | A constant reference to the vector to set as the third row of m.
v3 | A constant reference to the vector to set as the fourth row of m.
Returns:
A reference to m.

Matnnt<4,T>& setMat | ( | Matnnt< 4, T > & | m,
 |  | const Quatt< T > & | ori,
 |  | const Vecnt< 3, T > & | trans = Vecnt<3,T>(0,0,0),
 |  | const Vecnt< 3, T > & | scale = Vecnt<3,T>(1,1,1)
 | ) |

Set the values of a 4 by 4 matrix by the constituents of a transformation.

Parameters:
m | A reference to the matrix to set.
ori | A constant reference of the rotation part of the transformation.
trans | An optional constant reference to the translational part of the transformation. The default is a null vector.
scale | An optional constant reference to the scaling part of the transformation. The default is the identity scaling.
Returns:
A reference to m.

void decompose | ( | const Matnnt< 4, float > & | m,
 |  | Vecnt< 3, float > & | translation,
 |  | Quatt< float > & | orientation,
 |  | Vecnt< 3, float > & | scaling,
 |  | Quatt< float > & | scaleOrientation
 | ) | [inline]

Decompose a 4 by 4 matrix of floats.

Parameters:
m | A constant reference to the matrix to decompose.
translation | A reference to the vector getting the translational part of the matrix.
orientation | A reference to the quaternion getting the rotational part of the matrix.
scaling | A reference to the vector getting the scaling part of the matrix.
scaleOrientation | A reference to the quaternion getting the orientation of the scaling.
Note:
The behavior is undefined, if the determinant of m is too small.

Currently, the behavior is undefined, if the rank of m is less than three.

T clamp | ( | T | v,
 |  | T | l,
 |  | T | u
 | ) |

Template to clamp an object of type T to a lower and an upper limit.

Returns:
clamped value of v between l and u
Parameters:
v | value to clamp
l | lower limit
u | upper limit

T degToRad ( T angle ) [inline]

Transform an angle in degrees to radians.

Returns:
angle in radians

int highestBit ( T i ) [inline]

Returns the highest bit set for the specified input value.

T highestBitValue ( T i ) [inline]

Returns the highest bit value for the specified input value.

bool isPowerOfTwo ( T n ) [inline]

Determine if an integer is a power of two.

Returns:
true if n is a power of two, otherwise false

T lerp | ( | float | alpha,
 |  | const T & | v0,
 |  | const T & | v1
 | ) | [inline]

Linear interpolation between two values v0 and v1.

v = ( 1 - alpha ) * v0 + alpha * v1

Parameters:
alpha | interpolation parameter
v0 | starting value
v1 | ending value

const T& max | ( | const T & | a,
 |  | const T & | b,
 |  | const T & | c
 | ) | [inline]

Determine the maximal value out of three.

Parameters:
a | A constant reference of the first value to consider.
b | A constant reference of the second value to consider.
c | A constant reference of the third value to consider.
Returns:
A constant reference to the maximal value out of a, b, and c.
See also:
min

const T& min | ( | const T & | a,
 |  | const T & | b,
 |  | const T & | c
 | ) | [inline]

Determine the minimal value out of three.

Parameters:
a | A constant reference of the first value to consider.
b | A constant reference of the second value to consider.
c | A constant reference of the third value to consider.
Returns:
A constant reference to the minimal value out of a, b, and c.
See also:
max

T powerOfTwoAbove ( T n ) [inline]

Determine the smallest power of two equal to or larger than n.

Parameters:
n The value to determine the nearest power of two above.
Returns:
n, if n is a power of two, otherwise the smallest power of two above n.
See also:
powerOfTowBelow

T powerOfTwoBelow ( T n ) [inline]

Determine the largest power of two equal to or smaller than n.

Parameters:
n The value to determine the nearest power of two below.
Returns:
n, if n is a power of two, otherwise the largest power of two below n.
See also:
powerOfTowAbove

T powerOfTwoNearest ( T n ) [inline]

Calculates the nearest power of two for the specified integer.

Parameters:
n Integer for which to calculate the nearest power of two.
Returns:
nearest power of two for integer n.

float radToDeg ( float angle ) [inline]

Transform an angle in radian to degree.

Parameters:
angle angle in radians
Returns:
angle in degrees

int sign ( const T & t ) [inline]

Determine the sign of a scalar.

Parameters:
t scalar value
Returns:
sign of t

T square ( const T & t ) [inline]

Template to square an object of Type T.

Parameters:
t value to square
Returns:
product of t with itself

int compare | ( | T | lhs,
 |  | T | rhs
 | ) | [inline]

Compares two numerical values.

Returns:
-1 if lhs < rhs, 1 if lhs > rhs, and 0 if lhs == rhs.

int compare | ( | float | lhs,
 |  | float | rhs
 | ) | [inline]

Compares two float values.

Returns:
-1 if lhs < rhs, 1 if lhs > rhs, and 0 if lhs == rhs.

int compare | ( | double | lhs,
 |  | double | rhs
 | ) | [inline]

Compares two double values.

Returns:
-1 if lhs < rhs, 1 if lhs > rhs, and 0 if lhs == rhs.

bool areOnOppositeSides | ( | const Planent< n, T > & | pl,
 |  | const Vecnt< n, T > & | p0,
 |  | const Vecnt< n, T > & | p1
 | ) |

Test if two points are on opposite sides of a plane.

Parameters:
pl | A reference to a constant plane.
p0 | A reference to the constant first point.
p1 | A reference to the constant second point.
Returns:
true, if p0 and p1 are on opposite sides of pl.
See also:
areOnSameSide

bool areOnSameSide | ( | const Planent< n, T > & | pl,
 |  | const Vecnt< n, T > & | p0,
 |  | const Vecnt< n, T > & | p1
 | ) |

Test if two points are on the same side of a plane.

Parameters:
pl | A reference to a constant plane.
p0 | A reference to the constant first point.
p1 | A reference to the constant second point.
Returns:
true, if p0 and p1 are on the same side of pl.
See also:
areOnOppositeSide

T distance | ( | const Planent< n, T > & | pl,
 |  | const Vecnt< n, T > & | p
 | ) |

Calculate the distance of a point to a plane.

Parameters:
pl | A reference to the constant plane.
p | A reference to the constant point.
Returns:
The distance of the point p to the plane pl.
See also:
signedDistance

Vecnt< n, T > nearestPoint | ( | const Planent< n, T > & | pl,
 |  | const Vecnt< n, T > & | p
 | ) |

Calculate the point on a plane nearest to a give point.

Parameters:
pl | A reference to the constant plane.
p | A reference to the constant point.
Returns:
The point on the plane pl nearest to the point p.
See also:
distance, signedDistance

bool operator== | ( | const Planent< n, T > & | pl0,
 |  | const Planent< n, T > & | pl1
 | ) |

Test for equality of two planes.

Parameters:
pl0 | A reference to the constant first plane.
pl1 | A reference to the constant second plane.
Returns:
true, if the normals of the two planes are equal and the offsets differ less than the type specific epsilon. Otherwise false.
See also:
operator!=()

bool operator!= | ( | const Planent< n, T > & | pl0,
 |  | const Planent< n, T > & | pl1
 | ) |

Test for inequality of two planes.

Parameters:
pl0 | A reference to the constant first plane.
pl1 | A reference to the constant second plane.
Returns:
true, if the normals of the two planes are not equal or the offsets differ more than the type specific epsilon. Otherwise false.
See also:
operator==()

T signedDistance | ( | const Planent< n, T > & | pl,
 |  | const Vecnt< n, T > & | p
 | ) |

Calculate the signed distance of a point to a plane.

Parameters:
pl | A reference to the constant plane.
p | A reference to the constant point.
Returns:
The signed distance of the point p to the plane pl.
Remarks:
The signed distance of a point p to a plane pl is positive, if p is in the half space the normal a pl points to. If p is in the other half space, the signed distance is negative.
See also:
distance

void decompose | ( | const Quatt< T > & | q,
 |  | Vecnt< 3, T > & | axis,
 |  | T & | angle
 | ) | [inline]

Decompose a quaternion into an axis and an angle.

Parameters:
q | A reference to the constant quaternion to decompose.
axis | A reference to the resulting axis.
angle | A reference to the resulting angle.

T distance | ( | const Quatt< T > & | q0,
 |  | const Quatt< T > & | q1
 | ) | [inline]

Determine the distance between two quaternions.

Parameters:
q0 | A reference to the left constant quaternion.
q1 | A reference to the right constant quaternion.
Returns:
The euclidean distance between q0 and q1, interpreted as Vecnt<4,T>.

bool isNormalized | ( | const Quatt< T > & | q,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Test if a quaternion is normalized.

Parameters:
q | A reference to the constant quaternion to test.
eps | An optional value giving the allowed epsilon. The default is a type dependent value.
Returns:
true if the quaternion is normalized, otherwise false.
Remarks:
A quaternion q is considered to be normalized, when it's magnitude differs less than some small value eps from one.

bool isNull | ( | const Quatt< T > & | q,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Test if a quaternion is null.

Parameters:
q | A reference to the constant quaternion to test.
eps | An optional value giving the allowed epsilon. The default is a type dependent value.
Returns:
true if the quaternion is null, otherwise false.
Remarks:
A quaternion q is considered to be null, if it's magnitude is less than some small value eps.

T magnitude ( const Quatt< T > & q ) [inline]

Determine the magnitude of a quaternion.

Parameters:
q A reference to the quaternion to determine the magnitude of.
Returns:
The magnitude of the quaternion q.
Remarks:
The magnitude of a normalized quaternion is one.

bool operator== | ( | const Quatt< T > & | q0,
 |  | const Quatt< T > & | q1
 | ) | [inline]

Quaternion equality operator.

Parameters:
q0 | A reference to the constant left operand.
q1 | A reference to the constant right operand.
Returns:
true if the quaternions q0 and q are equal, otherwise false.
Remarks:
Two quaternions are considered to be equal, if each component of the one quaternion deviates less than epsilon from the corresponding element of the other quaternion.

bool operator!= | ( | const Quatt< T > & | q0,
 |  | const Quatt< T > & | q1
 | ) | [inline]

Quaternion inequality operator.

Parameters:
q0 | A reference to the constant left operand.
q1 | A reference to the constant right operand.
Returns:
true if q0 is not equal to q1, otherwise false
Remarks:
Two quaternions are considered to be equal, if each component of the one quaternion deviates less than epsilon from the corresponding element of the other quaternion.

Quatt< T > operator~ ( const Quatt< T > & q ) [inline]

Quaternion conjugation operator.

Parameters:
q A reference to the constant quaternion to conjugate.
Returns:
The conjugation of q.
Remarks:
The conjugation of a quaternion is a rotation of the same angle around the negated axis.

Quatt< T > operator- ( const Quatt< T > & q ) [inline]

Negation operator.

Parameters:
q A reference to the constant quaternion to get the negation from.
Returns:
The negation of q.
Remarks:
The negation of a quaternion is a rotation around the same axis by the negated angle.

Quatt< T > operator * | ( | const Quatt< T > & | q0,
 |  | const Quatt< T > & | q1
 | ) | [inline]

Quaternion multiplication operator.

Parameters:
q0 | A reference to the constant left operand.
q1 | A reference to the constant right operand.
Returns:
The product of q0 with a1.
Remarks:
Multiplying two quaternions gives a quaternion that represents the concatenation of the rotation represented by the two quaternions. Besides rounding errors, the following equation holds:
    Matnnt<3,T>( q0 * q1 ) == Matnnt<3,T>( q0 ) * Matnnt<3,T>( q1 )

Vecnt< 3, T > operator * | ( | const Quatt< T > & | q,
 |  | const Vecnt< 3, T > & | v
 | ) | [inline]

Quaternion multiplication operator with a vector.

Parameters:
q | A reference to the constant left operand.
v | A reference to the constant right operand.
Returns:
The vector v rotated by the inverse of q.
Remarks:
Multiplying a quaternion q with a vector v applies the inverse rotation represented by q to v.

Vecnt< 3, T > operator * | ( | const Vecnt< 3, T > & | v,
 |  | const Quatt< T > & | q
 | ) | [inline]

Vector multiplication operator with a quaternion.

Parameters:
v | A reference to the constant left operand.
q | A reference to the constant right operand.
Returns:
The vector v rotated by q.
Remarks:
Multiplying a vector v by a quaternion q applies the rotation represented by q to v.

Quatt< T > operator/ | ( | const Quatt< T > & | q0,
 |  | const Quatt< T > & | q1
 | ) | [inline]

Quaternion division operator.

Parameters:
q0 | A reference to the constant left operand.
q1 | A reference to the constant right operand.
Returns:
A quaternion representing the quotient of q0 and q1.
Remarks:
Dividing a quaternion by an other gives a quaternion that represents the concatenation of the rotation represented by the numerator quaternion and the rotation represented by the conjugated denumerator quaternion.

NVSG_API Quatt<float> lerp | ( | float | alpha,
 |  | const Quatt< float > & | q0,
 |  | const Quatt< float > & | q1
 | ) |

Spherical linear interpolation between two quaternions q0 and q1.

Parameters:
alpha | The interpolation parameter.
q0 | The starting value.
q1 | The ending value.
Returns:
The quaternion that represents the spherical linear interpolation between q0 and q1.

Spherent< n, T > boundingSphere | ( | const Vecnt< n, T > * | points,
 |  | unsigned int | numberOfPoints
 | ) | [inline]

Determine the bounding sphere of a number of points.

Parameters:
points | A pointer to the points to include.
numberOfPoints | The number of points used.
Returns:
A small sphere around the given points.
Remarks:
The sphere is not necessarily the smallest possible bounding sphere.

Spherent< n, T > boundingSphere | ( | const Vecnt< n, T > * | points,
 |  | const unsigned int * | indices,
 |  | unsigned int | numberOfIndices
 | ) |

Determine the bounding sphere of a number of indexed points.

Parameters:
points | A pointer to the points to use.
indices | A pointer to the indices to use.
numberOfIndices | The number of indices used.
Returns:
A small sphere around the given points.
Remarks:
The sphere is not necessarily the smallest possible bounding sphere.

Spherent< n, T > boundingSphere | ( | const Vecnt< n, T > * | points,
 |  | const std::vector< unsigned int > * | strips,
 |  | unsigned int | numberOfStrips
 | ) |

Determine the bounding sphere of a number of strip-indexed points.

Parameters:
points | A pointer to the points to use.
strips | A pointer to the strips of indices used.
numberOfStrips | The number of strips used.
Returns:
A small sphere around the given points.
Remarks:
The sphere is not necessarily the smallest possible bounding sphere.

Spherent< n, T > boundingSphere | ( | const Spherent< n, T > & | s,
 |  | const Vecnt< n, T > & | p
 | ) |

Determine the bounding sphere of a sphere and a point.

Parameters:
s | A reference to the constant sphere to use.
p | A reference to the constant point to use.
Returns:
The bounding sphere around s and p.
Remarks:
If p is inside of s, a sphere of the same size and position as s is returned. Otherwise, the smallest sphere enclosing both s and p is returned.

Spherent< n, T > boundingSphere | ( | const Spherent< n, T > & | s0,
 |  | const Spherent< n, T > & | s1
 | ) |

Determine the bounding sphere around two spheres.

Parameters:
s0 | A reference to the constant first sphere to enclose.
s1 | A reference to the constant second sphere to enclose.
Returns:
A bounding sphere around s0 and s1.
Remarks:
If the one sphere is completely contained in the other, a sphere equaling that other sphere is returned. Otherwise, the smallest sphere enclosing both s0 and s1 is returned.

Spherent< n, T > intersectingSphere | ( | const Spherent< n, T > & | s0,
 |  | const Spherent< n, T > & | s1
 | ) |

Determine the bounding sphere of the intersection of two spheres.

Parameters:
s0 | A reference to the constant first sphere.
s1 | A reference to the constant second sphere.
Returns:
A sphere around the intersection of s0 and s1.

bool isEmpty ( const Spherent< n, T > & s ) [inline]

Determine if a sphere is empty.

Parameters:
s A reference to a constant sphere.
Returns:
true, if \ s is empty, otherwise false.
Remarks:
A sphere is considered to be empty, if it's radius is negative.

bool operator== | ( | const Spherent< n, T > & | s0,
 |  | const Spherent< n, T > & | s1
 | ) |

Test for equality of two spheres.

Parameters:
s0 | A constant reference to the first sphere to test.
s1 | A constant reference to the second sphere to test.
Returns:
true, if the centers of the spheres are equal and the radii differ less than the type specific epsilon. Otherwise false.
See also:
operator!=()

bool operator!= | ( | const Spherent< n, T > & | s0,
 |  | const Spherent< n, T > & | s1
 | ) |

Test for inequality of two spheres.

Parameters:
s0 | A constant reference to the first sphere to test.
s1 | A constant reference to the second sphere to test.
Returns:
true, if the centers of the spheres are different or the radii differ more than the type specific epsilon. Otherwise false.
See also:
operator==()

void boundingBox | ( | const Vecnt< n, T > * | points,
 |  | size_t | numberOfPoints,
 |  | Vecnt< n, T > & | min,
 |  | Vecnt< n, T > & | max
 | ) | [inline]

Determine the bounding box of a number of points.

Parameters:
points | A vector to the points.
numberOfPoints | The number of points in points.
min | Reference to the calculated lower left front vertex of the bounding box.
max | Reference to the calculated upper right back vertex of the bounding box.

bool areOpposite | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Determine if two vectors point in opposite directions.

Parameters:
v0 | A constant reference to the first normalized vector to use.
v1 | A constant reference to the second normalized vector to use.
eps | An optional type dependent epsilon, defining the acceptable deviation.
Returns:
true, if v0 and v1 are anti-parallel, otherwise false.
Note:
The behavior is undefined if v0 or v1 are not normalized.
See also:
areCollinear, isNormalized

bool areOrthogonal | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1,
 |  | T | eps = 2 * std::numeric_limits<T>::epsilon()
 | ) |

Determine if two vectors are orthogonal.

Parameters:
v0 | A constant reference to the first vector to use.
v1 | A constant reference to the second vector to use.
eps | An optional deviation from orthonormality. The default is the type dependent epsilon.
Returns:
true, if v0 and v1 are orthogonal, otherwise false.
See also:
areOrthonormal

bool areOrthonormal | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1,
 |  | T | eps = 2 * std::numeric_limits<T>::epsilon()
 | ) |

Determine if two vectors are orthonormal.

Parameters:
v0 | A constant reference to the first normalized vector to use.
v1 | A constant reference to the second normalized vector to use.
eps | An optional deviation from orthonormality. The default is the type dependent epsilon.
Returns:
true, if v0 and v1 are orthonormal, otherwise false.
Note:
The behavior is undefined if v0 or v1 are not normalized.
See also:
areOrthogonal

bool areSimilar | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1,
 |  | T | eps
 | ) | [inline]

Determine if two vectors differ less than a given epsilon in each component.

Parameters:
v0 | A constant reference to the first vector to use.
v1 | A constant reference to the second vector to use.
eps | The acceptable deviation for each component.
Returns:
true, if \ v0 and v1 differ less than eps in each component, otherwise false.
See also:
distance, operator==()

T distance | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1
 | ) | [inline]

Determine the distance between vectors.

Parameters:
v0 | A constant reference to the first vector.
v1 | A constant reference to the second vector.
Returns:
The euclidean distance between v0 and v1.
See also:
length, lengthSquared

bool isNormalized | ( | const Vecnt< n, T > & | v,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Determine if a vector is normalized.

Parameters:
v | A constant reference to the vector to test.
eps | An optional type dependent epsilon, defining the acceptable deviation.
Returns:
true, if v is normalized, otherwise false.
See also:
isNull, length, lengthSquared, normalize

bool isNull | ( | const Vecnt< n, T > & | v,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Determine if a vector is the null vector.

Parameters:
v | A constant reference to the vector to test.
eps | An optional type dependent epsilon, defining the acceptable deviation.
Returns:
true, if v is the null vector, otherwise false.
See also:
isNormalized, length, lengthSquared

T length ( const Vecnt< n, T > & v ) [inline]

Determine the length of a vector.

Parameters:
v A constant reference to the vector to use.
Returns:
The length of the vector v.
See also:
lengthSquared

T lengthSquared ( const Vecnt< n, T > & v ) [inline]

Determine the squared length of a vector.

Parameters:
v A constant reference to the vector to use.
Returns:
The squared length of the vector v.
See also:
length

T maxElement ( const Vecnt< n, T > & v ) [inline]

Determine the maximal element of a vector.

Parameters:
v A constant reference to the vector to use.
Returns:
The largest absolute value of v.
See also:
minElement

T minElement ( const Vecnt< n, T > & v ) [inline]

Determine the minimal element of a vector.

Parameters:
v A constant reference to the vector to use.
Returns:
The smallest absolute value of v.
See also:
maxElement

T normalize ( Vecnt< n, T > & v ) [inline]

Normalize a vector.

Parameters:
v A reference to the vector to normalize.
Returns:
The length of the unnormalized vector.
See also:
isNormalized, length

bool operator== | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1
 | ) | [inline]

Test for equality of two vectors.

Parameters:
v0 | A constant reference to the first vector to test.
v1 | A constant reference to the second vector to test.
Returns:
true, if the two vectors component-wise differ less than the type dependent epsilon, otherwise false.
See also:
operator!=()

bool operator!= | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1
 | ) | [inline]

Test for inequality of two vectors.

Parameters:
v0 | A constant reference to the first vector to test.
v1 | A constant reference to the second vector to test.
Returns:
true, if the two vectors component-wise differ more than the type dependent epsilon in at least one component, otherwise false.
See also:
operator==()

Vecnt< n, T > operator+ | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1
 | ) | [inline]

Vector addition operator.

Parameters:
v0 | A constant reference to the left operand.
v1 | A second reference to the right operand.
Returns:
A vector holding the component-wise sum of v0 and v1.
See also:
operator-()

Vecnt< n, T > operator- ( const Vecnt< n, T > & v ) [inline]

Unary vector negation operator.

Parameters:
v A constant reference to a vector.
Returns:
A vector holding the component-wise negation of v.
See also:
operator-()

Vecnt< n, T > operator- | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1
 | ) | [inline]

Vector subtraction operator.

Parameters:
v0 | A constant reference to the left operand.
v1 | A second reference to the right operand.
Returns:
A vector holding the component-wise difference of v0 and v1.
See also:
operator+()

Vecnt< n, T > operator * | ( | const Vecnt< n, T > & | v,
 |  | T | s
 | ) | [inline]

Scalar multiplication of a vector.

Parameters:
v | A constant reference to the left operand.
s | A scalar as the right operand.
Returns:
A vector holding the component-wise product with s.
See also:
operator/()

Vecnt< n, T > operator * | ( | T | s,
 |  | const Vecnt< n, T > & | v
 | ) | [inline]

Scalar multiplication of a vector.

Parameters:
s | A scalar as the left operand.
v | A constant reference to the right operand.
Returns:
A vector holding the component-wise product with s.
See also:
operator/()

T operator * | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1
 | ) | [inline]

Vector multiplication.

Parameters:
v0 | A constant reference to the left operand.
v1 | A constant reference to the right operand.
Returns:
The dot product of v0 and v1.
See also:
operator^()

Vecnt< n, T > operator/ | ( | const Vecnt< n, T > & | v,
 |  | T | s
 | ) | [inline]

Scalar division of a vector.

Parameters:
v | A constant reference to the left operand.
s | A scalar as the right operand.
Returns:
A vector holding the component-wise division by s.
See also:
operator*()

Vecnt< n, T > orthonormalize | ( | const Vecnt< n, T > & | v0,
 |  | const Vecnt< n, T > & | v1
 | ) | [inline]

Determine the orthonormal vector of v1 with respect to v0.

Parameters:
v0 | A constant reference to the normalized vector to orthonormalize against.
v1 | A constant reference to the normalized vector to orthonormalize.
Returns:
A normalized vector representing the orthonormalized version of v1 with respect to v0.
Note:
The behavior is undefined if v0 or v1 are not normalized.
Example:
    Vec3f newYAxis = orthonormalize( newZAxis, oldYAxis );
See also:
normalize

Vecnt< 2, T > & setVec | ( | Vecnt< 2, T > & | v,
 |  | T | x,
 |  | T | y
 | ) | [inline]

Set the values of a two-component vector.

Parameters:
v | A reference to the vector to set with x and y.
x | The first component to set.
y | The second component to set.

bool areCollinear | ( | const Vecnt< 3, T > & | v0,
 |  | const Vecnt< 3, T > & | v1,
 |  | T | eps = std::numeric_limits<T>::epsilon()
 | ) |

Determine if two vectors are collinear.

Parameters:
v0 | A constant reference to the first vector.
v1 | A constant reference to the second vector.
eps | An optional type dependent epsilon, defining the acceptable deviation.
Returns:
true, if v0 and v1 are collinear, otherwise false.
See also:
areOpposite

Vecnt< 3, T > operator^ | ( | const Vecnt< 3, T > & | v0,
 |  | const Vecnt< 3, T > & | v1
 | ) | [inline]

Cross product operator.

Parameters:
v0 | A constant reference to the left operand.
v1 | A constant reference to the right operand.
Returns:
A vector that is the cross product of v0 and v1.
See also:
operator*()

Vecnt< 3, T > & setVec | ( | Vecnt< 3, T > & | v,
 |  | T | x,
 |  | T | y,
 |  | T | z
 | ) | [inline]

Set the values of a three-component vector.

Parameters:
v | A reference to the vector to set with x, y and z.
x | The first component to set.
y | The second component to set.
z | The third component to set.

void smoothNormals | ( | const std::vector< Vecnt< 3, T > > & | vertices,
 |  | const Spherent< 3, T > & | sphere,
 |  | T | creaseAngle,
 |  | std::vector< Vecnt< 3, T > > & | normals
 | ) | [inline]

Determine smoothed normals for a set of vertices.

Parameters:
vertices | A constant reference to a vector of vertices.
sphere | A constant reference to the bounding sphere of the vertices.
creaseAngle | The angle in radians to crease at.
normals | A reference to a vector of normals.
Remarks:
Given vertices with normals and their bounding sphere, this function calculates smoothed normals in normals for the vertices. For all vertices, that are similar within a tolerance that depends on the radius of sphere, and whose normals differ less than creaseAngle (in radians), their normals are set to the average of their normals.

Vecnt< 4, T > & setVec | ( | Vecnt< 4, T > & | v,
 |  | T | x,
 |  | T | y,
 |  | T | z,
 |  | T | w
 | ) | [inline]

Set the values of a four-component vector.

Parameters:
v | A reference to the vector to set with x, y, z, and w.
x | The first component to set.
y | The second component to set.
z | The third component to set.
w | The fourth component to set.

NVSG_API void lerp | ( | float | alpha,
 |  | const nvsg::VertexAttribute & | va0,
 |  | const nvsg::VertexAttribute & | va1,
 |  | nvsg::VertexAttribute & | var
 | ) |

Linear interpolation between two VertexAttributes.

Parameters:
alpha | The interpolation parameter.
va0 | The starting value for the interpolation.
va1 | The ending value for the interpolation.
var | The resulting value of the interpolation.
Remarks:
Two VertexAttributes are linearly interpolated by linearly interpolating each of the corresponding vertex data elements.

nvsg::VNVector lerp | ( | float | alpha,
 |  | const nvsg::VNVector & | v0,
 |  | const nvsg::VNVector & | v1
 | ) | [inline]

Linear interpolation between two VNVector.

Performs a linear interpolation v = v0 + alpha * ( v1 - v0 ) of each corresponding vertex and normal of the two VNVector. The interpolated normals are normalized then.

Note:
The two VNVector are assumed to be the same size.
Returns:
a VNVector with the interpolated vertices and normals.
Parameters:
alpha | interpolation parameter
v0 | start value of interpolation
v1 | end value of interpolation

Variable Documentation

NVSG_API const Mat44f cIdentity44f

global identity matrix.

const float PI = 3.14159265358979323846f

constant PI

const float PI_HALF = 1.57079632679489661923f

constant PI half

const float PI_QUARTER = 0.78539816339744830962f

constant PI quarter

const float SQRT_TWO = 1.41421356237309504880f

constant square root two

const float SQRT_TWO_HALF = 0.70710678118654752440f

constant square root two half

Generated on Tue Jan 15 10:28:56 2008 for NVSGSDK by NVIDIA


nvsg Namespace Reference

Scenegrah classes - core NVSG. More...

Classes

class | AlphaTestAttribute
StateAttribute that defines the Alpha test. More...

class | AnimatedTransform
Class representing an animated Transform. More...

class | AnimatedVertexAttributeSet
Provides functionality to work with animated vertex attribute data. More...

class | AnimationBase
class | Animation
Class defining the common interface of an animation. More...

class | Billboard
Class that adds billboard properties to a Group. More...

class | BlendAttribute
StateAttribute that determines the blending modes to use. More...

class | CallbackServer
CallBackServer for associating CallBacks with objects. More...

class | Camera
Abstract base class for parallel and perspective cameras. More...

class | CgFxContext
CgFxContext wraps a CGcontext and maintains its state machine configuration. More...

class | CgFxEffect
Abstracts a render effect to be applied to a specific geometry. More...

class | CgFx
A StateAttribute to apply render effects that are compliant to the Cg 1.4 standard. More...

class | ChangeCallback
Abstract class for defining a CallBack on an object. More...

class | CullData
Class holding culling information of an object and it's children. More...

class | DALHostHolder
class | DALHost
Represents an object capable to host a Device Abstraction Link. More...

class | DALDataCreator
Represents the interface required for a creator of DALData. More...

class | DALData
Device Abstraction Link Data. More...

class | DepthAttribute
StateAttribute that determines the depth settings to use. More...

class | DirectedLight
LightSource representing a directed light. More...

class | Drawable
The abstract base class of all drawable objects. More...

class | NVSGException
class | Face
Simple helper class for Lines, Quads, and Triangles. More...

class | FaceAttribute
PrimitiveAttribute specific for Drawables with faces, like Triangles or QuadStrips. More...

class | FlipbookAnimation
Class representing a flipbook animation. More...

class | FramedAnimation
Template class of an Animation that holds a complete data set for each frame. More...

class | GeoNode
Leaf Node to maintain geometry. More...

struct | GeoNode::Geometry
class | Group
Provides grouping of Node objects. More...

class | HighlightBox
A HighlightObject that realizes a bounding box around a Drawable. More...

class | HighlightEdges
A HighlightObject that realizes a wireframe drawing of the highlighted PrimitiveSet. More...

class | HighlightObject
Abstract base class for highlighting objects. More...

class | IndependentPrimitiveSet
Abstract base class for PrimitiveSet objects with independent primitives. More...

class | KeyFramedAnimation
Abstract base class for key-framed Animations of type T. More...

class | LightingAttribute
StateAttribute indicating whether lighting should be disabled. More...

class | LightSource
Abstract base class for all light sources. More...

class | LinearInterpolatedAnimation
An KeyFramedAnimation class that performs linear interpolation. More...

class | LineAttribute
PrimitiveAttribute specific for Drawables with lines, like Lines or LineStrips. More...

class | Lines
IndependentPrimitiveSet for lines. More...

class | LineStrips
StrippedPrimitiveSet for line strips. More...

class | LOD
Distance-based level of detail class. More...

class | Map
Abstract base class for Map objects. More...

class | MapArray
Class to hold an array of Map objects. More...

class | MapElement
Class to hold a single Map. More...

class | MapList
Class to hold a list of two-dimensional maps. More...

class | MapMatrix
Class to hold a matrix of Map objects. More...

class | MapObject
Abstract base class to position one or more Map objects. More...

class | Material
StateAttribute that describes material properties. More...

class | IndexMesh
IndexSet specialization used with a MeshedPrimitiveSet. More...

class | MeshedPrimitiveSet
Abstract base class for PrimitiveSet objects with points organized as meshes. More...

class | Node
Serves as base class for all tree nodes. More...

class | Node::Parent
class | Object
Serves as base class for all traversable objects. More...

class | OwnedObject
Helper class to hold a vector of owners of an Object. More...

class | OwnedObject::Owner
class | ParallelCamera
Class describing a parallel (non-perspective) Camera. More...

class | Path
Class that represents a path through the tree. More...

class | PerspectiveCamera
Class describing a perspective Camera. More...

class | SceneLoader
Pure virtual base class for NVSG scene loader plug-ins. More...

class | SceneSaver
Pure virtual base class for NVSG scene saver plug-ins. More...

class | TextureLoader
Pure virtual base class for texture loader plugins. More...

class | TextureSaver
Pure virtual base class for texture saver plugins. More...

class | PointAttribute
PrimitiveAttribute specific for Points. More...

class | PointLight
LightSource representing a point light. More...

class | Points
IndependentPrimitiveSet for points. More...

class | PrimitiveAttribute
Base class for all primitive related StateAttribute classes. More...

class | PrimitiveSet
Base class for Drawable objects holding a VertexAttributeSet. More...

class | QuadMeshes
MeshedPrimitiveSet for quad meshes. More...

class | Quads
IndependentPrimitiveSet for quads. More...

class | QuadStrips
StrippedPrimitiveSet for quad strips. More...

class | Scene
Container class to hold all scene related information. More...

class | Shape
Abstract base class for shaped geometries like Boxes, Spheres, etc. More...

class | Skin
Provides functionality to work with skinned vertex attribute data. More...

class | Bone
An internal helper class for SkinnedTriangles. More...

class | SkinnedTriangles
Class representing a skinned Triangles. More...

struct | SkinnedTriangles::Skin
Internal helper class for SkinnedTriangles. More...

class | SpotLight
LightSource representing a spot light. More...

class | StateAttribute
Abstract base class of all attribute objects. More...

class | StatePass
Container class to hold a number of StateAttribute objects. More...

class | VariantIterator
Helper class used for iterating the StateVariant objects in a StateSet. More...

class | StateSet
Container class to hold a number of StateVariant objects. More...

class | StateVariant
Container class to hold a number of StatePass objects. More...

class | StrippedPrimitiveSet
Abstract base class for PrimitiveSet objects with points organized as strips. More...

class | Switch
Switch node. More...

class | TextureAttributeItemData
Data of a texture attribute item that is worth sharing. More...

class | TextureAttributeItem
Texture attribute item. More...

class | TextureAttribute
Texture attribute. More...

struct | Image
Helper structure to hold the data of an image. More...

class | TextureImage
A texture image abstraction class. More...

class | ScaleFilter
Scale Filter Functor. More...

class | BoxFilter
ScaleFilter functor providing box filter functionality. More...

class | TriangleFilter
ScaleFilter functor providing triangle filter functionality. More...

class | BellFilter
ScaleFilter functor providing bell filter functionality. More...

class | BSplineFilter
ScaleFilter functor providing BSpline filter functionality. More...

class | Lanczos3Filter
ScaleFilter functor providing lanczos3 filter functionality. More...

class | Transform
Transform node. More...

class | Triangles
IndependentPrimitiveSet for triangles. More...

class | TriFans
StrippedPrimitiveSet for quad strips. More...

class | TriStrips
StrippedPrimitiveSet for triangle strips. More...

struct | Type2EnumType
Converts a given type into a symbolic constant representing a NVSG type. More...

struct | Type2EnumType< char >
struct | Type2EnumType< unsigned char >
struct | Type2EnumType< short >
struct | Type2EnumType< unsigned short >
struct | Type2EnumType< int >
struct | Type2EnumType< unsigned int >
struct | Type2EnumType< float >
struct | Type2EnumType< double >
class | UnlitColorAttribute
StateAttribute specifying the color in case there is no lighting. More...

class | VertexAttribute
Class to hold the data of one vertex attribute. More...

class | VertexAttributeSet
Provides an interface to deal with vertex attribute data. More...

class | ViewState
The ViewState class encapsulates the view-specific states. More...

class | VNVector
A helper class for use in animation. More...

class | VolumeBrick
Class to represent one brick of a volume. More...

class | VolumeNode
Class to hold a volume. More...

class | VolumeTexture
A class representing a VolumeTexture. More...

Typedefs

typedef nvutil::Singleton<
CallbackServer > 		CBS
Type define for the application unique CallBackServer.

typedef CGIAnnotation * | CgFxAnnotation
Typedef for an annotation handle.

typedef CGIParameter * | CgFxParameter
Typedef for a parameter handle.

typedef CGITechnique * | CgFxTechnique
Typedef for a technique handle.

typedef CGIPass * | CgFxPass
Typedef for a pass handle.

typedef CGIProgram * | CgFxProgram
Typedef for a program handle.

typedef std::vector< unsigned
int > 		IndexSet
typedef nvutil::Handle< Object > | ObjectHandle
typedef nvutil::Handle< Camera,
ObjectHandle > 		CameraHandle
typedef nvutil::Handle< ParallelCamera,
CameraHandle > 		ParallelCameraHandle
typedef nvutil::Handle< PerspectiveCamera,
CameraHandle > 		PerspectiveCameraHandle
typedef nvutil::Handle< Node,
ObjectHandle > 		NodeHandle
typedef nvutil::Handle< Group,
NodeHandle > 		GroupHandle
typedef nvutil::Handle< Billboard,
GroupHandle > 		BillboardHandle
typedef nvutil::Handle< FlipbookAnimation,
GroupHandle > 		FlipbookAnimationHandle
typedef nvutil::Handle< LOD,
GroupHandle > 		LODHandle
typedef nvutil::Handle< Transform,
GroupHandle > 		TransformHandle
typedef nvutil::Handle< AnimatedTransform,
TransformHandle > 		AnimatedTransformHandle
typedef nvutil::Handle< Switch,
GroupHandle > 		SwitchHandle
typedef nvutil::Handle< LightSource,
ObjectHandle > 		LightSourceHandle
typedef nvutil::Handle< DirectedLight,
LightSourceHandle > 		DirectedLightHandle
typedef nvutil::Handle< PointLight,
LightSourceHandle > 		PointLightHandle
typedef nvutil::Handle< SpotLight,
LightSourceHandle > 		SpotLightHandle
typedef nvutil::Handle< GeoNode,
NodeHandle > 		GeoNodeHandle
typedef nvutil::Handle< Drawable,
ObjectHandle > 		DrawableHandle
typedef nvutil::Handle< PrimitiveSet,
DrawableHandle > 		PrimitiveSetHandle
typedef nvutil::Handle< IndependentPrimitiveSet,
PrimitiveSetHandle > 		IndependentPrimitiveSetHandle
typedef nvutil::Handle< Quads,
IndependentPrimitiveSetHandle > 		QuadsHandle
typedef nvutil::Handle< Triangles,
IndependentPrimitiveSetHandle > 		TrianglesHandle
typedef nvutil::Handle< SkinnedTriangles,
TrianglesHandle > 		SkinnedTrianglesHandle
typedef nvutil::Handle< Lines,
IndependentPrimitiveSetHandle > 		LinesHandle
typedef nvutil::Handle< Points,
IndependentPrimitiveSetHandle > 		PointsHandle
typedef nvutil::Handle< MeshedPrimitiveSet,
PrimitiveSetHandle > 		MeshedPrimitiveSetHandle
typedef nvutil::Handle< QuadMeshes,
MeshedPrimitiveSetHandle > 		QuadMeshesHandle
typedef nvutil::Handle< StrippedPrimitiveSet,
PrimitiveSetHandle > 		StrippedPrimitiveSetHandle
typedef nvutil::Handle< QuadStrips,
StrippedPrimitiveSetHandle > 		QuadStripsHandle
typedef nvutil::Handle< TriFans,
StrippedPrimitiveSetHandle > 		TriFansHandle
typedef nvutil::Handle< TriStrips,
StrippedPrimitiveSetHandle > 		TriStripsHandle
typedef nvutil::Handle< LineStrips,
StrippedPrimitiveSetHandle > 		LineStripsHandle
typedef nvutil::Handle< Shape,
DrawableHandle > 		ShapeHandle
typedef nvutil::Handle< VertexAttributeSet,
ObjectHandle > 		VertexAttributeSetHandle
typedef nvutil::Handle< AnimatedVertexAttributeSet,
VertexAttributeSetHandle > 		AnimatedVertexAttributeSetHandle
typedef nvutil::Handle< Skin,
ObjectHandle > 		SkinHandle
typedef nvutil::Handle< StateAttribute,
ObjectHandle > 		StateAttributeHandle
typedef nvutil::Handle< CgFx,
StateAttributeHandle > 		CgFxHandle
typedef nvutil::Handle< CgFxEffect > | CgFxEffectHandle
typedef nvutil::Handle< Material,
StateAttributeHandle > 		MaterialHandle
typedef nvutil::Handle< TextureAttribute,
StateAttributeHandle > 		TextureAttributeHandle
typedef nvutil::Handle< TextureAttributeItem,
ObjectHandle > 		TextureAttributeItemHandle
typedef nvutil::Handle< BlendAttribute,
StateAttributeHandle > 		BlendAttributeHandle
typedef nvutil::Handle< AlphaTestAttribute,
StateAttributeHandle > 		AlphaTestAttributeHandle
typedef nvutil::Handle< DepthAttribute,
StateAttributeHandle > 		DepthAttributeHandle
typedef nvutil::Handle< UnlitColorAttribute,
StateAttributeHandle > 		UnlitColorAttributeHandle
typedef nvutil::Handle< PrimitiveAttribute,
StateAttributeHandle > 		PrimitiveAttributeHandle
typedef nvutil::Handle< FaceAttribute,
PrimitiveAttributeHandle > 		FaceAttributeHandle
typedef nvutil::Handle< LightingAttribute,
StateAttributeHandle > 		LightingAttributeHandle
typedef nvutil::Handle< LineAttribute,
PrimitiveAttributeHandle > 		LineAttributeHandle
typedef nvutil::Handle< PointAttribute,
PrimitiveAttributeHandle > 		PointAttributeHandle
typedef nvutil::Handle< StateSet,
ObjectHandle > 		StateSetHandle
typedef nvutil::Handle< StateVariant,
ObjectHandle > 		StateVariantHandle
typedef nvutil::Handle< StatePass,
ObjectHandle > 		StatePassHandle
typedef nvutil::Handle< AnimationBase,
ObjectHandle > 		AnimationBaseHandle
typedef nvutil::Handle< Animation<
VertexAttribute >, AnimationBaseHandle > 		VertexAttributeAnimationHandle
typedef nvutil::Handle< FramedAnimation<
VertexAttribute >, VertexAttributeAnimationHandle > 		FramedVertexAttributeAnimationHandle
typedef nvutil::Handle< KeyFramedAnimation<
VertexAttribute >, VertexAttributeAnimationHandle > 		KeyFramedVertexAttributeAnimationHandle
typedef nvutil::Handle< LinearInterpolatedAnimation<
VertexAttribute >, KeyFramedVertexAttributeAnimationHandle > 		LinearInterpolatedVertexAttributeAnimationHandle
typedef nvutil::Handle< Animation<
nvmath::Trafo >, AnimationBaseHandle > 		TrafoAnimationHandle
typedef nvutil::Handle< FramedAnimation<
nvmath::Trafo >, TrafoAnimationHandle > 		FramedTrafoAnimationHandle
typedef nvutil::Handle< KeyFramedAnimation<
nvmath::Trafo >, TrafoAnimationHandle > 		KeyFramedTrafoAnimationHandle
typedef nvutil::Handle< LinearInterpolatedAnimation<
nvmath::Trafo >, KeyFramedTrafoAnimationHandle > 		LinearInterpolatedTrafoAnimationHandle
typedef nvutil::Handle< Animation<
unsigned int >, AnimationBaseHandle > 		IndexAnimationHandle
typedef nvutil::Handle< FramedAnimation<
unsigned int >, IndexAnimationHandle > 		FramedIndexAnimationHandle
typedef nvutil::Handle< HighlightObject,
ObjectHandle > 		HighlightObjectHandle
typedef nvutil::Handle< HighlightBox,
HighlightObjectHandle > 		HighlightBoxHandle
typedef nvutil::Handle< HighlightEdges,
HighlightObjectHandle > 		HighlightEdgesHandle
typedef nvutil::Handle< MapObject,
ObjectHandle > 		MapObjectHandle
typedef nvutil::Handle< MapArray,
MapObjectHandle > 		MapArrayHandle
typedef nvutil::Handle< MapElement,
MapObjectHandle > 		MapElementHandle
typedef nvutil::Handle< MapMatrix,
MapObjectHandle > 		MapMatrixHandle
typedef nvutil::Handle< MapList,
ObjectHandle > 		MapListHandle
typedef nvutil::Handle< TextureImage > | TextureImageHandle
typedef nvutil::Handle< VolumeTexture,
TextureImageHandle > 		VolumeTextureHandle
typedef nvutil::Handle< Scene > | SceneHandle
typedef nvutil::Handle< ViewState > | ViewStateHandle
typedef nvutil::Handle< VolumeNode,
NodeHandle > 		VolumeNodeHandle
typedef nvutil::Handle< VolumeBrick,
ObjectHandle > 		VolumeBrickHandle
typedef nvutil::Handle< DALHost > | DALHostHandle
typedef DWORD | THREADID
typedef unsigned long | HDAL
Handle to a Device Abstraction Link (DAL).

typedef void | NVSGERRORHANDLER (const NVSGException &)
typedef Face< 2 > | Segment
Shortcut for a 2-element Face (line segment).

typedef Face< 3 > | Face3
Shortcut for a 3-element Face (triangle).

typedef Face< 4 > | Face4
Shortcut for a 4-element Face (quad).

typedef unsigned long long | DataID
64-bit save DataID.

typedef unsigned int | VariantKey
Key to a specific StateVariant.

Enumerations

enum AlphaFunction {
AF_NEVER = 0, AF_LESS, AF_EQUAL, AF_LEQUAL,
AF_GREATER, AF_NOTEQUAL, AF_GEQUAL, AF_ALWAYS
}
Enumeration to identify the AlphaFunc conditional. More...

enum BlendFunction {
BF_ZERO, BF_ONE, BF_DESTINATION_COLOR, BF_SOURCE_COLOR,
BF_ONE_MINUS_DESTINATION_COLOR, BF_ONE_MINUS_SOURCE_COLOR, BF_SOURCE_ALPHA, BF_ONE_MINUS_SOURCE_ALPHA,
BF_DESTINATION_ALPHA, BF_ONE_MINUS_DESTINATION_ALPHA, BF_SOURCE_ALPHA_SATURATE
}
Enumeration to identify a blend function. More...

enum | CullCode { CC_OUT, CC_IN, CC_PART }
Type to describe the cull code of an object. More...

enum DepthFunction {
DF_NEVER, DF_ALWAYS, DF_LESS, DF_LESS_OR_EQUAL,
DF_EQUAL, DF_GREATER_OR_EQUAL, DF_GREATER, DF_NOT_EQUAL
}
Enumeration to identify a depth function. More...

enum | FaceMode { FM_POINT, FM_LINE, FM_FACE }
enum | MapAlignment { MA_LOWER, MA_CENTER, MA_UPPER }
Enumeration to define the alignment of a MapObject holding more than one Map. More...

enum | MapOrientation { MO_HORIZONTAL, MO_VERTICAL }
Enumeration to determine the horizontal or vertical orientation of a MapObject. More...

enum MapRelation {
MR_LOWER_LEFT, MR_LOWER_CENTER, MR_LOWER_RIGHT, MR_CENTER_LEFT,
MR_CENTER, MR_CENTER_RIGHT, MR_UPPER_LEFT, MR_UPPER_CENTER,
MR_UPPER_RIGHT
}
Enumeration to define the anchor relation of the MapObject position. More...

enum | MapTraversalDirection { MTD_LOW_TO_HIGH, MTD_HIGH_TO_LOW }
Enumeration to define the traversal direction of a MapObject holding more than one Map. More...

enum | MaterialFace { MF_FRONT = 0x01, MF_BACK = 0x02, MF_FRONT_AND_BACK = MF_FRONT | MF_BACK }
ID to identify the front and back face properties of a Material. More...

enum | NVSGThreadingModelEnum { NVSG_SINGLETHREADED = 0, NVSG_MULTITHREADED }
enum | NVSG3DAPIEnum { NVSG_3DAPI_GL = 0 }
enum | NVSGFeatureSupportedEnum { NVSG_FAST_TEXTURE_UPLOAD = BIT0, NVSG_VOLUME_RENDERING = BIT1 }
enum {
OC_INVALID = 0xFFFFFFFF, OC_OBJECT = 0, OC_NODE = OC_OBJECT, OC_GEONODE,
OC_GROUP, OC_FLIPBOOKANIMATION, OC_LOD, OC_SWITCH,
OC_TRANSFORM, OC_ANIMATEDTRANSFORM, OC_DIRECTEDLIGHT, OC_POINTLIGHT,
OC_SPOTLIGHT, OC_BILLBOARD, OC_VOLUMENODE, OC_VOLUMEBRICK,
OC_DRAWABLES = 0x20, OC_VERTEX_ATTRIBUTE_SET, OC_ANIMATED_VERTEX_ATTRIBUTE_SET, OC_QUADS,
OC_QUADSTRIPS, OC_TRIANGLES, OC_SKINNEDTRIANGLES, OC_TRISTRIPS,
OC_LINES, OC_LINESTRIPS, OC_TRIFANS, OC_POINTS,
OC_SHAPE, OC_BITMAP, OC_PIXMAP, OC_MAPELEMENT,
OC_MAPARRAY, OC_MAPMATRIX, OC_MAPLIST, OC_QUADMESHES,
OC_SKIN, OC_STATESET = 0x40, OC_STATEVARIANT, OC_STATEPASS,
OC_STATEATTRIBUTE, OC_CGFX, OC_FACEATTRIBUTE, OC_MATERIAL,
OC_TEXTUREATTRIBUTE, OC_TEXTUREATTRIBUTEITEM, OC_STATESETEXT, OC_LINEATTRIBUTE,
OC_LIGHTINGATTRIBUTE, OC_POINTATTRIBUTE, OC_BLENDATTRIBUTE, OC_ALPHATESTATTRIBUTE,
OC_DEPTHATTRIBUTE, OC_UNLITCOLORATTRIBUTE, OC_ANIMATION = 0x60, OC_FRAMEDINDEXANIMATION,
OC_FRAMEDTRAFOANIMATION, OC_LINEARINTERPOLATEDTRAFOANIMATION, OC_FRAMEDVERTEXATTRIBUTEANIMATION, OC_LINEARINTERPOLATEDVERTEXATTRIBUTEANIMATION,
OC_CAMERA = 0x80, OC_PARALLELCAMERA, OC_PERSPECTIVECAMERA, OC_HIGHLIGHTOBJECT = 0xA0,
OC_HIGHLIGHTBOX, OC_HIGHLIGHTEDGES, OC_CUSTOMOBJECT = 0xC0
}
Object Codes for NVSG Object Type Identification. More...

enum {
SF_CONTAINS_CGFX = BIT0, SF_CONTAINS_CGFX_VALID = BIT1, SF_CONTAINS_TRANSPARENCY = BIT2, SF_CONTAINS_TRANSPARENCY_VALID = BIT3,
SF_CONTAINS_MASK = SF_CONTAINS_CGFX | SF_CONTAINS_TRANSPARENCY, SF_CONTAINS_VALID_MASK = SF_CONTAINS_MASK << 1
}
enum | TexCoordAxis { TCA_S = 0, TCA_T, TCA_R, TCA_Q }
Texture coordinate axis. More...

enum TextureEnvMode {
TEM_REPLACE = 0, TEM_MODULATE, TEM_DECAL, TEM_BLEND,
TEM_ADD, TEM_ADD_SIGNED, TEM_SUBTRACT, TEM_INTERPOLATE,
TEM_DOT3_RGB, TEM_DOT3_RGBA
}
Texture environment mode. More...

enum | TextureEnvScale { TES_1X = 1, TES_2X = 2, TES_4X = 4 }
Texture environment scale. More...

enum TexGenMode {
TGM_OFF = -1, TGM_OBJECT_LINEAR, TGM_EYE_LINEAR, TGM_SPHERE_MAP,
TGM_REFLECTION_MAP, TGM_NORMAL_MAP
}
Texture coordinate generation mode. More...

enum | TexGenLinearPlane { TGLP_OBJECT = 0, TGLP_EYE, TGLP_OBJECT_AND_EYE }
Texture generation plane. More...

enum | TexWrapCoordAxis { TWCA_S = 0, TWCA_T, TWCA_R }
Texture wrap coordinate axis. More...

enum TextureWrapMode {
TWM_REPEAT = 0, TWM_CLAMP, TWM_MIRROR_REPEAT, TWM_CLAMP_TO_EDGE,
TWM_CLAMP_TO_BORDER, TWM_MIRROR_CLAMP, TWM_MIRROR_CLAMP_TO_EDGE, TWM_MIRROR_CLAMP_TO_BORDER
}
Texture wrap mode. More...

enum TextureMinFilterMode {
TFM_MIN_NEAREST = 0, TFM_MIN_LINEAR, TFM_MIN_BILINEAR = TFM_MIN_LINEAR, TFM_MIN_LINEAR_MIPMAP_LINEAR,
TFM_MIN_TRILINEAR = TFM_MIN_LINEAR_MIPMAP_LINEAR, TFM_MIN_NEAREST_MIPMAP_NEAREST, TFM_MIN_NEAREST_MIPMAP_LINEAR, TFM_MIN_LINEAR_MIPMAP_NEAREST
}
Texture minification mode. More...

enum | TextureMagFilterMode { TFM_MAG_NEAREST = 0, TFM_MAG_LINEAR, TFM_MAG_BILINEAR = TFM_MAG_LINEAR }
Texture magnification mode. More...

enum TextureTarget {
NVSG_UNSPECIFIED_TEXTURE_TARGET = ~0, NVSG_TEXTURE_1D = 0, NVSG_TEXTURE_2D, NVSG_TEXTURE_3D,
NVSG_TEXTURE_CUBE, NVSG_TEXTURE_1D_ARRAY, NVSG_TEXTURE_2D_ARRAY, NVSG_TEXTURE_RECTANGLE,
NVSG_TEXTURE_TARGET_COUNT
}
Texture target specifier. More...

enum {
NVSG_UNSUPPORTED_TYPE = -1, NVSG_BYTE = 0, NVSG_UNSIGNED_BYTE, NVSG_SHORT,
NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT,
NVSG_DOUBLE
}
enum | TextureCoordType { TCT_CYLINDRICAL, TCT_PLANAR, TCT_SPHERICAL }
Type to specify the type of texture coordinate to generate. More...

Functions

template<typename T> T | camera_cast (const Camera *camera)
template<typename T> T | camera_cast (Camera *camera)
NVSG_API CgFxContext * | cgfxContext ()
Returns the CgFxContext singleton object.

THREADID | getCallingThread ()
template<typename T> T | drawable_cast (const Drawable *drwbl)
template<typename T> T | drawable_cast (Drawable *drwbl)
NVSGERRORHANDLER * | nvsgSetErrorHandler (NVSGERRORHANDLER *newErrorHandler)
template<> | FramedAnimation< nvmath::Trafo >::FramedAnimation (void)
template<> | FramedAnimation< nvmath::Trafo >::FramedAnimation (const Animation< nvmath::Trafo > &rhs)
template<> | FramedAnimation< nvmath::Trafo >::FramedAnimation (const FramedAnimation< nvmath::Trafo > &rhs)
template<typename T> T | light_cast (const LightSource *light)
template<typename T> T | light_cast (LightSource *light)
template<> | LinearInterpolatedAnimation< nvmath::Trafo >::LinearInterpolatedAnimation ()
template<> | LinearInterpolatedAnimation< nvmath::Trafo >::LinearInterpolatedAnimation (const KeyFramedAnimation< nvmath::Trafo > &rhs)
template<> | LinearInterpolatedAnimation< nvmath::Trafo >::LinearInterpolatedAnimation (const LinearInterpolatedAnimation< nvmath::Trafo > &rhs)
bool | isEmptyBoundingSphere (NodeHandle *node)
Tests whether the bounding sphere of the specified Node is empty.

nvmath::Sphere3f | getBoundingSphere (NodeHandle *node)
Returns a copy of the specified Node's bounding sphere.

template<typename T> T | node_cast (const Node *node)
template<typename T> T | node_cast (Node *node)
NVSG_API void | nvsgInitialize (NVSGThreadingModelEnum threadingModel=NVSG_SINGLETHREADED, NVSG3DAPIEnum graphicsAPI=NVSG_3DAPI_GL)
Per-application initialization of NVSG global data.

NVSG_API void | nvsgTerminate ()
Per-application termination of nvsg global data.

NVSG_API void | getVersionString (std::string &string)
Get the version string of the NVSGSDK.

NVSG_API void | getSDKName (std::string &string)
Get the NVSGSDK name string.

NVSG_API void | getCopyrightString (std::string &string)
Get the NVSGSDK copyright string.

NVSG_API void | getVendorName (std::string &string)
Get the NVSGSDK vendor name.

NVSG_API unsigned int | getSupportedFeatures ()
Get a bit field of the supported features.

template<typename T> void | NVSG_ASSERT_OBJECT_WRITE_LOCKED (const T *obj)
template<typename T> void | NVSG_ASSERT_OBJECT_READ_LOCKED (const T *obj)
template<typename T> bool | isTypeOf (ObjectHandle *p)
Detects if the object pointed to by p is a pointer to a specified (templated) type.

bool | areOfSameType (ObjectHandle *p0, ObjectHandle *p1)
Detects if the two objects p0 and p1 are of the same type.

template<typename OwnerType, typename OwnedHandleType> void | addAsOwnerTo (OwnerType *owner, OwnedHandleType *owned)
template<typename OwnerType, typename OwnedHandleType> void | removeAsOwnerFrom (OwnerType *owner, OwnedHandleType *owned)
NVSG_API TextureTarget | determineTextureTarget (TextureImageHandle *img)
Retrieves the best-matching TextureTarget from A TextureImage.

NVSG_API unsigned char * | dbgAllocImagePixels (unsigned int nbytes, unsigned int line)
Same as allocImagePixels + leak detection.

NVSG_API void | freeImagePixels (unsigned char *pixels)
Helper function to free memory of pixel data.

NVSG_API unsigned int | numberOfComponents (Image::PixelFormat format)
Helper function to determine the number of components of a PixelFormat.

NVSG_API unsigned int | sizeOfComponents (Image::PixelDataType type)
Helper function to determine the size of components of a PixelDataType.

NVSG_API void | calculateContributions (std::vector< std::vector< std::pair< unsigned int, float > > > &contribs, unsigned int srcSize, unsigned int dstSize, const ScaleFilter *filter)
Helper function to determine the contributions of a ScaleFilter on scaling an Image.

NVSG_API void | insert (const Image *src, Image *dst, unsigned int x, unsigned int y, unsigned int z)
Helper function to insert a source image into a destination image at a given position.

NVSG_API void | rescale (const Image *src, Image *dst, std::vector< std::vector< std::pair< unsigned int, float > > > *contributions)
Helper function to rescale an Image using the contributions of a ScaleFilter.

NVSG_API void | convertPixelFormat (const Image *src, Image *dst, Image::PixelFormat destFormat)
Helper function to convert the image format from one to another.

NVSG_API void | assertMipMapChainComplete (const TextureImage *img)
Asserts mipmap chain to be complete for the specified TextureImage.

NVSG_API unsigned int | sizeOfType (unsigned int type)
Yields the size in bytes of the respective type.

NVSG_API bool | isIntegerType (unsigned int type)
NVSG_API bool | isFloatingPointType (unsigned int type)
NVSG_API void | normalize (VertexAttribute &va)
Normalize all vertex data elements of a VertexAttribute.

NVSG_API bool | operator== (const VertexAttribute &va0, const VertexAttribute &va1)
Equality operator.

NVSG_API bool | operator!= (const VertexAttribute &va0, const VertexAttribute &va1)
Inequality operator.

NVSG_API bool | genericAttrib (unsigned int attrib)
Determine if an attribute identifier identifies a generic or a conventional attribute.

NVSG_API unsigned int | attribIndex (unsigned int attrib)
Translates an attribute identifier to the corresponding conventional attribute identifier.

nvmath::Vec3f | getSubBrickPosition (const nvmath::Vec3f &pos, const nvmath::Vec3f &halfSize, unsigned int brickIndex)
Helper function to get the position of a brick inside its surrounding brick.

Variables

const HDAL | HDAL_INVALID
Indicates a invalid handle value.

NVSGERRORHANDLER * nvsgErrorHandler

Detailed Description

Scenegrah classes - core NVSG.

This namespace contains all core NVSG classes. Put all the scenegraph and node related classes in here.

Typedef Documentation

typedef nvutil::Singleton<CallbackServer> CBS

Type define for the application unique CallBackServer.

typedef CGIAnnotation* CgFxAnnotation

Typedef for an annotation handle.

typedef CGIParameter* CgFxParameter

Typedef for a parameter handle.

typedef CGITechnique* CgFxTechnique

Typedef for a technique handle.

typedef CGIPass* CgFxPass

Typedef for a pass handle.

typedef CGIProgram* CgFxProgram

Typedef for a program handle.

typedef unsigned long HDAL

Handle to a Device Abstraction Link (DAL).

typedef void NVSGERRORHANDLER(const NVSGException&)

A NVSG error handler routine is of this type

typedef Face<2> Segment

Shortcut for a 2-element Face (line segment).

typedef Face<3> Face3

Shortcut for a 3-element Face (triangle).

typedef Face<4> Face4

Shortcut for a 4-element Face (quad).

typedef unsigned long long DataID

64-bit save DataID.

Remarks:
The DataID is used to uniquely identify an Object's embedded data.
See also:
Object::getDataID

typedef unsigned int VariantKey

Key to a specific StateVariant.

Enumeration Type Documentation

enum AlphaFunction

Enumeration to identify the AlphaFunc conditional.

Namespace: nvsg
Remarks:
AlphaTest can be used in cases where the fragment is to be drawn or culled based on the alpha value. The AlphaFunction along with the threshold value define the equation used to determine whether the fragment is drawn.
See also:
BlendAttribute

enum BlendFunction

Enumeration to identify a blend function.

Namespace: nvsg
Remarks:
A BlendFunction indicates how a blending function is to be computed. In the description of the possible values, source and destination are indicated with the suffix s and d, respectively. Subtraction of quadruplets means subtracting them component-wise.
See also:
BlendAttribute
Enumeration values:
BF_ZERO | (0,0,0,0); available for source and destination
BF_ONE | (1,1,1,1); available for source and destination
BF_DESTINATION_COLOR | (Rd,Gd,Bd,Ad); available for source only
BF_SOURCE_COLOR | (Rs,Gs,Bs,As); available for destination only
BF_ONE_MINUS_DESTINATION_COLOR | (1,1,1,1)-(Rd,Gd,Bd,Ad); available for source only
BF_ONE_MINUS_SOURCE_COLOR | (1,1,1,1)-(Rs,Gs,Bs,As); available for destination only
BF_SOURCE_ALPHA | (As,As,As,As); available for source and destination
BF_ONE_MINUS_SOURCE_ALPHA | (1,1,1,1)-(As,As,As,As); available for source and destination
BF_DESTINATION_ALPHA | (Ad,Ad,Ad,Ad); available for source and destination
BF_ONE_MINUS_DESTINATION_ALPHA | (1,1,1,1)-(Ad,Ad,Ad,Ad); available for source and destination
BF_SOURCE_ALPHA_SATURATE | (f,f,f,1) with f=min(As,1-Ad); available for source only

enum CullCode

Type to describe the cull code of an object.

Namespace: nvsg
Remarks:
With a CullCode, an object can be marked to be completely out (CC_OUT), completely in (CC_IN) or partially in and out (CC_PART) with respect to a view volume.
See also:
CullData
Enumeration values:
CC_OUT | an object is completely outside
CC_IN | an object is completely inside
CC_PART | an object is partially in and partially out

enum DepthFunction

Enumeration to identify a depth function.

Namespace: nvsg
Remarks:
On rendering, an incoming fragment passes the depth test if its z value has the specified relation to the value already stored in the depth buffer. The default is DF_LESS, which means that an incoming fragment passes the test if its z value is less than that already stored in the depth buffer. In this case, the z value represents the distance from the object to the viewpoint, and smaller values mean the corresponding objects are closer to the viewpoint.
See also:
DepthAttribute

enum MapAlignment

Enumeration to define the alignment of a MapObject holding more than one Map.

Namespace: nvsg
Remarks:
In a MapArray and a MapMatrix, the Map objects can be aligned along the lower base line (bottom or left), the center line, or the upper base line (top or right).
See also:
MapArray, MapMatrix
Enumeration values:
MA_LOWER | draw Map objects aligned at the lower coordinate
MA_CENTER | draw Map objects aligned at the center coordinate
MA_UPPER | draw Map objects aligned at the upper coordinate

enum MapOrientation

Enumeration to determine the horizontal or vertical orientation of a MapObject.

Namespace: nvsg
Remarks:
A MapArray can either be oriented horizontally or vertically. A MapMatrix has settings like alignment or spacing, independently in both orientations.
See also:
MapArray, MapMatrix
Enumeration values:
MO_HORIZONTAL | use the horizontal orientation
MO_VERTICAL | use the vertical orientation

enum MapRelation

Enumeration to define the anchor relation of the MapObject position.

Namespace: nvsg
Remarks:
The position of a MapObject describes one of nine possible relative positions, such as the lower left, the center, or the upper right.
See also:
MapObject
Enumeration values:
MR_LOWER_LEFT | position is lower left of MapObject
MR_LOWER_CENTER | position is lower center of MapObject
MR_LOWER_RIGHT | position is lower right of MapObject
MR_CENTER_LEFT | position is center left of MapObject
MR_CENTER | position is center of MapObject
MR_CENTER_RIGHT | position is center right of MapObject
MR_UPPER_LEFT | position is upper left of MapObject
MR_UPPER_CENTER | position is upper center of MapObject
MR_UPPER_RIGHT | position is upper right of MapObject

enum MapTraversalDirection

Enumeration to define the traversal direction of a MapObject holding more than one Map.

Namespace: nvsg
Remarks:
A MapArray can be traversed from the lower to the higher index, or vice versa.
A columns of a MapMatrix can also be traversed from the lower to the higher index, or vice versa; each column of a MapMatrix in turn can be traversed from the lower to the higher index, or vice versa, but all columns of a MapMatrix must be traversed in the same way.
See also:
MapArray, MapMatrix
Enumeration values:
MTD_LOW_TO_HIGH | traverse from lowest to highest index
MTD_HIGH_TO_LOW | traverse from highest to lowest index

enum MaterialFace

ID to identify the front and back face properties of a Material.

Namespace: nvsg
Remarks:
All the properties of a Material can be independently set for the front and the back faces.
See also:
Material
Enumeration values:
MF_FRONT | used for front material
MF_BACK | used for back material
MF_FRONT_AND_BACK | used for both front and back material

anonymous enum

Object Codes for NVSG Object Type Identification.

Remarks:
For a custom traverser it is essential to identify all actual scene graph components while traversing the scene graph, and to call the corresponding handler routine for a particular object. For this reason, all concrete NVSG object types must be assigned to a unique object code. Secure object codes for custom defined NVSG objects start at OC_CUSTOMOBJECT.
Note:
Choosing an object code lower than OC_CUSTOMOBJECT for a custom-defined NVSG object results in undefined runtime behavior!
See also:
How to Derive a Traverser How to Derive an NVSG Object
Enumeration values:
OC_INVALID | invalid object code
OC_OBJECT | Object.
OC_NODE | Node = 0x00.
OC_GEONODE | GeoNode.
OC_GROUP | Group.
OC_FLIPBOOKANIMATION | FlipbookAnimation.
OC_LOD | LOD.
OC_SWITCH | Switch.
OC_TRANSFORM | Transform.
OC_ANIMATEDTRANSFORM | AnimatedTransform.
OC_DIRECTEDLIGHT | DirectedLight.
OC_POINTLIGHT | PointLight.
OC_SPOTLIGHT | SpotLight.
OC_BILLBOARD | Billboard.
OC_VOLUMENODE | VolumeNode.
OC_VOLUMEBRICK | VolumeBrick.
OC_DRAWABLES | Drawable = 0x20.
OC_VERTEX_ATTRIBUTE_SET | VertexAttributeSet.
OC_ANIMATED_VERTEX_ATTRIBUTE_SET | AnimatedVertexAttributeSet.
OC_QUADS | Quads.
OC_QUADSTRIPS | QuadStrips.
OC_TRIANGLES | Triangles.
OC_SKINNEDTRIANGLES | Obsolete.
OC_TRISTRIPS | TriStrips.
OC_LINES | Lines.
OC_LINESTRIPS | LineStrips.
OC_TRIFANS | TriFans.
OC_POINTS | Points.
OC_SHAPE | Shape.
OC_BITMAP | Bitmap.
OC_PIXMAP | Pixmap.
OC_MAPELEMENT | MapElement.
OC_MAPARRAY | MapArray.
OC_MAPMATRIX | MapMatrix.
OC_MAPLIST | MapList.
OC_QUADMESHES | QuadMeshes.
OC_SKIN | Skin.
OC_STATESET | StateSet = 0x40.
OC_STATEVARIANT | StateVariant.
OC_STATEPASS | StatePass.
OC_STATEATTRIBUTE | StateAttribute.
OC_CGFX | CgFX.
OC_FACEATTRIBUTE | FaceAttribute.
OC_MATERIAL | Material.
OC_TEXTUREATTRIBUTE | TextureAttribute.
OC_TEXTUREATTRIBUTEITEM | TextureAttributeItem.
OC_STATESETEXT | StateSet for default and override state set.
OC_LINEATTRIBUTE | LineAttribute.
OC_LIGHTINGATTRIBUTE | LightingAttribute.
OC_POINTATTRIBUTE | PointAttribute.
OC_BLENDATTRIBUTE | BlendAttribute.
OC_ALPHATESTATTRIBUTE | AlphaTestAttribute.
OC_DEPTHATTRIBUTE | DepthAttribute.
OC_UNLITCOLORATTRIBUTE | UnlitColorAttribute.
OC_ANIMATION | Animation = 0x60.
OC_FRAMEDINDEXANIMATION | FramedIndexAnimation.
OC_FRAMEDTRAFOANIMATION | FramedTrafoAnimation.
OC_LINEARINTERPOLATEDTRAFOANIMATION | LinearInterpolatedTrafoAnimation.
OC_FRAMEDVERTEXATTRIBUTEANIMATION | FramedVertexAttributeAnimation.
OC_LINEARINTERPOLATEDVERTEXATTRIBUTEANIMATION | LinearInterpolatedVertexAttributeAnimation.
OC_CAMERA | Camera = 0x80.
OC_PARALLELCAMERA | ParallelCamera.
OC_PERSPECTIVECAMERA | PerspectiveCamera.
OC_HIGHLIGHTOBJECT | HighlightObject = 0xA0.
OC_HIGHLIGHTBOX | HighlightBox.
OC_HIGHLIGHTEDGES | HighlightEdges.
OC_CUSTOMOBJECT | CustomObjects = 0xC0.

enum TexCoordAxis

Texture coordinate axis.

Enumeration values:
TCA_S | S axis.
TCA_T | T axis.
TCA_R | R axis.
TCA_Q | Q axis.

enum TextureEnvMode

Texture environment mode.

Enumeration values:
TEM_REPLACE | C = C_t; A = A_t.
TEM_MODULATE | C = C_f*C_t; A = A_f*A_t.
TEM_DECAL | C = C_f*(1-A_t)+C_t*A_t; A = A_f.
TEM_BLEND | C = C_f*(1-C_t)+C_c*C_t; A = A_f*A_t.
TEM_ADD | C = min(1,C_f+C_t); A = A_f*A_t.
TEM_ADD_SIGNED | C = texUnitCur + texUnitPrev - 0.5; A = Ac*Ap.
TEM_SUBTRACT | C = texUnitCur - texUnitPrev; A = Ac*Ap.
TEM_INTERPOLATE | C = tUC * (tevColor) + tUP * (1-tevColor); A = Ac*Ap.
TEM_DOT3_RGB | C = texUnitCur.rgb dot texUnitPrev.rgb; A = N/A.
TEM_DOT3_RGBA | C = texUnitCur.rgba dot texUnitPrev.rgba.

enum TextureEnvScale

Texture environment scale.

Enumeration values:
TES_1X | scale factor 1x or no scaling
TES_2X | scale factor 2x
TES_4X | scale factor 4x

enum TexGenMode

Texture coordinate generation mode.

Enumeration values:
TGM_OFF | Off.
TGM_OBJECT_LINEAR | Object linear.
TGM_EYE_LINEAR | Eye linear.
TGM_SPHERE_MAP | Sphere map.
TGM_REFLECTION_MAP | Reflection map.
TGM_NORMAL_MAP | Normal map.

enum TexGenLinearPlane

Texture generation plane.

Enumeration values:
TGLP_OBJECT | Object.
TGLP_EYE | Eye.
TGLP_OBJECT_AND_EYE | Object and eye.

enum TexWrapCoordAxis

Texture wrap coordinate axis.

Enumeration values:
TWCA_S | S axis.
TWCA_T | T axis.
TWCA_R | R axis.

enum TextureWrapMode

Texture wrap mode.

Enumeration values:
TWM_REPEAT | Corresponds to GL_REPEAT in OpenGL.
TWM_CLAMP | Corresponds to GL_CLAMP in OpenGL.
TWM_MIRROR_REPEAT | Corresponds to GL_MIRRORED_REPEAT in OpenGL.
TWM_CLAMP_TO_EDGE | Corresponds to GL_CLAMP_TO_EDGE in OpenGL.
TWM_CLAMP_TO_BORDER | Corresponds to GL_CLAMP_TO_BORDER in OpenGL.
TWM_MIRROR_CLAMP | Corresponds to GL_MIRROR_CLAMP in OpenGL.
TWM_MIRROR_CLAMP_TO_EDGE | Corresponds to GL_MIRROR_CLAMP_TO_EDGE in OpenGL.
TWM_MIRROR_CLAMP_TO_BORDER | Corresponds to GL_MIRROR_CLAMP_TO_BORDER in OpenGL.

enum TextureMinFilterMode

Texture minification mode.

Enumeration values:
TFM_MIN_NEAREST | Corresponds to GL_NEAREST in OpenGL.
TFM_MIN_LINEAR | Corresponds to GL_LINEAR in OpenGL.
TFM_MIN_BILINEAR | Deprecated, name and value provided for backwards compatibility.
TFM_MIN_LINEAR_MIPMAP_LINEAR | Corresponds to GL_LINEAR_MIPMAP_LINEAR.
TFM_MIN_TRILINEAR | Deprecated, name and value provided for backwards compatibility.
TFM_MIN_NEAREST_MIPMAP_NEAREST | Corresponds to GL_NEAREST_MIPMAP_NEAREST.
TFM_MIN_NEAREST_MIPMAP_LINEAR | Corresponds to GL_NEAREST_MIPMAP_LINEAR (the OpenGL default).
TFM_MIN_LINEAR_MIPMAP_NEAREST | Corresponds to GL_LINEAR_MIPMAP_NEAREST.

enum TextureMagFilterMode

Texture magnification mode.

Enumeration values:
TFM_MAG_NEAREST | Corresponds to GL_NEAREST in OpenGL.
TFM_MAG_LINEAR | Corresponds to GL_LINEAR in OpenGL.
TFM_MAG_BILINEAR | Deprecated, name and value provided for backwards compatibility.

enum TextureTarget

Texture target specifier.

Enumeration values:
NVSG_UNSPECIFIED_TEXTURE_TARGET | indicates an unspecified target
NVSG_TEXTURE_1D | indicates a 1-dimensional texture target
NVSG_TEXTURE_2D | indicates a 2-dimensional texture target
NVSG_TEXTURE_3D | indicates a 3-dimensional texture target
NVSG_TEXTURE_CUBE | indicates a cube map target
NVSG_TEXTURE_1D_ARRAY | indicates a 1d texture array
NVSG_TEXTURE_2D_ARRAY | indicates a 2d texture array
NVSG_TEXTURE_RECTANGLE | indicates a non-power-of-two, rectangular texture target
NVSG_TEXTURE_TARGET_COUNT | specifies the count of known texture targets

enum TextureCoordType

Type to specify the type of texture coordinate to generate.

There are three different types of texture coordinate generation available: cylindrical, planar, and spherical.

Enumeration values:
TCT_CYLINDRICAL | Puts a cylinder around the BoundingSphere with the z-axis as it's axis and projects the vertices of the VertexAttributeSet on it to get the texture coordinates.
TCT_PLANAR | Puts a plane in the x-y-plane and vertically projects the vertices of the VertexAttributeSet on that plane to the the texture coordinates.
TCT_SPHERICAL | Projects the vertices of the VertexAttributeSet radially on the BoundingSphere to get the texture coordinates.

Function Documentation

NVSG_API CgFxContext* cgfxContext ( )

Returns the CgFxContext singleton object.

Returns:
The function returns a pointer to the CgFxContext singleton object used in the NVSG core.
Remarks:
NVSG core uses a CgFxContext singleton object that will be shared between all effects in a Scene.

NVSGERRORHANDLER* nvsgSetErrorHandler ( NVSGERRORHANDLER * newErrorHandler )

Replace the current NVSG error handler by newErrorHandler

Parameters

  • newErrorHandler The replacement for the currently used NVSG error handler routine.

Return Value A pointer to the formerly used error handler routine.

bool isEmptyBoundingSphere ( NodeHandle * node ) [inline]

Tests whether the bounding sphere of the specified Node is empty.

Parameters:
node Pointer to a NodeHandle specifying the Node to query.
Returns:
true if the bounding sphere is empty, false otherwise.
Remarks:
The function temporary read-locks the passed Node to query its bounding sphere.

nvmath::Sphere3f getBoundingSphere ( NodeHandle * node ) [inline]

Returns a copy of the specified Node's bounding sphere.

Parameters:
node Pointer to a NodeHandle specifying the Node to get the bounding sphere from.
Returns:
A copy of the node's bounding sphere.
Remarks:
The function temporary read-locks the passed Node to access its bounding sphere.

NVSG_API void nvsgInitialize | ( | NVSGThreadingModelEnum | threadingModel = NVSG_SINGLETHREADED,
 |  | NVSG3DAPIEnum | graphicsAPI = NVSG_3DAPI_GL
 | ) |

Per-application initialization of NVSG global data.

Parameters:
threadingModel Specifies whether to run in a multithreaded environment, or not.
Specify NVSG_SINGLETHREADED to configure NVSG to run in a single-threaded environment.
Specify NVSG_MULTITHREADED to configure NVSG to run in a multi-threaded environment.
The default for this parameter is NVSG_SINGLETHREADED.
graphicsAPI Specifies the 3D graphics API to use for rendering.
Specifying NVSG_3DAPI_GL to use OpenGL as 3D API currently is the only choice. This is subject to change with future releases.
Remarks:
An application must call this routine once before any other NVSG API call. This routine properly initializes all global data required by the NVSG API.

In addition, this routine optionally configures the NVSG library to run safe in a multithreaded environment. This will be achieved by specifying NVSG_MULTITHREADED for the optional threadingModel parameter.

Making the NVSG library multi-threaded safe requires some overhead, which might affect the runtime behavior in a single-threaded environment. That is, it is not recommended to configure NVSG to run in a multi-threaded environment, if your application's threading model really is single-threaded only.

The nvsgInitialize entry point in addition lets you specify which 3D graphics API is used for rendering. Note that using another 3D API for rendering than specified here will result in undefined run-time behaviour.

It is recommended to call this routine inside the application's initial entry point.
Note:
The nvsg runtime behaviour is undefined if an application issues nvsg API calls without a prior call to this routine.

NVSG_API void nvsgTerminate ( )

Per-application termination of nvsg global data.

It is strongly recommended to call this routine when the application terminates. This routine properly frees all global data required by the nvsg API.

Note:
The nvsg runtime behaviour is undefined if an application issues nvsg API calls after having called this routine.

NVSG_API void getVersionString ( std::string & string )

Get the version string of the NVSGSDK.

Parameters:
string string to hold the NVSGSDK version string

NVSG_API void getSDKName ( std::string & string )

Get the NVSGSDK name string.

Parameters:
string string to hold the NVSGSDK name string

NVSG_API void getCopyrightString ( std::string & string )

Get the NVSGSDK copyright string.

Parameters:
string string to hold the NVSGSDK coppyright string

NVSG_API void getVendorName ( std::string & string )

Get the NVSGSDK vendor name.

Parameters:
string string to hold the NVSGSDK vendor name string

NVSG_API unsigned int getSupportedFeatures ( )

Get a bit field of the supported features.

Returns:
An unsigned int encoding the supported features.
Remarks:
Currently, there are two features supported on Quadro boards only: fast texture upload (NVSG_FAST_TEXTURE_UPLOAD) and volume rendering (NVSG_VOLUME_RENDERING).

bool isTypeOf ( ObjectHandle * p ) [inline]

Detects if the object pointed to by p is a pointer to a specified (templated) type.

Returns:
true if p is a pointer to the specified type, false otherwise.

bool areOfSameType | ( | ObjectHandle * | p0,
 |  | ObjectHandle * | p1
 | ) | [inline]

Detects if the two objects p0 and p1 are of the same type.

Returns:
true if p0 and p1 are of the same type, false otherwise.

NVSG_API TextureTarget determineTextureTarget ( TextureImageHandle * img )

Retrieves the best-matching TextureTarget from A TextureImage.

Returns:
The function returns the best-matching TextureTarget for the specified TextureImage, or NVSG_UNSPECIFIED_TEXTURE_TARGET if no matching TextureTarget can be determined.

NVSG_API unsigned char* dbgAllocImagePixels | ( | unsigned int | nbytes,
 |  | unsigned int | line
 | ) |

Same as allocImagePixels + leak detection.

NVSG_API void freeImagePixels ( unsigned char * pixels )

Helper function to free memory of pixel data.

Parameters:
pixels A pointer to the pixel data to free.
Remarks:
This function assumes that pixels has been allocated by allocImagePixels.
See also:
allocImagePixels

NVSG_API unsigned int numberOfComponents ( Image::PixelFormat format )

Helper function to determine the number of components of a PixelFormat.

Parameters:
format The PixelFormat to determine the number of components from.
Returns:
The number of components described by format.
See also:
sizeOfComponents

NVSG_API unsigned int sizeOfComponents ( Image::PixelDataType type )

Helper function to determine the size of components of a PixelDataType.

Parameters:
type The PixelDataType to determine the size of components from.
Returns:
The size of components described by type.
See also:
numberOfComponents

NVSG_API void calculateContributions | ( | std::vector< std::vector< std::pair< unsigned int, float > > > & | contribs,
 |  | unsigned int | srcSize,
 |  | unsigned int | dstSize,
 |  | const ScaleFilter * | filter
 | ) |

Helper function to determine the contributions of a ScaleFilter on scaling an Image.

Parameters:
contribs | A reference to a vector of vector of pairs of an int and a float. The i'th element of contribs holds the vector of contributions for the i'th destination value. The j'th element of contribs[i] holds the index and the contribution of the source values.
srcSize | The number of the source values.
dstSize | The number of the destination values.
filter | A pointer to the ScaleFilter to use for contribution determination.
Remarks:
To determine the contributions of filter on a multidimensional array of values call calculateContributions once per dimension.
Example
  vector<vector<pair<unsigned int,float> > > contributions[3];
  //  contributions[0..2]: contributions in x-, y-, and z-direction
  calculateContributions( contributions[0], srcWidth, dstWidth, sf );
  calculateContributions( contributions[1], srcHeight, dstHeight, sf );
  calculateContributions( contributions[2], srcDepth, dstDepth, sf );
  rescale( src, dst, contributions );
See also:
insert, rescale, TextureImage::filter

NVSG_API void insert | ( | const Image * | src,
 |  | Image * | dst,
 |  | unsigned int | x,
 |  | unsigned int | y,
 |  | unsigned int | z
 | ) |

Helper function to insert a source image into a destination image at a given position.

Parameters:
src | A pointer to the constant source image.
dst | A pointer to the destination image.
x | x-position of the source image in the destination image.
y | y-position of the source image in the destination image.
z | y-position of the source image in the destination image.
Remarks:
It is assumed the the source image offset by x/y/z completely fits into the destination image.
Note:
If the source image has overlaps, the overlap pixels are not copied (and need not fit into the destination image).
See also:
rescale

NVSG_API void rescale | ( | const Image * | src,
 |  | Image * | dst,
 |  | std::vector< std::vector< std::pair< unsigned int, float > > > * | contributions
 | ) |

Helper function to rescale an Image using the contributions of a ScaleFilter.

Parameters:
src | A pointer to the constant source Image to scale.
dst | A pointer to the destination Image.
contributions | A pointer to three vectors of vectors of pairs of an int and a float that holds the contributions of each source pixel to each destination pixel in x, y, and z direction.
Remarks:
The contributions can be calculated by calculateContributions.
Note:
If the destination image is defined to have overlaps, those pixel values are not set.
See also:
calculateContributions

NVSG_API void convertPixelFormat | ( | const Image * | src,
 |  | Image * | dst,
 |  | Image::PixelFormat | destFormat
 | ) |

Helper function to convert the image format from one to another.

Parameters:
src | A pointer to the constant source Image to scale.
dst | A pointer to the destination Image.
destFormat | The destination format.
Remarks:
If destFormat is the same as the source image, src is simply copied to dst. If an image format containing no alpha is converted to a format that contains alpha (for instance, RGB -> BGRA) the alpha channel will be set to 0xff.

NVSG_API void assertMipMapChainComplete ( const TextureImage * img )

Asserts mipmap chain to be complete for the specified TextureImage.

NVSG_API unsigned int sizeOfType ( unsigned int type )

Yields the size in bytes of the respective type.

Parameters:
type Indicates a symbolic constant representing a NVSG type. NVSG_BYTE, NVSG_UNSIGNED_BYTE, NVSG_SHORT, NVSG_UNSIGNED_SHORT, NVSG_INT, NVSG_UNSIGNED_INT, NVSG_FLOAT, and NVSG_DOUBLE are accepted values.
Returns:
The function yields the size in bytes of the type indicated by type.

NVSG_API void normalize ( VertexAttribute & va )

Normalize all vertex data elements of a VertexAttribute.

Parameters:
va The VertexAttribute to normalize.
Remarks:
The function normalize is called for every vertex data element.

bool operator== | ( | const VertexAttribute & | va0,
 |  | const VertexAttribute & | va1
 | ) | [inline]

Equality operator.

Parameters:
va0 | First VertexAttribute to compare.
va1 | Second VertexAttribute to compare.
Returns:
true, if va0 and va1 are equal, otherwise false.
See also:
operator!=

bool operator!= | ( | const VertexAttribute & | va0,
 |  | const VertexAttribute & | va1
 | ) | [inline]

Inequality operator.

Parameters:
va0 | First VertexAttribute to compare.
va1 | Second VertexAttribute to compare.
Returns:
true, if va0 and va1 are not equal, otherwise false.
See also:
operator==

bool genericAttrib ( unsigned int attrib ) [inline]

Determine if an attribute identifier identifies a generic or a conventional attribute.

Parameters:
attrib The attribute identifier to test.
Returns:
true if attrib identifies a generic attribute, otherwise false.
See also:
attribIndex

unsigned int attribIndex ( unsigned int attrib ) [inline]

Translates an attribute identifier to the corresponding conventional attribute identifier.

Parameters:
attrib The attribute identifier to translate.
Returns:
The conventional attribute identifier corresponding to attrib.
Remarks:
If attrib already identifies a conventional attribute, it is returned unchanged. Otherwise it is a generic attribute identifier and the corresponding conventional one is returned.
See also:
genericAttrib

nvmath::Vec3f getSubBrickPosition | ( | const nvmath::Vec3f & | pos,
 |  | const nvmath::Vec3f & | halfSize,
 |  | unsigned int | brickIndex
 | ) | [inline]

Helper function to get the position of a brick inside its surrounding brick.

Parameters:
pos | The position of the surrounding brick.
halfSize | Half the size of the surrounding brick (and the complete size of the sub brick.
brickIndex | Index of the brick to determine the position for.
Returns:
The position of the sub brick determined by brickIndex inside the surrounding brick positioned at pos.
Remarks:
The brickIndex is between 0 and 7, where 0 is the lower left back, and 7 is the upper right front. The three bits used in brickIndex determine the sub brick to be lower or upper (bit 0), right or left (bit 1), and back and front (bit 2).

Variable Documentation

const HDAL HDAL_INVALID

Indicates a invalid handle value.

NVSGERRORHANDLER* nvsgErrorHandler

Global pointer to the currently used NVSG error handler routine. Use the nvsgSetErrorHandler function to assign a new error handler routine .

Generated on Tue Jan 15 10:28:58 2008 for NVSGSDK by NVIDIA


nvtraverser Namespace Reference

Scenegraph traverser classes. More...

Classes

class | AnalyzeResult
Base class of the analyzing results determined with the AnalyzeTraverser. More...

class | CombinableResult
AnalyzeResult indicating that a number of Objects can be combined. More...

class | DenormalizedNormalsResult
AnalyzeResult indicating a VertexAttributeSet with denormalized normals. More...

class | EmptyResult
AnalyzeResult indicating an empty object. More...

class | EquivalenceResult
AnalyzeResult indicating equivalent objects. More...

class | IdentityResult
AnalyzeResult indicating identity transformations. More...

class | MissingResult
AnalyzeResult indicating non-complete objects. More...

class | NullNormalsResult
AnalyzeResult indicating a VertexAttributeSet with null normals. More...

class | RedundantLODRangesResult
AnalyzeResult indicating LODs with redundant ranges. More...

class | SingleChildResult
AnalyzeResult indicating a Group with a single child. More...

class | ShortStrippedResult
AnalyzeResult indicating a StrippedPrimitiveSet with very short strips. More...

class | AnalyzeTraverser
Traverser that analyzes a tree and reports about potential deficiencies. More...

class | AnalyzeTraverser::EquivalenceInfo
class | AppTraverser
AppTraverser Class. More...

class | AppTraverser::SkinningProcessor
class | BalanceTraverser
Balance a flat tree into a somewhat more balanced tree. More...

class | BaseRenderElement
Helper class to serve as a base class for the render list elements, like RenderElement, LightsElement, or ClipPlanesElement. More...

class | ClipPlanesElement
Helper class to hold the clip planes valid for a number of PrimitiveSets. More...

class | CombineTraverser
Traverser that combines a number of Objects, if appropriate. More...

class | CPUSkinningProcessor
CPUSkinningProcessor Class. More...

class | CullTraverser
Base class for culling parts of a scene. More...

class | DefaultCullTraverser
class | DestrippingTraverser
Traverser to destripify stripped primitives. More...

class | EliminateTraverser
Traverser that eliminates a number of Objects, if appropriate. More...

class | FrustumCullTraverser
CullTraverser culling on frustum information. More...

class | GLTraverser
RenderTraverser using OpenGL. More...

class | GLTraverser::StipplePatterns
class | GLUploadTraverser
UploadTraverser using OpenGL. More...

class | GPUSkinningProcessor
GPUSkinningProcessor Class. More...

struct | GPUSkinningProcessor::GPUInfo
class | HighlightElement
Helper class to hold highlight information used in the render lists. More...

class | IdentityToGroupTraverser
Traverser that replaces identity transforms by groups. More...

class | LightsElement
Helper class to hold the vector of lights that are active while traversing the tree. More...

class | SharedModelViewTraverser
Traverser that can handle the model view transform stack. More...

class | ExclusiveModelViewTraverser
Traverser that can handle the model view transform stack. More...

class | NodeHintsCullTraverser
CullTraverser that culls based on NodeHints information. More...

class | NormalizeTraverser
Traverser that normalizes all normals. More...

class | OptimizeTraverser
Base for Traversers that perform some optimizations on a scene. More...

class | Intersection
Intersection class. More...

class | RayIntersectTraverser
RayIntersectTraverser. More...

class | RenderElement
Helper class to hold all the state informations valid for a number of PrimitiveSets. More...

class | RenderElementCompareBackToFront
Comparison functor to sort RenderElements from back to front. More...

class | RenderElementCompareFrontToBack
Comparison functor to sort RenderElements from front to back. More...

class | RenderElementCompareStateAttributes
Comparison functor to sort RenderElements by material. More...

class | RenderElementPool
struct | RenderElementPool::Block
class | RenderTraverser
Pure virtual render traverser class. More...

class | SearchTraverser
Traverser for searching all objects of one class type. More...

class | SmoothTraverser
Traverser that can smooth some drawables. More...

class | StrippingTraverser
Traverser to convert Triangles to TriStrips, and Quads to QuadStrips. More...

class | TransformElement
Helper class to hold transformation information used in the render lists. More...

class | Traverser
Virtual base class providing the common interface part of ExclusiveTraverser and SharedTraverser. More...

class | SharedTraverser
Base class providing an interface for read-only traversing of a given scene graph. More...

class | ExclusiveTraverser
Base class providing an interface for read-write traversing of a given scene graph. More...

class | TriangulateTraverser
Traverser that converts all flavors of quads to triangles. More...

class | UnifyTraverser
OptimizeTraverser that can unify identical objects in a scene. More...

class | VertexUnifyTraverser
Traverser that can unifies vertices. More...

Enumerations

enum | { RT_GL = 0x00010000 }

Functions

ClipPlanesElement * | createClipPlanesElement (RenderElementPool *pool)
Helper function to create an empty ClipPlanesElement using a given RenderElementPool.

ClipPlanesElement * | createClipPlanesElement (RenderElementPool *pool, nvsg::GroupHandle *group, const nvmath::Mat44f &modelToWorld, const ClipPlanesElement &rhs)
Helper function to create a ClipPlanesElement using a given RenderElementPool.

HighlightElement * | createHighlightElement (RenderElementPool *pool, ClipPlanesElement *cpe, TransformElement *te)
Helper function to create a HighlightElement using a given RenderElementPool.

LightsElement * | createLightsElement (RenderElementPool *pool)
Helper function to create a default LightsElement using a given RenderElementPool.

LightsElement * | createLightsElement (RenderElementPool *pool, nvsg::GroupHandle *group, const LightsElement &rhs)
Helper function to create a LightsElement using a given RenderElementPool.

RenderElement * | createRenderElement (RenderElementPool *pool, nvsg::StateVariantHandle *svh, ClipPlanesElement *cpe, LightsElement *le, TransformElement *te, bool culling)
Helper function to create a RenderElement using a given RenderElementPool.

template<typename REType> REType * | constructRenderElement (RenderElementPool *pool)
template<typename REType, typename Arg> REType * | constructRenderElement (RenderElementPool *pool, Arg arg)
template<typename REType, typename Arg0, typename Arg1> REType * | constructRenderElement (RenderElementPool *pool, Arg0 arg0, Arg1 arg1)
template<typename REType, typename Arg0, typename Arg1, typename Arg2> REType * | constructRenderElement (RenderElementPool *pool, Arg0 arg0, Arg1 arg1, Arg2 arg2)
template<typename REType, typename Arg0, typename Arg1, typename Arg2, typename Arg3> REType * | constructRenderElement (RenderElementPool *pool, Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3)
template<typename REType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4> REType * | constructRenderElement (RenderElementPool *pool, Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
template<typename REType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> REType * | constructRenderElement (RenderElementPool *pool, Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
template<typename REType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6> REType * | constructRenderElement (RenderElementPool *pool, Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6)
TransformElement * | createTransformElement (RenderElementPool *pool)
Helper function to create a default TransformElement using a given RenderElementPool.

TransformElement * | createTransformElement (RenderElementPool *pool, const nvmath::Mat44f &mtw, const nvmath::Mat44f &wtm, TransformElement *parent, nvsg::GroupHandle *transform, bool lengthPreserving, bool mirror, bool fixed)
Helper function to create a TransformElement using a given RenderElementPool.

Detailed Description

Scenegraph traverser classes.

This namespace is the collection of the scenegraph traverser classes. Currently we have two base kinds of traversers: const and non const traversers. Const traverser are not allowed to change anything in the tree, where non const traverser are allowed to change/manipulate the tree.

Function Documentation

ClipPlanesElement* createClipPlanesElement ( RenderElementPool * pool ) [inline]

Helper function to create an empty ClipPlanesElement using a given RenderElementPool.

Parameters:
pool The memory pool to create the the RenderElement in.
Returns:
A pointer to the newly created ClipPlanesElement.
See also:
constructRenderElement, RenderElementPool

ClipPlanesElement* createClipPlanesElement | ( | RenderElementPool * | pool,
 |  | nvsg::GroupHandle * | group,
 |  | const nvmath::Mat44f & | modelToWorld,
 |  | const ClipPlanesElement & | rhs
 | ) | [inline]

Helper function to create a ClipPlanesElement using a given RenderElementPool.

Parameters:
pool | The memory pool to create the the RenderElement in.
group | A pointer to the Group that adds at least one clip plane.
modelToWorld | A reference to the corresponding constant model to world transformation matrix.
rhs | A reference to the constant ClipPlanesElement to get the first clip planes from.
Returns:
A pointer to the newly created ClipPlanesElement.
See also:
constructRenderElement, RenderElementPool

HighlightElement* createHighlightElement | ( | RenderElementPool * | pool,
 |  | ClipPlanesElement * | cpe,
 |  | TransformElement * | te
 | ) | [inline]

Helper function to create a HighlightElement using a given RenderElementPool.

Parameters:
pool | The memory pool to create the the HighlightElement in.
cpe | A pointer to the ClipPlanesElement to use.
te | A pointer to the TransformElement to use.
Returns:
A pointer to the newly created HighlightElement.
See also:
constructRenderElement

LightsElement* createLightsElement ( RenderElementPool * pool ) [inline]

Helper function to create a default LightsElement using a given RenderElementPool.

Parameters:
pool The memory pool to create the the LightsElement in.
Returns:
A pointer to the newly created LightsElement.
See also:
LightsElement, constructRenderElement, RenderElementPool

LightsElement* createLightsElement | ( | RenderElementPool * | pool,
 |  | nvsg::GroupHandle * | group,
 |  | const LightsElement & | rhs
 | ) | [inline]

Helper function to create a LightsElement using a given RenderElementPool.

Parameters:
pool | The memory pool to create the the LightsElement in.
group | The handle of the Group that is going to add one or more light sources.
rhs | A reference to the constant current LightsElement valid up to now.
Returns:
A pointer to the newly created LightsElement.
See also:
LightsElement, constructRenderElement, RenderElementPool

RenderElement* createRenderElement | ( | RenderElementPool * | pool,
 |  | nvsg::StateVariantHandle * | svh,
 |  | ClipPlanesElement * | cpe,
 |  | LightsElement * | le,
 |  | TransformElement * | te,
 |  | bool | culling
 | ) | [inline]

Helper function to create a RenderElement using a given RenderElementPool.

Parameters:
pool | The memory pool to create the the RenderElement in.
svh | A pointer to the current StateVariant to be used. May by NULL.
cpe | A pointer to the current ClipPlanesElement to be used.
le | A pointer to the current LightsElement to be used.
te | A pointer to the current TransformElement to be used.
culling | Flag which indicates if the render element should be considered during culling.
Returns:
A pointer to the newly created LightsElement.
See also:
constructRenderElement, RenderElementPool

TransformElement* createTransformElement ( RenderElementPool * pool ) [inline]

Helper function to create a default TransformElement using a given RenderElementPool.

Parameters:
pool The memory pool to create the the TransformElement in.
Returns:
A pointer to the newly created TransformElement.
See also:
constructRenderElement

TransformElement* createTransformElement | ( | RenderElementPool * | pool,
 |  | const nvmath::Mat44f & | mtw,
 |  | const nvmath::Mat44f & | wtm,
 |  | TransformElement * | parent,
 |  | nvsg::GroupHandle * | transform,
 |  | bool | lengthPreserving,
 |  | bool | mirror,
 |  | bool | fixed
 | ) | [inline]

Helper function to create a TransformElement using a given RenderElementPool.

Parameters:
pool | The memory pool to create the the TransformElement in.
mtw | A reference to the constant model to world matrix.
wtm | A reference to the constant world to model matrix.
parent | A pointer to the TransformElement that represents the parent of this transformation, in the scene graph.
transform | A pointer to the GroupHandle, giving the transformation.
lengthPreserving | A flag, that specifies, if true, that this transformation preserves the length of vectors, such that they need not be renormalized before usage.
mirror | A flag, that specifies, if true, that this transformation mirrors vectors.
fixed | A flag, that specifies, if true, that this transformation is not to be expected to vary from frame to frame, and thus can be cached.
Returns:
A pointer to the newly created TransformElement.
See also:
constructRenderElement

Generated on Tue Jan 15 10:29:25 2008 for NVSGSDK by NVIDIA


nvui Namespace Reference

Namespace for user interface and interaction classes. More...

Classes

class | AnimationManipulator
This Manipulator controls the camera animation. More...

class | FlightCameraManipulator
Simulate flight like camera-mouse interaction. More...

class | GLWinRenderArea
RenderArea class for MS Windows OpenGL. More...

class | KeyInput
Keyboard input helper class to store keyboard press and release events. More...

class | Manipulator
Base class for all kinds of manipulators. More...

class | MouseInput
Mouse input helper class to store mouse events. More...

class | RenderArea
The RenderArea is the place where the actual drawing takes place. More...

class | TrackballCameraManipulator
Simulate a trackball-like camera mouse interaction. More...

class | TrackballTransformManipulator
Simulate a trackball like object mouse interaction. More...

class | TransformManipulator
Base class for all kinds of transform manipulators. More...

class | WalkCameraManipulator
Simulate a walk-through camera-mouse interaction. More...

class | GLMFCRAWnd
OpenGL render area window. More...

Functions

NVSG_API int | determinePixelFormat (UINT features, UINT cMultiSampleBuffers, nvutil::ProblemLog &problemLog)
Determines a pixel format according to requested features.

NVSG_API void | testPixelFormat (HDC hdc, int pixelFormat, UINT &features, nvutil::ProblemLog &problemLog)
Tests if a given pixel format matches the specified features.

Detailed Description

Namespace for user interface and interaction classes.

Remarks:
This namespace contains mainly user interface classes such as camera manipulators, render areas, render windows, etc.. Add all the interfaces and classes that interact more or less directly with the user into this namespace.

Function Documentation

NVSG_API int determinePixelFormat | ( | UINT | features,
 |  | UINT | cMultiSampleBuffers,
 |  | nvutil::ProblemLog & | problemLog
 | ) |

Determines a pixel format according to requested features.

Parameters:
features | A bit field specifying requested features. RenderArea::NVSG_STEREO, RenderArea::NVSG_MULTISAMPLE, or a combination of these bits are accepted.
cMultiSampleBuffers | Specifies the requested number of multi-sample buffers. Ignored if the RenderArea::NVSG_MULTISAMPLE feature is not requested.
problemLog | Log object where possible problems will be logged.
Returns:
The function returns a one-based pixel format index if succeeded. It returns 0 if no hardware-accelerated pixel format could be determined, -1 if RenderArea::NVSG_STEREO was requested, but stereoscopic rendering is not possible on current configuration, and -2 if RenderArea::NVSG_MULTISAMPLE was requested, but multi-sampled rendering is not possible on current configuration.
Remarks:
The function determines the OpenGL pixel format index with respect to the requested features, like stereo, and multi-sample. If only a generic pixel format could be determined on the current configuration, no hardware acceleration is possible, and the function returns 0, indicating an invalid pixel format index.
The function returns a negative index if one of the requested features are not available on the current configuration: -1 is returned if a stereo format was requested, but not available, -2 is returned if a multi-sample format was requeted, but not available. If a negative return value is encountered, the user can clear the corresponding feature bit from the input features bit field and reiterate the function call to receive a more restrictive pixel format:
     nvutil::ProblemLog problemLog;

     // try to get a 4x-sampled stereo format
     UINT features = RenderArea::NVSG_STEREO | RenderArea::NVSG_MULTISAMPLE;
     UINT cBuffers = 4;

     int pixelfmt = determinePixelFormat(features, cBuffers, problemLog);
     while (pixelfmt < 0)
     {
         // It appears that one of the requested features is not
         // available. Determine which, clear the corresponding
         // feature bit, and try again.
         switch( pixelfmt )
         {
         case -1: features &= ~RenderArea::NVSG_STEREO;      break;
         case -2: features &= ~RenderArea::NVSG_MULTISAMPLE; break;
         default : features = 0; break;
         }
         pixelfmt = determinePixelFormat(features, cBuffers);
     }

     if ( !pixelfmt )
     {
         // no hardware acceleration at all
         [...]
     }
     [...]
If the WGL_ARB_pixelformat extension is not available on the current configuration, the function is unable to determine the desired pixel format, and 0 is returned to indicate an invalid pixel format.

Problems that occur during determination of the pixel format will be logged to the nvuitl::ProblemLog object, passed as last argument.

See also:
nvutil::ProblemLog

NVSG_API void testPixelFormat | ( | HDC | hdc,
 |  | int | pixelFormat,
 |  | UINT & | features,
 |  | nvutil::ProblemLog & | problemLog
 | ) |

Tests if a given pixel format matches the specified features.

Parameters:
hdc | Device context for which the function tests the pixel format.
pixelFormat | One-base pixel format index indicating the pixel format to test.
features | Requested features. RenderArea::NVSG_STEREO, RenderArea::NVSG_MULTISAMPLE, or a combination of these bits are accepted.
problemLog | Log object where detected problems will be logged.
Remarks:
The function tests whether the indicated pixel format matches the features requested by a particular OpenGL RenderArea. In case a mismatch is found, the problem will be logged to the ProblemLog object passed as last argument.
In particular, a problem will be reported if the indicated pixel format specifies a generic, that is - non hardware-accelerated format. In addition a problem will be reported if a requested RenderArea feature does not match the indicated pixel format. For example, if RenderArea::NVSG_STEREO was requested but the indicated pixel format does not offer stereo support.
See also:
nvutil::ProblemLog

Generated on Tue Jan 15 10:29:40 2008 for NVSGSDK by NVIDIA


nvutil Namespace Reference

nvutil namespace More...

Classes

class | Chunk
Chunk of memory for our low level memory managment of fixed size objects. More...

class | FixedAllocator
Manages allocation requests for objects of a certain size only. More...

class | Allocator
Internal manager for memory allocations. More...

struct | Allocator::DbgAllocInfo
struct | Allocator::LeakWarning
class | IAllocator
An allocator interface. More...

class | Bit
Template class for easy definition of a single-bit bitmask. More...

class | Conversion
class | Conversion::Big
class | Conversion< T, T >
class | FileMapping
Helper class to ease efficient reading and writing of large files. More...

struct | FileMapping::ViewHeader
class | ReadMapping
Helper class to ease efficient reading of large files. More...

class | WriteMapping
Helper class to ease efficient writing of large files. More...

class | EmptyType
class | HandledObject
struct | Holder
class | Handle< T, NullType >
Specialized stand-alone Handle. More...

class | Handle< T, Handle< U, V > >
Specialization template for Handle-derived Handle types. More...

class | WritableObject
class | ReadableObject
struct | CloneObject
class | Incarnation
This class abstracts an incarnation count. More...

class | Log
Logging test results. More...

class | MemFunTbl
Member Function Table template. More...

class | UPITID
Unique Plug Interface Type ID. More...

class | UPIID
Unique Plug Interface ID. More...

class | PlugIn
Plug-in base class. More...

class | PlugInServer
Plug-in management. More...

class | PlugInServer::PlugInHolder
class | PlugInCallback
PlugInCallback base class. More...

struct | PlugInCallback::EmptyTokenInfo
Information structure used for warning PICW_EMPTY_TOKEN. More...

struct | PlugInCallback::IncompatibleValueInfo
Information structure used for warning PICW_INCOMPATIBLE_VALUES. More...

struct | PlugInCallback::InvalidValueInfo
Information structure used for warning PICW_INVALID_VALUE. More...

struct | PlugInCallback::UndefinedTokenInfo
Information structure used for warning PICW_UNDEFINED_TOKEN. More...

struct | PlugInCallback::UnexpectedTokenInfo
Information structure used for error PICE_UNEXPECTED_TOKEN. More...

struct | PlugInCallback::UnknownTokenInfo
Information structure used for error PICE_UNKNOWN_TOKEN. More...

struct | PlugInCallback::UnsupportedTokenInfo
Information structure used for warning PICW_UNSUPPORTED_TOKEN. More...

struct | PlugInCallback::DegenerateGeometryInfo
Information structure used for warning PICW_DEGENERATE_GEOMETRY. More...

struct | PlugInCallback::FileAccessFailedInfo
Information structure used for error PICE_FILE_ACCESS_ERROR. More...

struct | PlugInCallback::FileMappingFailedInfo
Information structure used for error PICE_FILE_MAPPING_ERROR. More...

struct | PlugInCallback::IncompatibleFileInfo
Information structure used for error PICE_INCOMPATIBLE_FILE. More...

struct | PlugInCallback::InvalidFileInfo
Information structure used for error PICE_INVALID_FILE. More...

class | ProblemInfo
Class that holds the problem information. More...

class | LogListCompare
class | ProblemLog
class | RCObject
Provides an interface for reference counted objects. More...

class | RCVector
A reference counted vector. More...

class | RCPtr
A smart pointer template to manage reference counted objects. More...

class | RCIPtr
A smart pointer template for reference counted objects. More...

struct | RCIPtr::CountHolder
class | RCObject_AutoPtr
AutoPtr for reference counted objects. More...

struct | addReference
Convenient helper functor that can be used in STL algorithms to add a reference to reference counted objects. More...

struct | removeReference
Convenient helper functor that can be used in STL algorithms. More...

class | RegVal
Template class for easy access to the Registry. More...

class | Singleton
A Singleton framework. More...

class | SWMRSync
Single write, multiple read synchronization class. More...

class | AutoLock
class | StrTokenizer
Separate a string into tokens. More...

struct | traceDebugOutput
output to attached debugger More...

struct | traceConsoleOutput
output to console More...

struct | traceConsoleDebugOutput
output to console _AND_ attached debugger More...

struct | traceFileOutput
output to file More...

struct | traceFileDebugOutput
output to log file _AND_ attached debugger More...

struct | traceFileConsoleOutput
output to log file _AND_ console More...

class | Trace
Trace class template. More...

struct | TraceFunctor
uses the function given as template argument to print out a given string More...

class | Trackball
Trackball class for simulating a virtual trackball. More...

class | TransformStack
Utility class to hold a stack of concatenated transformation matrices. More...

class | Validated
The Validated class adds a validation state to some data. More...

class | Handle
Controls access to the the handled object. More...

Typedefs

typedef unsigned long | bitset32
typedef unsigned long long | bitset64
typedef void | LOG_OUTPUT_FUNCTION (const char *)
Type of output function to use with Log class objects.

typedef Singleton< Log< TM_TEST,
logFileOutput > > 		LogTest
Dedicated type for general test logging.

typedef bool(* | PFNGETPLUGINTERFACE )(const UPIID &piid, PlugIn *&plugIn)
Function pointer type for getPlugInterface export function required by a plug-in.

typedef bool(* | PFNQUERYPLUGINTERFACETYPE )(const UPITID &pitid, std::vector< UPIID > &piids)
Function pointer type for queryPlugInterfaceType export function required by a plug-in.

typedef Singleton< PlugInServer > | PIS
Type define for the application unique PlugInServer.

typedef std::list< ProblemInfo > | ProblemLogList
This class logs problems.

typedef void | DestroyCallback (const RCObject *rcObject, void *data)
Type definition for the callback on destruction.

typedef std::basic_string<
TCHAR > 		tstring
typedef CRITICAL_SECTION | SWMRCriticalSection

Enumerations

enum | TESTMODE { TM_NONE = 0, TM_TEST }
Test modes available for logging. More...

Functions

NVSG_API void | AssertionFailed (const char *assertion, const char *file, unsigned int line, const char *function)
unsigned int | bit (unsigned int index, size_t value)
template<typename T> T * | getHandle (const HandledObject *obj)
bool | operator< (const UPITID &lhs, const UPITID &rhs)
bool | operator== (const UPITID &lhs, const UPITID &rhs)
bool | operator!= (const UPITID &lhs, const UPITID &rhs)
bool | operator< (const UPIID &lhs, const UPIID &rhs)
bool | operator== (const UPIID &lhs, const UPIID &rhs)
bool | operator!= (const UPIID &lhs, const UPIID &rhs)
void | reportError (ProblemLog &log, const char *problem, const char *missingFeature)
void | reportWarning (ProblemLog &log, const char *problem, const char *missingFeature)
template<typename T> void | writeAccess (RCPtr< T > &rcPtr)
template<typename T> void | writeAccess (RCIPtr< T > &rcPtr)
NVSG_API void | EnableLocking ()
Enable locking of the SWMRSync class.

NVSG_API bool | FindFile (const std::string &mask, const std::vector< std::string > &searchPaths, std::vector< std::string > &results, bool recursive=false)
Find files matching a pattern.

NVSG_API bool | FindFileFirst (const std::string &mask, const std::vector< std::string > &searchPaths, std::string &nameOut, bool recursive=false)
Check for the first occurence of a file.

NVSG_API bool | FileExists (const std::string &filepath)
Check if a given file exists.

NVSG_API bool | FileSize (const std::string &filepath, long &size)
Return filesize in bytes of an existing file. Supports filesizes up to 2GB only.

NVSG_API void | GetFileNameFromPath (const std::string &path, std::string &fname)
Extract filename.

NVSG_API void | GetFileExtFromPath (const std::string &path, std::string &fext)
Extract file extension.

NVSG_API void | GetDirFromPath (const std::string &path, std::string &dir)
Extract directory path.

NVSG_API void | GetDrvFromPath (const std::string &path, std::string &drv)
Extract drive letter.

NVSG_API void | GetDrvAndDirFromPath (const std::string &path, std::string &dir)
Extract full path.

NVSG_API void | SplitPath (const std::string &path, std::string &drv, std::string &dir, std::string &fname, std::string &fext)
NVSG_API void | GetModulePath (const std::string &module, std::string &path)
Determine the module path **Windows only**.

NVSG_API void | GetModulePath (const HMODULE hModule, std::string &path)
Determine the module path **Windows only**.

NVSG_API void | GetModulePath (std::string &path)
Holds the full executable path.

NVSG_API bool | GetCurrentDir (std::string &path)
Get the current directory for the current process.

NVSG_API std::string | SetCurrentDir (const std::string &dir)
Set the current directory for the current process.

Variables

NVSG_API LOG_OUTPUT_FUNCTION | logFileOutput
Function to log into a file.

Detailed Description

nvutil namespace

Typedef Documentation

typedef bool(* PFNGETPLUGINTERFACE)(const UPIID& piid, PlugIn *& plugIn)

Function pointer type for getPlugInterface export function required by a plug-in.

typedef bool(* PFNQUERYPLUGINTERFACETYPE)(const UPITID& pitid, std::vector<UPIID>& piids)

Function pointer type for queryPlugInterfaceType export function required by a plug-in.

typedef Singleton<PlugInServer> PIS

Type define for the application unique PlugInServer.

typedef std::list<ProblemInfo> ProblemLogList

This class logs problems.

typedef void DestroyCallback( const RCObject * rcObject, void * data )

Type definition for the callback on destruction.

Namespace: nvsg
Remarks:
An RCObject can have callbacks to be called, just before it is destroyed. This is the definition of the interface of these callbacks. The complete rcObject can be read at that moment, but not written.
Note:
The behavior is undefined, if rcObject is written to.
See also:
RCObject::addOnDestroyCallback, RCObject::removeOnDestroyCallback

Function Documentation

bool operator< | ( | const UPITID & | lhs,
 |  | const UPITID & | rhs
 | ) | [inline]

Compares two UPITID objects. This operator is required e.g. if it is intended to store UPITID objects in ordered containers.

Returns:
true if lhs is less than rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator== | ( | const UPITID & | lhs,
 |  | const UPITID & | rhs
 | ) | [inline]

Tests two UPITID objects on equality.

Returns:
true if lhs is equal to rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator!= | ( | const UPITID & | lhs,
 |  | const UPITID & | rhs
 | ) | [inline]

Tests two UPITID objects on inequality.

Returns:
true if lhs is unequal to rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator< | ( | const UPIID & | lhs,
 |  | const UPIID & | rhs
 | ) | [inline]

Compares two UPIID objects. This operator is required e.g. if it is intended to store UPIID objects in ordered containers.

Returns:
true if lhs is less than rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator== | ( | const UPIID & | lhs,
 |  | const UPIID & | rhs
 | ) | [inline]

Tests two UPIID objects on equality.

Returns:
true if lhs is equal to rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

bool operator!= | ( | const UPIID & | lhs,
 |  | const UPIID & | rhs
 | ) | [inline]

Tests two UPIID objects on inequality.

Returns:
true if lhs is unequal to rhs, false otherwise.
Parameters:
lhs | Left operand
rhs | Right operand

NVSG_API void EnableLocking ( )

Enable locking of the SWMRSync class.

Remarks:
This function is called from within nvsgInitialize if the argument threadingModel is NVSG_MULTITHREADED.

NVSG_API bool FindFile | ( | const std::string & | mask,
 |  | const std::vector< std::string > & | searchPaths,
 |  | std::vector< std::string > & | results,
 |  | bool | recursive = false
 | ) |

Find files matching a pattern.

Tries to find files matching mask and output results (full path) to results

The function tries to lookup the file as follows:
  1. If mask contains a drive or path, that path will be looked for first
  2. If it does not contain a path and searchPaths is empty we look inside current dir for a match
  3. Look inside the search paths stored in searchPaths
  4. Dive into all the subdirs if recursive is set true
Note: Use FindFileFirst, if you are only interested in the first occurence of a file.

Returns:
true if successfull, false otherwise.
Parameters:
mask | the path/file mask to match
searchPaths | the dirs to addtionally search
results | store results in here
recursive | search all subdirs also

NVSG_API bool FindFileFirst | ( | const std::string & | mask,
 |  | const std::vector< std::string > & | searchPaths,
 |  | std::string & | nameOut,
 |  | bool | recursive = false
 | ) |

Check for the first occurence of a file.

Works as FindFile, but return the first match only to nameOut

Parameters:
mask | Name of the file to search for.
searchPaths | Collection of search pathes to lookup the file.
nameOut | Holds the full path and filename, if successfull.
recursive | search all subdirs also

NVSG_API bool FileExists ( const std::string & filepath )

Check if a given file exists.

NVSG_API bool FileSize | ( | const std::string & | filepath,
 |  | long & | size
 | ) |

Return filesize in bytes of an existing file. Supports filesizes up to 2GB only.

NVSG_API void GetFileNameFromPath | ( | const std::string & | path,
 |  | std::string & | fname
 | ) |

Extract filename.

Extracts the filename with extension from path and returns it in fname.

Parameters:
path | Input path and filename.
fname | Extracted filename with extension.

NVSG_API void GetFileExtFromPath | ( | const std::string & | path,
 |  | std::string & | fext
 | ) |

Extract file extension.

Extracts the file extension, including leading period from path and returns it in fext.

Parameters:
path | Input path and filename.
fext | Extracted file extension, including leading period.

NVSG_API void GetDirFromPath | ( | const std::string & | path,
 |  | std::string & | dir
 | ) |

Extract directory path.

Extracts the directory path, including trailing slash from path and returns it in dir.

Parameters:
path | Input path and filename.
dir | Extracted directory path, including trailing slash.

NVSG_API void GetDrvFromPath | ( | const std::string & | path,
 |  | std::string & | drv
 | ) |

Extract drive letter.

Extracts the optional drive letter, followed by a colon from path and returns it in drv.

Parameters:
path | Input path and filename.
drv | Extracted drive letter, followed by a colon.

NVSG_API void GetDrvAndDirFromPath | ( | const std::string & | path,
 |  | std::string & | dir
 | ) |

Extract full path.

Extracts the drive and directory from path and returns it in dir.

Parameters:
path | Input path and filename.
dir | Extracted path, including trailing slash.

NVSG_API void GetModulePath | ( | const std::string & | module,
 |  | std::string & | path
 | ) |

Determine the module path **Windows only**.

Determines the full path to the module, given the module's name in module and returns it in path.

Parameters:
module | Module name.
path | Holds the full path to the module if the module was found.

NVSG_API void GetModulePath | ( | const HMODULE | hModule,
 |  | std::string & | path
 | ) |

Determine the module path **Windows only**.

Determines the full path of the module, given the module handle in hModule and returns it in path.

Parameters:
hModule | Module handle.
path | Holds the full path to the module.

NVSG_API void GetModulePath ( std::string & path )

Holds the full executable path.

Determines the full path to the current executable and returns it in path.

NVSG_API bool GetCurrentDir ( std::string & path )

Get the current directory for the current process.

path will hold the current directory if the function succeeds

Returns:
true if successful, false otherwise.
Parameters:
path Holds the current directory if the function succeeds.

NVSG_API std::string SetCurrentDir ( const std::string & dir )

Set the current directory for the current process.

Sets the current directory for the current process to path and returns the former current directory.

Returns:
A string holding the former current directory.
Parameters:
dir Path to be set as current directory.

Generated on Tue Jan 15 10:29:45 2008 for NVSGSDK by NVIDIA


nvutil::IO Namespace Reference

IO namespace. More...

Functions

NVSG_API void errorMessage (const std::string &caption, const std::string &msg, bool resume)
Pop up an error message.

Detailed Description

IO namespace.

The IO namespace has been introduced as an additional layer to maintain platform independency for input/output related functionality.

Function Documentation

NVSG_API void errorMessage | ( | const std::string & | caption,
 |  | const std::string & | msg,
 |  | bool | resume
 | ) |

Pop up an error message.

This function pops up a dialog showing the error message msg. The dialog box will show \ a caption as caption. The boolean parameter resume forces a visual feedback for whether subsequent code will be resumed or not.

Note:
This function is only implemented for win32 and win64 systems by now.
Parameters:
caption | The dialog's caption string
msg | The error message string.
resume | true if subsequent code will be resumed, false otherwise.

Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Module Index

NVSGSDK Modules

Here is a list of all modules:
  • Logging a certain test results
    • Macros providing initialization of certain test modes for logging
    • Macros providing formatted output relevant for a certain test modes
    • Macros to inquire if logging is enabled for a certain test mode
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Logging a certain test results

Modules

group | Macros providing initialization of certain test modes for logging
group | Macros providing formatted output relevant for a certain test modes
group | Macros to inquire if logging is enabled for a certain test mode

Classes

class | Log
Logging test results. More...

Typedefs

typedef void | nvutil::LOG_OUTPUT_FUNCTION (const char *)
Type of output function to use with Log class objects.

typedef Singleton< Log< TM_TEST,
logFileOutput > > 		nvutil::LogTest
Dedicated type for general test logging.

Enumerations

enum | nvutil::TESTMODE { nvutil::TM_NONE = 0, nvutil::TM_TEST }
Test modes available for logging. More...

Functions

void | nvutil::Log::init (bool enable)
Initialization.

void | nvutil::Log::format (const char *fmt,...) const
Formatted output.

bool | nvutil::Log::isEnabled () const
Determine whether a certain test mode is enabled.

Variables

NVSG_API LOG_OUTPUT_FUNCTION | nvutil::logFileOutput
Function to log into a file.

Typedef Documentation

typedef void LOG_OUTPUT_FUNCTION(const char *)

Type of output function to use with Log class objects.

typedef Singleton< Log<TM_TEST, logFileOutput> > LogTest

Dedicated type for general test logging.

Enumeration Type Documentation

enum TESTMODE

Test modes available for logging.

Enumeration values:
TM_NONE | None of the following modes enabled.
TM_TEST | Any test mode.

Function Documentation

void init ( bool enable ) [inline, inherited]

Initialization.

Based on enable, decides wether to output or not.

Parameters:
enable Enable logging if true.

void format | ( | const char * | fmt,
 |  | ... |
 | ) | const [inline, inherited]

Formatted output.

Outputs the format string fmt using OutputFn.

Parameters:
fmt Format string.

bool isEnabled ( ) const [inline, inherited]

Determine whether a certain test mode is enabled.

Returns:
true if output is enabled, fasle otherwise.

Variable Documentation

NVSG_API LOG_OUTPUT_FUNCTION logFileOutput

Function to log into a file.

Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


Macros providing initialization of certain test modes for logging

Macros providing initialization of certain test modes for logging
[Logging a certain test results]

Defines

#define NVSG_LOG_TEST_INIT(TM) nvutil::LogTest::instance()->init(TM!=nvutil::TM_NONE)
Initialize general test logging.

Detailed Description

By default, logging is disabled for all test modes. This macros can be used to initialize logging for a certain test mode:
 NVSG_LOG_TEST_INIT(testmode)  // enable test looging if testmode!=TM_NONE

Define Documentation

#define NVSG_LOG_TEST_INIT ( TM ) nvutil::LogTest::instance()->init(TM!=nvutil::TM_NONE)

Initialize general test logging.

Enables general test logging if TM equals any test mode but TM_NONE.

Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


Macros providing formatted output relevant for a certain test modes

Macros providing formatted output relevant for a certain test modes
[Logging a certain test results]

Defines

#define NVSG_LOG_TEST(s) { if ( nvutil::LogTest::instance()->isEnabled() ) { nvutil::LogTest::instance()->format s; } }
Output test relevant format string s if output is enabled.

Detailed Description

These macros will only output if a specified test mode was enabled before, using the matching NVSG_LOG_TEST_INIT macro.
Note:
As macros cannot handle optional arguments as used with format strings, clients must use extra brackets for the argument:
 NVSG_LOG_TEST(( "Error: %X\n", getErrCode() ));

Define Documentation

#define NVSG_LOG_TEST ( s ) { if ( nvutil::LogTest::instance()->isEnabled() ) { nvutil::LogTest::instance()->format s; } }

Output test relevant format string s if output is enabled.

Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


Macros to inquire if logging is enabled for a certain test mode

Macros to inquire if logging is enabled for a certain test mode
[Logging a certain test results]

Defines

#define NVSG_LOG_TEST_ENABLED() nvutil::LogTest::instance()->isEnabled()
Query if any test is enabled.

Detailed Description

This macros all can be used in conditional statements:
 if ( NVSG_LOG_TEST_ENABLED() )
 {
    // ...
 }

Define Documentation

#define NVSG_LOG_TEST_ENABLED ( ) nvutil::LogTest::instance()->isEnabled()

Query if any test is enabled.

Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines
b | c | d | f | g | i | m | n | o | p | q | r | s | t | u

Here is a list of all documented file members with links to the documentation:

- b -

  • BUFFER_OFFSET : GLContext.h
  • byte_t : NBF.h, PLYLoader.h

- c -

  • CreateHandle : Handle.h
  • CreateHandleFromBase : Handle.h

- d -

  • DEVICE_CONTEXT : GLContext.h

- f -

  • float2_t : NBF.h
  • float3_t : NBF.h
  • float44_t : NBF.h
  • float4_t : NBF.h

- g -

  • GET_CURRENT_DC : GLContext.h
  • GET_CURRENT_RC : GLContext.h
  • getPlugInterface() : OBJSaver.h, NVSGSaver.h, WRLLoader.h, PLYLoader.h, NVSGLoader.h, NVBLoader.h

- i -

  • int_t : NBF.h, PLYLoader.h

- m -

  • MAKE_CURRENT : GLContext.h

- n -

  • NBF_ALPHA_TEST_ATTRIBUTE : NBF.h
  • NBF_ANIMATED_QUADS : NBF.h
  • NBF_ANIMATED_TRANSFORM : NBF.h
  • NBF_ANIMATED_TRIANGLES : NBF.h
  • NBF_ANIMATED_VERTEX_ATTRIBUTE_SET : NBF.h
  • NBF_BIG_ENDIAN : NBF.h
  • NBF_BILLBOARD : NBF.h
  • NBF_BLEND_ATTRIBUTE : NBF.h
  • NBF_CGFX : NBF.h
  • NBF_CUSTOM_OBJECT : NBF.h
  • NBF_DEPTH_ATTRIBUTE : NBF.h
  • NBF_DIRECTED_LIGHT : NBF.h
  • NBF_FACE_ATTRIBUTE : NBF.h
  • NBF_FLIPBOOK_ANIMATION : NBF.h
  • NBF_FRAMED_INDEX_ANIMATION : NBF.h
  • NBF_FRAMED_TRAFO_ANIMATION : NBF.h
  • NBF_FRAMED_VERTEX_ATTRIBUTE_ANIMATION : NBF.h
  • NBF_FRAMED_VNVECTOR_ANIMATION : NBF.h
  • NBF_GEO_NODE : NBF.h
  • NBF_GROUP : NBF.h
  • NBF_LIGHTING_ATTRIBUTE : NBF.h
  • NBF_LINE_ATTRIBUTE : NBF.h
  • NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION : NBF.h
  • NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION : NBF.h
  • NBF_LINES : NBF.h
  • NBF_LINESTRIPS : NBF.h
  • NBF_LITTLE_ENDIAN : NBF.h
  • NBF_LOD : NBF.h
  • NBF_MATERIAL : NBF.h
  • NBF_PARALLEL_CAMERA : NBF.h
  • NBF_PERSPECTIVE_CAMERA : NBF.h
  • NBF_POINT_ATTRIBUTE : NBF.h
  • NBF_POINT_LIGHT : NBF.h
  • NBF_POINTS : NBF.h
  • NBF_QUADMESHES : NBF.h
  • NBF_QUADS : NBF.h
  • NBF_QUADSTRIPS : NBF.h
  • NBF_SKIN : NBF.h
  • NBF_SKINNED_TRIANGLES : NBF.h
  • NBF_SPOT_LIGHT : NBF.h
  • NBF_STATE_PASS : NBF.h
  • NBF_STATE_SET : NBF.h
  • NBF_STATE_VARIANT : NBF.h
  • NBF_SWITCH : NBF.h
  • NBF_TEXTURE_ATTRIBUTE : NBF.h
  • NBF_TEXTURE_ATTRIBUTE_ITEM : NBF.h
  • NBF_TRANSFORM : NBF.h
  • NBF_TRIANGLES : NBF.h
  • NBF_TRIFANS : NBF.h
  • NBF_TRISTRIPS : NBF.h
  • NBF_UNKNOWN : NBF.h
  • NBF_UNLIT_COLOR_ATTRIBUTE : NBF.h
  • NBF_VER_BUGFIX : NBF.h
  • NBF_VER_MAJOR : NBF.h
  • NBF_VER_MINOR : NBF.h
  • NBF_VERTEX_ATTRIBUTE_SET : NBF.h
  • NBF_VOLUME_NODE : NBF.h
  • NVSG_ASSERT_CONTEXT : GLTraverser.h
  • NVSG_CACHE_BACK : GLContext.h
  • NVSG_CACHE_FRONT : GLContext.h
  • NVSG_CTASSERT_MODULO_BYTESIZE() : NBF.h
  • NVSG_LOG_FILE : Log.h
  • NVSG_LOG_TEST : Log.h
  • NVSG_LOG_TEST_ENABLED : Log.h
  • NVSG_LOG_TEST_INIT : Log.h
  • NVSG_TIF_INVALID : GLContext.h

- o -

  • operator new() : DbgNew.h
  • operator new[]() : DbgNew.h

- p -

  • PADDING : NBF.h
  • PADDING_i : NBF.h
  • PADDING_ii : NBF.h

- q -

  • queryPlugInterfaceType() : OBJSaver.h, NVSGSaver.h, WRLLoader.h, PLYLoader.h, NVSGLoader.h, NVBLoader.h

- r -

  • REG_NV_TRACE_SUBKEY : Trace.h
  • RENDER_CONTEXT : GLContext.h

- s -

  • short_t : NBF.h

- t -

  • TRACE_LOG_FILE : Trace.h

- u -

  • ubyte_t : NBF.h, PLYLoader.h
  • uint64_t : NBF.h, PLYLoader.h
  • uint_t : NBF.h, PLYLoader.h
  • UPITID_SCENE_LOADER : PlugInterfaceID.h
  • UPITID_SCENE_SAVER : PlugInterfaceID.h
  • UPITID_TEXTURE_LOADER : PlugInterfaceID.h
  • UPITID_TEXTURE_SAVER : PlugInterfaceID.h
  • UPITID_VERSION : PlugInterfaceID.h
  • ushort_t : NBF.h
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines

  • BUFFER_OFFSET : GLContext.h
  • CreateHandle : Handle.h
  • CreateHandleFromBase : Handle.h
  • GET_CURRENT_DC : GLContext.h
  • GET_CURRENT_RC : GLContext.h
  • MAKE_CURRENT : GLContext.h
  • NVSG_ASSERT_CONTEXT : GLTraverser.h
  • NVSG_CACHE_BACK : GLContext.h
  • NVSG_CACHE_FRONT : GLContext.h
  • NVSG_LOG_TEST : Log.h
  • NVSG_LOG_TEST_ENABLED : Log.h
  • NVSG_LOG_TEST_INIT : Log.h
  • NVSG_TIF_INVALID : GLContext.h
  • PADDING : NBF.h
  • PADDING_i : NBF.h
  • PADDING_ii : NBF.h
  • TRACE_LOG_FILE : Trace.h
  • UPITID_SCENE_LOADER : PlugInterfaceID.h
  • UPITID_SCENE_SAVER : PlugInterfaceID.h
  • UPITID_TEXTURE_LOADER : PlugInterfaceID.h
  • UPITID_TEXTURE_SAVER : PlugInterfaceID.h
  • UPITID_VERSION : PlugInterfaceID.h
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines
n

- n -

  • NBF_ALPHA_TEST_ATTRIBUTE : NBF.h
  • NBF_ANIMATED_QUADS : NBF.h
  • NBF_ANIMATED_TRANSFORM : NBF.h
  • NBF_ANIMATED_TRIANGLES : NBF.h
  • NBF_ANIMATED_VERTEX_ATTRIBUTE_SET : NBF.h
  • NBF_BILLBOARD : NBF.h
  • NBF_BLEND_ATTRIBUTE : NBF.h
  • NBF_CGFX : NBF.h
  • NBF_CUSTOM_OBJECT : NBF.h
  • NBF_DEPTH_ATTRIBUTE : NBF.h
  • NBF_DIRECTED_LIGHT : NBF.h
  • NBF_FACE_ATTRIBUTE : NBF.h
  • NBF_FLIPBOOK_ANIMATION : NBF.h
  • NBF_FRAMED_INDEX_ANIMATION : NBF.h
  • NBF_FRAMED_TRAFO_ANIMATION : NBF.h
  • NBF_FRAMED_VERTEX_ATTRIBUTE_ANIMATION : NBF.h
  • NBF_FRAMED_VNVECTOR_ANIMATION : NBF.h
  • NBF_GEO_NODE : NBF.h
  • NBF_GROUP : NBF.h
  • NBF_LIGHTING_ATTRIBUTE : NBF.h
  • NBF_LINE_ATTRIBUTE : NBF.h
  • NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION : NBF.h
  • NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION : NBF.h
  • NBF_LINES : NBF.h
  • NBF_LINESTRIPS : NBF.h
  • NBF_LOD : NBF.h
  • NBF_MATERIAL : NBF.h
  • NBF_PARALLEL_CAMERA : NBF.h
  • NBF_PERSPECTIVE_CAMERA : NBF.h
  • NBF_POINT_ATTRIBUTE : NBF.h
  • NBF_POINT_LIGHT : NBF.h
  • NBF_POINTS : NBF.h
  • NBF_QUADMESHES : NBF.h
  • NBF_QUADS : NBF.h
  • NBF_QUADSTRIPS : NBF.h
  • NBF_SKIN : NBF.h
  • NBF_SKINNED_TRIANGLES : NBF.h
  • NBF_SPOT_LIGHT : NBF.h
  • NBF_STATE_PASS : NBF.h
  • NBF_STATE_SET : NBF.h
  • NBF_STATE_VARIANT : NBF.h
  • NBF_SWITCH : NBF.h
  • NBF_TEXTURE_ATTRIBUTE : NBF.h
  • NBF_TEXTURE_ATTRIBUTE_ITEM : NBF.h
  • NBF_TRANSFORM : NBF.h
  • NBF_TRIANGLES : NBF.h
  • NBF_TRIFANS : NBF.h
  • NBF_TRISTRIPS : NBF.h
  • NBF_UNKNOWN : NBF.h
  • NBF_UNLIT_COLOR_ATTRIBUTE : NBF.h
  • NBF_VERTEX_ATTRIBUTE_SET : NBF.h
  • NBF_VOLUME_NODE : NBF.h
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines

  • getPlugInterface() : OBJSaver.h, NVSGSaver.h, WRLLoader.h, PLYLoader.h, NVSGLoader.h, NVBLoader.h
  • NVSG_CTASSERT_MODULO_BYTESIZE() : NBF.h
  • operator new() : DbgNew.h
  • operator new[]() : DbgNew.h
  • queryPlugInterfaceType() : OBJSaver.h, NVSGSaver.h, WRLLoader.h, PLYLoader.h, NVSGLoader.h, NVBLoader.h
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines

  • byte_t : NBF.h, PLYLoader.h
  • DEVICE_CONTEXT : GLContext.h
  • float2_t : NBF.h
  • float3_t : NBF.h
  • float44_t : NBF.h
  • float4_t : NBF.h
  • int_t : NBF.h, PLYLoader.h
  • RENDER_CONTEXT : GLContext.h
  • short_t : NBF.h
  • ubyte_t : NBF.h, PLYLoader.h
  • uint64_t : NBF.h, PLYLoader.h
  • uint_t : NBF.h, PLYLoader.h
  • ushort_t : NBF.h
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines

  • NBF_BIG_ENDIAN : NBF.h
  • NBF_LITTLE_ENDIAN : NBF.h
  • NBF_VER_BUGFIX : NBF.h
  • NBF_VER_MAJOR : NBF.h
  • NBF_VER_MINOR : NBF.h
  • NVSG_LOG_FILE : Log.h
  • REG_NV_TRACE_SUBKEY : Trace.h
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values
a | b | c | d | e | f | g | h | i | l | m | n | o | p | r | s | t | v | w

Here is a list of all documented namespace members with links to the namespaces they belong to:

- a -

  • AlphaFunction : nvsg
  • areCollinear() : nvmath
  • areOfSameType() : nvsg
  • areOnOppositeSides() : nvmath
  • areOnSameSide() : nvmath
  • areOpposite() : nvmath
  • areOrthogonal() : nvmath
  • areOrthonormal() : nvmath
  • areSimilar() : nvmath
  • assertMipMapChainComplete() : nvsg
  • attribIndex() : nvsg

- b -

  • BF_DESTINATION_ALPHA : nvsg
  • BF_DESTINATION_COLOR : nvsg
  • BF_ONE : nvsg
  • BF_ONE_MINUS_DESTINATION_ALPHA : nvsg
  • BF_ONE_MINUS_DESTINATION_COLOR : nvsg
  • BF_ONE_MINUS_SOURCE_ALPHA : nvsg
  • BF_ONE_MINUS_SOURCE_COLOR : nvsg
  • BF_SOURCE_ALPHA : nvsg
  • BF_SOURCE_ALPHA_SATURATE : nvsg
  • BF_SOURCE_COLOR : nvsg
  • BF_ZERO : nvsg
  • BlendFunction : nvsg
  • boundingBox() : nvmath
  • boundingSphere() : nvmath

- c -

  • calculateContributions() : nvsg
  • CBS : nvsg
  • CC_IN : nvsg
  • CC_OUT : nvsg
  • CC_PART : nvsg
  • CgFxAnnotation : nvsg
  • cgfxContext() : nvsg
  • CgFxParameter : nvsg
  • CgFxPass : nvsg
  • CgFxProgram : nvsg
  • CgFxTechnique : nvsg
  • cIdentity44f : nvmath
  • clamp() : nvmath
  • compare() : nvmath
  • convertPixelFormat() : nvsg
  • createClipPlanesElement() : nvtraverser
  • createHighlightElement() : nvtraverser
  • createLightsElement() : nvtraverser
  • createRenderElement() : nvtraverser
  • createTransformElement() : nvtraverser
  • CullCode : nvsg

- d -

  • DataID : nvsg
  • dbgAllocImagePixels() : nvsg
  • decompose() : nvmath
  • degToRad() : nvmath
  • DepthFunction : nvsg
  • DestroyCallback : nvutil
  • determinant() : nvmath
  • determinePixelFormat() : nvui
  • determineTextureTarget() : nvsg
  • distance() : nvmath

- e -

  • EnableLocking() : nvutil
  • equal3f() : nvgl
  • equal3fv() : nvgl
  • equal4f() : nvgl
  • equal4fv() : nvgl
  • equalf() : nvgl
  • errorMessage() : nvutil::IO

- f -

  • Face3 : nvsg
  • Face4 : nvsg
  • FileExists() : nvutil
  • FileSize() : nvutil
  • FindFile() : nvutil
  • FindFileFirst() : nvutil
  • freeImagePixels() : nvsg

- g -

  • genericAttrib() : nvsg
  • getBoundingSphere() : nvsg
  • getCopyrightString() : nvsg
  • GetCurrentDir() : nvutil
  • GetDirFromPath() : nvutil
  • GetDrvAndDirFromPath() : nvutil
  • GetDrvFromPath() : nvutil
  • GetFileExtFromPath() : nvutil
  • GetFileNameFromPath() : nvutil
  • GetModulePath() : nvutil
  • getSDKName() : nvsg
  • getSubBrickPosition() : nvsg
  • getSupportedFeatures() : nvsg
  • getVendorName() : nvsg
  • getVersionString() : nvsg
  • GLAccum() : nvgl
  • GLActiveStencilFace() : nvgl
  • GLActiveTexture() : nvgl
  • GLActiveVarying() : nvgl
  • GLAddSwapHintRect() : nvgl
  • GLAlphaFunc() : nvgl
  • GLAreProgramsResident() : nvgl
  • GLAreTexturesResident() : nvgl
  • GLArrayElement() : nvgl
  • GLAttachObject() : nvgl
  • GLAttachShader() : nvgl
  • GLBegin() : nvgl
  • GLBeginOcclusionQuery() : nvgl
  • GLBeginQuery() : nvgl
  • GLBeginTransformFeedback() : nvgl
  • GLBindArraySet() : nvgl
  • GLBindAttribLocation() : nvgl
  • GLBindBuffer() : nvgl
  • GLBindBufferBase() : nvgl
  • GLBindBufferOffset() : nvgl
  • GLBindBufferRange() : nvgl
  • GLBindFragDataLocation() : nvgl
  • GLBindFramebuffer() : nvgl
  • GLBindIndexBuffer() : nvgl
  • GLBindProgram() : nvgl
  • GLBindRenderbuffer() : nvgl
  • GLBindTexture() : nvgl
  • GLBindTransformFeedbackBuffer() : nvgl
  • GLBindVertexBuffer() : nvgl
  • GLBitmap() : nvgl
  • GLBlendColor() : nvgl
  • GLBlendEquation() : nvgl
  • GLBlendEquationSeparate() : nvgl
  • GLBlendFunc() : nvgl
  • GLBlendFuncSeparate() : nvgl
  • GLBlitFramebuffer() : nvgl
  • GLBufferData() : nvgl
  • GLBufferSubData() : nvgl
  • GLBuildVertexBufferCache() : nvgl
  • GLCallList() : nvgl
  • GLCallLists() : nvgl
  • GLCheckFramebufferStatus() : nvgl
  • GLClampColor() : nvgl
  • GLClear() : nvgl
  • GLClearAccum() : nvgl
  • GLClearColor() : nvgl
  • GLClearColorIi() : nvgl
  • GLClearColorIui() : nvgl
  • GLClearDepth() : nvgl
  • GLClearDepthd() : nvgl
  • GLClearIndex() : nvgl
  • GLClearStencil() : nvgl
  • GLClientActiveTexture() : nvgl
  • GLClipPlane() : nvgl
  • GLColor3b() : nvgl
  • GLColor3bv() : nvgl
  • GLColor3d() : nvgl
  • GLColor3dv() : nvgl
  • GLColor3f() : nvgl
  • GLColor3fv() : nvgl
  • GLColor3h() : nvgl
  • GLColor3hv() : nvgl
  • GLColor3i() : nvgl
  • GLColor3iv() : nvgl
  • GLColor3s() : nvgl
  • GLColor3sv() : nvgl
  • GLColor3ub() : nvgl
  • GLColor3ubv() : nvgl
  • GLColor3ui() : nvgl
  • GLColor3uiv() : nvgl
  • GLColor3us() : nvgl
  • GLColor3usv() : nvgl
  • GLColor4b() : nvgl
  • GLColor4bv() : nvgl
  • GLColor4d() : nvgl
  • GLColor4dv() : nvgl
  • GLColor4f() : nvgl
  • GLColor4fv() : nvgl
  • GLColor4h() : nvgl
  • GLColor4hv() : nvgl
  • GLColor4i() : nvgl
  • GLColor4iv() : nvgl
  • GLColor4s() : nvgl
  • GLColor4sv() : nvgl
  • GLColor4ub() : nvgl
  • GLColor4ubv() : nvgl
  • GLColor4ui() : nvgl
  • GLColor4uiv() : nvgl
  • GLColor4us() : nvgl
  • GLColor4usv() : nvgl
  • GLColorMask() : nvgl
  • GLColorMaskIndexed() : nvgl
  • GLColorMaterial() : nvgl
  • GLColorPointer() : nvgl
  • GLColorSubTable() : nvgl
  • GLColorTable() : nvgl
  • GLColorTableParameterfv() : nvgl
  • GLColorTableParameteriv() : nvgl
  • GLCombinerInput() : nvgl
  • GLCombinerOutput() : nvgl
  • GLCombinerParameterf() : nvgl
  • GLCombinerParameterfv() : nvgl
  • GLCombinerParameteri() : nvgl
  • GLCombinerParameteriv() : nvgl
  • GLCombinerStageParameterfv() : nvgl
  • GLCompileShader() : nvgl
  • GLCompressedTexImage1D() : nvgl
  • GLCompressedTexImage2D() : nvgl
  • GLCompressedTexImage3D() : nvgl
  • GLCompressedTexSubImage1D() : nvgl
  • GLCompressedTexSubImage2D() : nvgl
  • GLCompressedTexSubImage3D() : nvgl
  • glContext() : nvgl
  • GLConvolutionFilter1D() : nvgl
  • GLConvolutionFilter2D() : nvgl
  • GLConvolutionParameterf() : nvgl
  • GLConvolutionParameterfv() : nvgl
  • GLConvolutionParameteri() : nvgl
  • GLConvolutionParameteriv() : nvgl
  • GLCopyColorSubTable() : nvgl
  • GLCopyColorTable() : nvgl
  • GLCopyConvolutionFilter1D() : nvgl
  • GLCopyConvolutionFilter2D() : nvgl
  • GLCopyPixels() : nvgl
  • GLCopyTexImage1D() : nvgl
  • GLCopyTexImage2D() : nvgl
  • GLCopyTexSubImage1D() : nvgl
  • GLCopyTexSubImage2D() : nvgl
  • GLCopyTexSubImage3D() : nvgl
  • GLCreateProgram() : nvgl
  • GLCreateProgramObject() : nvgl
  • GLCreateShader() : nvgl
  • GLCreateShaderObject() : nvgl
  • GLCullFace() : nvgl
  • GLCullFaceLock() : nvgl
  • GLCullFaceUnlock() : nvgl
  • GLDeleteArraySets() : nvgl
  • GLDeleteBuffers() : nvgl
  • GLDeleteFences() : nvgl
  • GLDeleteFramebuffers() : nvgl
  • GLDeleteIndexBuffer() : nvgl
  • GLDeleteLists() : nvgl
  • GLDeleteObject() : nvgl
  • GLDeleteOcclusionQueries() : nvgl
  • GLDeleteProgram() : nvgl
  • GLDeletePrograms() : nvgl
  • GLDeleteQueries() : nvgl
  • GLDeleteRenderbuffers() : nvgl
  • GLDeleteShader() : nvgl
  • GLDeleteTextures() : nvgl
  • GLDeleteVertexBuffer() : nvgl
  • GLDepthBounds() : nvgl
  • GLDepthBoundsd() : nvgl
  • GLDepthFunc() : nvgl
  • GLDepthMask() : nvgl
  • GLDepthRange() : nvgl
  • GLDepthRanged() : nvgl
  • GLDetachObject() : nvgl
  • GLDetachShader() : nvgl
  • GLDisable() : nvgl
  • GLDisableAlphaTest() : nvgl
  • GLDisableAutoNormal() : nvgl
  • GLDisableBlend() : nvgl
  • GLDisableClientState() : nvgl
  • GLDisableClipPlane() : nvgl
  • GLDisableColorArray() : nvgl
  • GLDisableColorLogicOp() : nvgl
  • GLDisableColorMaterial() : nvgl
  • GLDisableCullFace() : nvgl
  • GLDisableCullFaceLock() : nvgl
  • GLDisableCullFaceUnlock() : nvgl
  • GLDisableDepthTest() : nvgl
  • GLDisableDither() : nvgl
  • GLDisableFog() : nvgl
  • GLDisableFogCoordinateArray() : nvgl
  • GLDisableIndexed() : nvgl
  • GLDisableLight() : nvgl
  • GLDisableLighting() : nvgl
  • GLDisableLightingLock() : nvgl
  • GLDisableLightingUnlock() : nvgl
  • GLDisableLineSmooth() : nvgl
  • GLDisableLineStipple() : nvgl
  • GLDisableLogicOp() : nvgl
  • GLDisableNormalArray() : nvgl
  • GLDisableNormalize() : nvgl
  • GLDisablePointSmooth() : nvgl
  • GLDisablePolygonOffsetFill() : nvgl
  • GLDisablePolygonOffsetLine() : nvgl
  • GLDisablePolygonOffsetPoint() : nvgl
  • GLDisablePolygonSmooth() : nvgl
  • GLDisablePolygonStipple() : nvgl
  • GLDisableScissorTest() : nvgl
  • GLDisableSecondaryColorArray() : nvgl
  • GLDisableStencilTest() : nvgl
  • GLDisableTexture() : nvgl
  • GLDisableTextureCoordArray() : nvgl
  • GLDisableTextureGen() : nvgl
  • GLDisableVertexArray() : nvgl
  • GLDisableVertexAttribArray() : nvgl
  • GLDrawArrays() : nvgl
  • GLDrawArraysInstanced() : nvgl
  • GLDrawBuffer() : nvgl
  • GLDrawBuffers() : nvgl
  • GLDrawElements() : nvgl
  • GLDrawElementsInstanced() : nvgl
  • GLDrawPixels() : nvgl
  • GLDrawRangeElements() : nvgl
  • GLEdgeFlag() : nvgl
  • GLEdgeFlagPointer() : nvgl
  • GLEdgeFlagv() : nvgl
  • GLEnable() : nvgl
  • GLEnableAlphaTest() : nvgl
  • GLEnableAutoNormal() : nvgl
  • GLEnableBlend() : nvgl
  • GLEnableClientState() : nvgl
  • GLEnableClipPlane() : nvgl
  • GLEnableColorArray() : nvgl
  • GLEnableColorLogicOp() : nvgl
  • GLEnableColorMaterial() : nvgl
  • GLEnableCullFace() : nvgl
  • GLEnableCullFaceLock() : nvgl
  • GLEnableCullFaceUnlock() : nvgl
  • GLEnableDepthTest() : nvgl
  • GLEnableDither() : nvgl
  • GLEnableFog() : nvgl
  • GLEnableFogCoordinateArray() : nvgl
  • GLEnableIndexed() : nvgl
  • GLEnableLight() : nvgl
  • GLEnableLighting() : nvgl
  • GLEnableLineSmooth() : nvgl
  • GLEnableLineStipple() : nvgl
  • GLEnableLogicOp() : nvgl
  • GLEnableNormalArray() : nvgl
  • GLEnableNormalize() : nvgl
  • GLEnablePointSmooth() : nvgl
  • GLEnablePolygonOffsetFill() : nvgl
  • GLEnablePolygonOffsetLine() : nvgl
  • GLEnablePolygonOffsetPoint() : nvgl
  • GLEnablePolygonSmooth() : nvgl
  • GLEnablePolygonStipple() : nvgl
  • GLEnableScissorTest() : nvgl
  • GLEnableSecondaryColorArray() : nvgl
  • GLEnableStencilTest() : nvgl
  • GLEnableTexture() : nvgl
  • GLEnableTextureCoordArray() : nvgl
  • GLEnableTextureGen() : nvgl
  • GLEnableVertexArray() : nvgl
  • GLEnableVertexAttribArray() : nvgl
  • GLEnd() : nvgl
  • GLEndList() : nvgl
  • GLEndOcclusionQuery() : nvgl
  • GLEndQuery() : nvgl
  • GLEndTransformFeedback() : nvgl
  • glError : nvgl
  • GLEvalCoord1d() : nvgl
  • GLEvalCoord1f() : nvgl
  • GLEvalCoord2d() : nvgl
  • GLEvalCoord2f() : nvgl
  • GLEvalMesh1() : nvgl
  • GLEvalMesh2() : nvgl
  • GLEvalPoint1() : nvgl
  • GLEvalPoint2() : nvgl
  • GLExecuteProgram() : nvgl
  • GLFeedbackBuffer() : nvgl
  • GLFinalCombinerInput() : nvgl
  • GLFinish() : nvgl
  • GLFinishFence() : nvgl
  • GLFlush() : nvgl
  • GLFlushPixelDataRange() : nvgl
  • GLFlushVertexArrayRange() : nvgl
  • GLFogColor() : nvgl
  • GLFogCoordd() : nvgl
  • GLFogCoorddv() : nvgl
  • GLFogCoordf() : nvgl
  • GLFogCoordfv() : nvgl
  • GLFogCoordh() : nvgl
  • GLFogCoordhv() : nvgl
  • GLFogCoordPointer() : nvgl
  • GLFogDensity() : nvgl
  • GLFogEnd() : nvgl
  • GLFogf() : nvgl
  • GLFogfv() : nvgl
  • GLFogi() : nvgl
  • GLFogiv() : nvgl
  • GLFogMode() : nvgl
  • GLFogStart() : nvgl
  • GLFramebufferRenderbuffer() : nvgl
  • GLFramebufferTexture() : nvgl
  • GLFramebufferTexture1D() : nvgl
  • GLFramebufferTexture2D() : nvgl
  • GLFramebufferTexture3D() : nvgl
  • GLFramebufferTextureFace() : nvgl
  • GLFramebufferTextureLayer() : nvgl
  • GLFrameTerminator() : nvgl
  • GLFrontFace() : nvgl
  • GLFrustum() : nvgl
  • GLGenArraySets() : nvgl
  • GLGenBuffers() : nvgl
  • GLGenerateMipmap() : nvgl
  • GLGenFences() : nvgl
  • GLGenFramebuffers() : nvgl
  • GLGenIndexBuffer() : nvgl
  • GLGenLists() : nvgl
  • GLGenOcclusionQueries() : nvgl
  • GLGenPrograms() : nvgl
  • GLGenQueries() : nvgl
  • GLGenRenderbuffers() : nvgl
  • GLGenTextures() : nvgl
  • GLGenVertexBuffer() : nvgl
  • GLGetActiveAttrib() : nvgl
  • GLGetActiveUniform() : nvgl
  • GLGetActiveVarying() : nvgl
  • GLGetAttachedObjects() : nvgl
  • GLGetAttachedShaders() : nvgl
  • GLGetAttribLocation() : nvgl
  • GLGetBooleanIndexedv() : nvgl
  • GLGetBooleanv() : nvgl
  • GLGetBufferParameteriv() : nvgl
  • GLGetBufferPointerv() : nvgl
  • GLGetBufferSubData() : nvgl
  • GLGetClipPlane() : nvgl
  • GLGetColorTable() : nvgl
  • GLGetColorTableParameterfv() : nvgl
  • GLGetColorTableParameteriv() : nvgl
  • GLGetCombinerInputParameterfv() : nvgl
  • GLGetCombinerInputParameteriv() : nvgl
  • GLGetCombinerOutputParameterfv() : nvgl
  • GLGetCombinerOutputParameteriv() : nvgl
  • GLGetCombinerStageParameterfv() : nvgl
  • GLGetCompressedTexImage() : nvgl
  • GLGetConvolutionFilter() : nvgl
  • GLGetConvolutionParameterfv() : nvgl
  • GLGetConvolutionParameteriv() : nvgl
  • GLGetDoublev() : nvgl
  • GLGetFenceiv() : nvgl
  • GLGetFinalCombinerInputParameterfv() : nvgl
  • GLGetFinalCombinerInputParameteriv() : nvgl
  • GLGetFloatv() : nvgl
  • GLGetFragDataLocation() : nvgl
  • GLGetFramebufferAttachmentParameteriv() : nvgl
  • GLGetHandle() : nvgl
  • GLGetHistogram() : nvgl
  • GLGetHistogramParameterfv() : nvgl
  • GLGetHistogramParameteriv() : nvgl
  • GLGetIndexBufferOffset() : nvgl
  • GLGetInfoLog() : nvgl
  • GLGetIntegerIndexedv() : nvgl
  • GLGetIntegerv() : nvgl
  • GLGetLightfv() : nvgl
  • GLGetLightiv() : nvgl
  • GLGetMapdv() : nvgl
  • GLGetMapfv() : nvgl
  • GLGetMapiv() : nvgl
  • GLGetMaterialfv() : nvgl
  • GLGetMaterialiv() : nvgl
  • GLGetMaxTexCoords() : nvgl
  • GLGetMaxTexImageUnits() : nvgl
  • GLGetMaxTexUnits() : nvgl
  • GLGetMinmax() : nvgl
  • GLGetMinmaxParameterfv() : nvgl
  • GLGetMinmaxParameteriv() : nvgl
  • GLGetObjectParameterfv() : nvgl
  • GLGetObjectParameteriv() : nvgl
  • GLGetOcclusionQueryiv() : nvgl
  • GLGetOcclusionQueryuiv() : nvgl
  • GLGetPixelMapfv() : nvgl
  • GLGetPixelMapuiv() : nvgl
  • GLGetPixelMapusv() : nvgl
  • GLGetPointerv() : nvgl
  • GLGetPolygonStipple() : nvgl
  • GLGetProgramEnvParameterdv() : nvgl
  • GLGetProgramEnvParameterfv() : nvgl
  • GLGetProgramEnvParameterIiv() : nvgl
  • GLGetProgramEnvParameterIuiv() : nvgl
  • GLGetProgramInfoLog() : nvgl
  • GLGetProgramiv() : nvgl
  • GLGetProgramLocalParameterdv() : nvgl
  • GLGetProgramLocalParameterfv() : nvgl
  • GLGetProgramLocalParameterIiv() : nvgl
  • GLGetProgramLocalParameterIuiv() : nvgl
  • GLGetProgramNamedParameterdv() : nvgl
  • GLGetProgramNamedParameterfv() : nvgl
  • GLGetProgramParameterdv() : nvgl
  • GLGetProgramParameterfv() : nvgl
  • GLGetProgramString() : nvgl
  • GLGetQueryiv() : nvgl
  • GLGetQueryObjecti64v() : nvgl
  • GLGetQueryObjectiv() : nvgl
  • GLGetQueryObjectui64v() : nvgl
  • GLGetQueryObjectuiv() : nvgl
  • GLGetRenderbufferParameteriv() : nvgl
  • GLGetSeparableFilter() : nvgl
  • GLGetShaderInfoLog() : nvgl
  • GLGetShaderiv() : nvgl
  • GLGetShaderSource() : nvgl
  • GLGetString() : nvgl
  • GLGetTexEnvfv() : nvgl
  • GLGetTexEnviv() : nvgl
  • GLGetTexGendv() : nvgl
  • GLGetTexGenfv() : nvgl
  • GLGetTexGeniv() : nvgl
  • GLGetTexImage() : nvgl
  • GLGetTexLevelParameterfv() : nvgl
  • GLGetTexLevelParameteriv() : nvgl
  • GLGetTexParameterfv() : nvgl
  • GLGetTexParameterIiv() : nvgl
  • GLGetTexParameterIuiv() : nvgl
  • GLGetTexParameteriv() : nvgl
  • GLGetTexWrapMode() : nvgl
  • GLGetTrackMatrixiv() : nvgl
  • GLGetTransformFeedbackVarying() : nvgl
  • GLGetUniformBufferSize() : nvgl
  • GLGetUniformfv() : nvgl
  • GLGetUniformiv() : nvgl
  • GLGetUniformLocation() : nvgl
  • GLGetUniformOffset() : nvgl
  • GLGetUniformuiv() : nvgl
  • GLGetVaryingLocation() : nvgl
  • GLGetVersion() : nvgl
  • GLGetVertexAttribdv() : nvgl
  • GLGetVertexAttribfv() : nvgl
  • GLGetVertexAttribIiv() : nvgl
  • GLGetVertexAttribIuiv() : nvgl
  • GLGetVertexAttribiv() : nvgl
  • GLGetVertexAttribPointerv() : nvgl
  • GLGetVertexBufferOffset() : nvgl
  • GLHint() : nvgl
  • GLHistogram() : nvgl
  • GLIndexd() : nvgl
  • GLIndexf() : nvgl
  • GLIndexi() : nvgl
  • GLIndexMask() : nvgl
  • GLIndexPointer() : nvgl
  • GLIndexs() : nvgl
  • GLIndexub() : nvgl
  • GLInitNames() : nvgl
  • GLInterleavedArrays() : nvgl
  • GLintToGLfloat() : nvgl
  • GLIsArraySet() : nvgl
  • GLIsBuffer() : nvgl
  • GLIsEnabled() : nvgl
  • GLIsEnabledAlphaTest() : nvgl
  • GLIsEnabledAutoNormal() : nvgl
  • GLIsEnabledBlend() : nvgl
  • GLIsEnabledClipPlane() : nvgl
  • GLIsEnabledColorLogicOp() : nvgl
  • GLIsEnabledColorMaterial() : nvgl
  • GLIsEnabledCullFace() : nvgl
  • GLIsEnabledDepthTest() : nvgl
  • GLIsEnabledDither() : nvgl
  • GLIsEnabledFog() : nvgl
  • GLIsEnabledIndexed() : nvgl
  • GLIsEnabledLight() : nvgl
  • GLIsEnabledLighting() : nvgl
  • GLIsEnabledLineSmooth() : nvgl
  • GLIsEnabledLineStipple() : nvgl
  • GLIsEnabledLogicOp() : nvgl
  • GLIsEnabledNormalize() : nvgl
  • GLIsEnabledPointSmooth() : nvgl
  • GLIsEnabledPolygonOffsetFill() : nvgl
  • GLIsEnabledPolygonOffsetLine() : nvgl
  • GLIsEnabledPolygonOffsetPoint() : nvgl
  • GLIsEnabledPolygonSmooth() : nvgl
  • GLIsEnabledPolygonStipple() : nvgl
  • GLIsEnabledScissorTest() : nvgl
  • GLIsEnabledStencilTest() : nvgl
  • GLIsEnabledTexture() : nvgl
  • GLIsEnabledTextureGen() : nvgl
  • GLIsExtensionAvailable() : nvgl
  • GLIsExtensionExported() : nvgl
  • GLIsFence() : nvgl
  • GLIsFramebuffer() : nvgl
  • GLIsIndexBuffer() : nvgl
  • GLIsList() : nvgl
  • GLIsOcclusionQuery() : nvgl
  • GLIsProgram() : nvgl
  • GLIsQuery() : nvgl
  • GLIsRenderbuffer() : nvgl
  • GLIsShader() : nvgl
  • GLIsTexture() : nvgl
  • GLIsVertexBuffer() : nvgl
  • GLLightAmbient() : nvgl
  • GLLightConstantAttenuation() : nvgl
  • GLLightDiffuse() : nvgl
  • GLLightf() : nvgl
  • GLLightfv() : nvgl
  • GLLighti() : nvgl
  • GLLightiv() : nvgl
  • GLLightLinearAttenuation() : nvgl
  • GLLightModelAmbient() : nvgl
  • GLLightModelf() : nvgl
  • GLLightModelfv() : nvgl
  • GLLightModeli() : nvgl
  • GLLightModeliv() : nvgl
  • GLLightModelLocalViewer() : nvgl
  • GLLightModelTwoSide() : nvgl
  • GLLightModelTwoSideLock() : nvgl
  • GLLightModelTwoSideUnlock() : nvgl
  • GLLightPosition() : nvgl
  • GLLightQuadraticAttenuation() : nvgl
  • GLLightSpecular() : nvgl
  • GLLightSpotCutoff() : nvgl
  • GLLightSpotDirection() : nvgl
  • GLLightSpotExponent() : nvgl
  • GLLineStipple() : nvgl
  • GLLineWidth() : nvgl
  • GLLinkProgram() : nvgl
  • GLListBase() : nvgl
  • GLLoadIdentity() : nvgl
  • GLLoadMatrixd() : nvgl
  • GLLoadMatrixf() : nvgl
  • GLLoadName() : nvgl
  • GLLoadProgram() : nvgl
  • GLLoadTransposedMatrixd() : nvgl
  • GLLoadTransposeMatrixf() : nvgl
  • GLLockArrays() : nvgl
  • GLLogicOp() : nvgl
  • GLMap1d() : nvgl
  • GLMap1f() : nvgl
  • GLMap2d() : nvgl
  • GLMap2f() : nvgl
  • GLMapBuffer() : nvgl
  • GLMapGrid1d() : nvgl
  • GLMapGrid1f() : nvgl
  • GLMapGrid2d() : nvgl
  • GLMapGrid2f() : nvgl
  • GLMapIndexBuffer() : nvgl
  • GLMapVertexBuffer() : nvgl
  • GLMaterialAmbient() : nvgl
  • GLMaterialAmbientBack() : nvgl
  • GLMaterialAmbientFront() : nvgl
  • GLMaterialAmbientFrontAndBack() : nvgl
  • GLMaterialDiffuse() : nvgl
  • GLMaterialDiffuseBack() : nvgl
  • GLMaterialDiffuseFront() : nvgl
  • GLMaterialDiffuseFrontAndBack() : nvgl
  • GLMaterialEmission() : nvgl
  • GLMaterialEmissionBack() : nvgl
  • GLMaterialEmissionFront() : nvgl
  • GLMaterialEmissionFrontAndBack() : nvgl
  • GLMaterialf() : nvgl
  • GLMaterialfv() : nvgl
  • GLMateriali() : nvgl
  • GLMaterialiv() : nvgl
  • GLMaterialShininess() : nvgl
  • GLMaterialShininessBack() : nvgl
  • GLMaterialShininessFront() : nvgl
  • GLMaterialShininessFrontAndBack() : nvgl
  • GLMaterialSpecular() : nvgl
  • GLMaterialSpecularBack() : nvgl
  • GLMaterialSpecularFront() : nvgl
  • GLMaterialSpecularFrontAndBack() : nvgl
  • GLMatrixMode() : nvgl
  • GLMinmax() : nvgl
  • GLMultiDrawArrays() : nvgl
  • GLMultiDrawElements() : nvgl
  • GLMultiTexCoord1d() : nvgl
  • GLMultiTexCoord1dv() : nvgl
  • GLMultiTexCoord1f() : nvgl
  • GLMultiTexCoord1fv() : nvgl
  • GLMultiTexCoord1h() : nvgl
  • GLMultiTexCoord1hv() : nvgl
  • GLMultiTexCoord1i() : nvgl
  • GLMultiTexCoord1iv() : nvgl
  • GLMultiTexCoord1s() : nvgl
  • GLMultiTexCoord1sv() : nvgl
  • GLMultiTexCoord2d() : nvgl
  • GLMultiTexCoord2dv() : nvgl
  • GLMultiTexCoord2f() : nvgl
  • GLMultiTexCoord2fv() : nvgl
  • GLMultiTexCoord2h() : nvgl
  • GLMultiTexCoord2hv() : nvgl
  • GLMultiTexCoord2i() : nvgl
  • GLMultiTexCoord2iv() : nvgl
  • GLMultiTexCoord2s() : nvgl
  • GLMultiTexCoord2sv() : nvgl
  • GLMultiTexCoord3d() : nvgl
  • GLMultiTexCoord3dv() : nvgl
  • GLMultiTexCoord3f() : nvgl
  • GLMultiTexCoord3fv() : nvgl
  • GLMultiTexCoord3h() : nvgl
  • GLMultiTexCoord3hv() : nvgl
  • GLMultiTexCoord3i() : nvgl
  • GLMultiTexCoord3iv() : nvgl
  • GLMultiTexCoord3s() : nvgl
  • GLMultiTexCoord3sv() : nvgl
  • GLMultiTexCoord4d() : nvgl
  • GLMultiTexCoord4dv() : nvgl
  • GLMultiTexCoord4f() : nvgl
  • GLMultiTexCoord4fv() : nvgl
  • GLMultiTexCoord4h() : nvgl
  • GLMultiTexCoord4hv() : nvgl
  • GLMultiTexCoord4i() : nvgl
  • GLMultiTexCoord4iv() : nvgl
  • GLMultiTexCoord4s() : nvgl
  • GLMultiTexCoord4sv() : nvgl
  • GLMultiTexCoordPointer() : nvgl
  • GLMultMatrixd() : nvgl
  • GLMultMatrixf() : nvgl
  • GLMultTransposeMatrixd() : nvgl
  • GLMultTransposeMatrixf() : nvgl
  • GLNewList() : nvgl
  • GLNormal3b() : nvgl
  • GLNormal3bv() : nvgl
  • GLNormal3d() : nvgl
  • GLNormal3dv() : nvgl
  • GLNormal3f() : nvgl
  • GLNormal3fv() : nvgl
  • GLNormal3h() : nvgl
  • GLNormal3hv() : nvgl
  • GLNormal3i() : nvgl
  • GLNormal3iv() : nvgl
  • GLNormal3s() : nvgl
  • GLNormal3sv() : nvgl
  • GLNormalPointer() : nvgl
  • GLOrtho() : nvgl
  • GLPassThrough() : nvgl
  • GLPixelDataRange() : nvgl
  • GLPixelMapfv() : nvgl
  • GLPixelMapuiv() : nvgl
  • GLPixelMapusv() : nvgl
  • GLPixelStoref() : nvgl
  • GLPixelStorei() : nvgl
  • GLPixelTransferf() : nvgl
  • GLPixelTransferi() : nvgl
  • GLPixelZoom() : nvgl
  • GLPointParameterf() : nvgl
  • GLPointParameterfv() : nvgl
  • GLPointParameteri() : nvgl
  • GLPointParameteriv() : nvgl
  • GLPointSize() : nvgl
  • GLPolygonMode() : nvgl
  • GLPolygonModeBack() : nvgl
  • GLPolygonModeFront() : nvgl
  • GLPolygonModeFrontAndBack() : nvgl
  • GLPolygonModeLock() : nvgl
  • GLPolygonModeUnlock() : nvgl
  • GLPolygonOffset() : nvgl
  • GLPolygonStipple() : nvgl
  • GLPopAttrib() : nvgl
  • GLPopClientAttrib() : nvgl
  • GLPopMatrix() : nvgl
  • GLPopName() : nvgl
  • GLPrimitiveRestart() : nvgl
  • GLPrimitiveRestartIndex() : nvgl
  • GLPrioritizeTextures() : nvgl
  • GLProgramBufferParametersfv() : nvgl
  • GLProgramBufferParametersIiv() : nvgl
  • GLProgramBufferParametersIuiv() : nvgl
  • GLProgramEnvParameter4d() : nvgl
  • GLProgramEnvParameter4dv() : nvgl
  • GLProgramEnvParameter4f() : nvgl
  • GLProgramEnvParameter4fv() : nvgl
  • GLProgramEnvParameterI4i() : nvgl
  • GLProgramEnvParameterI4iv() : nvgl
  • GLProgramEnvParameterI4ui() : nvgl
  • GLProgramEnvParameterI4uiv() : nvgl
  • GLProgramEnvParameters4fv() : nvgl
  • GLProgramEnvParametersI4iv() : nvgl
  • GLProgramEnvParametersI4uiv() : nvgl
  • GLProgramLocalParameter4d() : nvgl
  • GLProgramLocalParameter4dv() : nvgl
  • GLProgramLocalParameter4f() : nvgl
  • GLProgramLocalParameter4fv() : nvgl
  • GLProgramLocalParameterI4i() : nvgl
  • GLProgramLocalParameterI4iv() : nvgl
  • GLProgramLocalParameterI4ui() : nvgl
  • GLProgramLocalParameterI4uiv() : nvgl
  • GLProgramLocalParameters4fv() : nvgl
  • GLProgramLocalParametersI4iv() : nvgl
  • GLProgramLocalParametersI4uiv() : nvgl
  • GLProgramNamedParameter4d() : nvgl
  • GLProgramNamedParameter4dv() : nvgl
  • GLProgramNamedParameter4f() : nvgl
  • GLProgramNamedParameter4fv() : nvgl
  • GLProgramParameter4d() : nvgl
  • GLProgramParameter4dv() : nvgl
  • GLProgramParameter4f() : nvgl
  • GLProgramParameter4fv() : nvgl
  • GLProgramParameteri() : nvgl
  • GLProgramParameters4dv() : nvgl
  • GLProgramParameters4fv() : nvgl
  • GLProgramString() : nvgl
  • GLProgramVertexLimit() : nvgl
  • GLPushAttrib() : nvgl
  • GLPushClientAttrib() : nvgl
  • GLPushMatrix() : nvgl
  • GLPushName() : nvgl
  • GLRasterPos2d() : nvgl
  • GLRasterPos2f() : nvgl
  • GLRasterPos2i() : nvgl
  • GLRasterPos2s() : nvgl
  • GLRasterPos3d() : nvgl
  • GLRasterPos3f() : nvgl
  • GLRasterPos3i() : nvgl
  • GLRasterPos3s() : nvgl
  • GLRasterPos4d() : nvgl
  • GLRasterPos4f() : nvgl
  • GLRasterPos4i() : nvgl
  • GLRasterPos4s() : nvgl
  • GLReadBuffer() : nvgl
  • GLReadPixels() : nvgl
  • GLRectd() : nvgl
  • GLRectf() : nvgl
  • GLRecti() : nvgl
  • GLRects() : nvgl
  • GLRenderbufferStorage() : nvgl
  • GLRenderbufferStorageMultisample() : nvgl
  • GLRenderbufferStorageMultisampleCoverage() : nvgl
  • GLRenderMode() : nvgl
  • GLRequestResidentPrograms() : nvgl
  • GLResetAlphaFunc() : nvgl
  • GLResetAlphaTest() : nvgl
  • GLResetAutoNormal() : nvgl
  • GLResetBlend() : nvgl
  • GLResetBlendFunc() : nvgl
  • GLResetBlendFuncSeparate() : nvgl
  • GLResetClearColor() : nvgl
  • GLResetClearDepth() : nvgl
  • GLResetClearStencil() : nvgl
  • GLResetClipPlane() : nvgl
  • GLResetClipPlaneEquation() : nvgl
  • GLResetColorLogicOp() : nvgl
  • GLResetColorMask() : nvgl
  • GLResetColorMaterial() : nvgl
  • GLResetColorMaterialMode() : nvgl
  • GLResetCullFace() : nvgl
  • GLResetCullFaceMode() : nvgl
  • GLResetDepthFunc() : nvgl
  • GLResetDepthMask() : nvgl
  • GLResetDepthRange() : nvgl
  • GLResetDepthTest() : nvgl
  • GLResetDither() : nvgl
  • GLResetFog() : nvgl
  • GLResetFogColor() : nvgl
  • GLResetFogDensity() : nvgl
  • GLResetFogEnd() : nvgl
  • GLResetFogMode() : nvgl
  • GLResetFogStart() : nvgl
  • GLResetFrontFace() : nvgl
  • GLResetHistogram() : nvgl
  • GLResetLight() : nvgl
  • GLResetLightAmbient() : nvgl
  • GLResetLightConstantAttenuation() : nvgl
  • GLResetLightDiffuse() : nvgl
  • GLResetLighting() : nvgl
  • GLResetLightLinearAttenuation() : nvgl
  • GLResetLightModelAmbient() : nvgl
  • GLResetLightModelLocalViewer() : nvgl
  • GLResetLightModelTwoSide() : nvgl
  • GLResetLightPosition() : nvgl
  • GLResetLightQuadraticAttenuation() : nvgl
  • GLResetLightSpecular() : nvgl
  • GLResetLightSpotCutoff() : nvgl
  • GLResetLightSpotDirection() : nvgl
  • GLResetLightSpotExponent() : nvgl
  • GLResetLineSmooth() : nvgl
  • GLResetLineStipple() : nvgl
  • GLResetLineStippleDefinition() : nvgl
  • GLResetLineWidth() : nvgl
  • GLResetLogicOp() : nvgl
  • GLResetMaterialAmbientBack() : nvgl
  • GLResetMaterialAmbientFront() : nvgl
  • GLResetMaterialAmbientFrontAndBack() : nvgl
  • GLResetMaterialDiffuseBack() : nvgl
  • GLResetMaterialDiffuseFront() : nvgl
  • GLResetMaterialDiffuseFrontAndBack() : nvgl
  • GLResetMaterialEmissionBack() : nvgl
  • GLResetMaterialEmissionFront() : nvgl
  • GLResetMaterialEmissionFrontAndBack() : nvgl
  • GLResetMaterialShininessBack() : nvgl
  • GLResetMaterialShininessFront() : nvgl
  • GLResetMaterialShininessFrontAndBack() : nvgl
  • GLResetMaterialSpecularBack() : nvgl
  • GLResetMaterialSpecularFront() : nvgl
  • GLResetMaterialSpecularFrontAndBack() : nvgl
  • GLResetMinmax() : nvgl
  • GLResetNormalize() : nvgl
  • GLResetPointSize() : nvgl
  • GLResetPointSmooth() : nvgl
  • GLResetPolygonModeBack() : nvgl
  • GLResetPolygonModeFront() : nvgl
  • GLResetPolygonModeFrontAndBack() : nvgl
  • GLResetPolygonOffset() : nvgl
  • GLResetPolygonOffsetFill() : nvgl
  • GLResetPolygonOffsetLine() : nvgl
  • GLResetPolygonOffsetPoint() : nvgl
  • GLResetPolygonSmooth() : nvgl
  • GLResetPolygonStipple() : nvgl
  • GLResetScissor() : nvgl
  • GLResetScissorTest() : nvgl
  • GLResetShadeModel() : nvgl
  • GLResetStencilFunc() : nvgl
  • GLResetStencilMask() : nvgl
  • GLResetStencilOp() : nvgl
  • GLResetStencilTest() : nvgl
  • GLResetTexture() : nvgl
  • GLRotated() : nvgl
  • GLRotatef() : nvgl
  • GLSampleCoverage() : nvgl
  • GLScaled() : nvgl
  • GLScalef() : nvgl
  • GLScissor() : nvgl
  • GLSecondaryColor3b() : nvgl
  • GLSecondaryColor3bv() : nvgl
  • GLSecondaryColor3d() : nvgl
  • GLSecondaryColor3dv() : nvgl
  • GLSecondaryColor3f() : nvgl
  • GLSecondaryColor3fv() : nvgl
  • GLSecondaryColor3h() : nvgl
  • GLSecondaryColor3hv() : nvgl
  • GLSecondaryColor3i() : nvgl
  • GLSecondaryColor3iv() : nvgl
  • GLSecondaryColor3s() : nvgl
  • GLSecondaryColor3sv() : nvgl
  • GLSecondaryColor3ub() : nvgl
  • GLSecondaryColor3ubv() : nvgl
  • GLSecondaryColor3ui() : nvgl
  • GLSecondaryColor3uiv() : nvgl
  • GLSecondaryColor3us() : nvgl
  • GLSecondaryColor3usv() : nvgl
  • GLSecondaryColorPointer() : nvgl
  • GLSelectBuffer() : nvgl
  • GLSelectTexture() : nvgl
  • GLSelectTextureCoordSet() : nvgl
  • GLSeparableFilter2D() : nvgl
  • GLSetFence() : nvgl
  • GLSetWindowStereoMode() : nvgl
  • GLShadeModel() : nvgl
  • GLShaderSource() : nvgl
  • GLStencilClearTag() : nvgl
  • GLStencilFunc() : nvgl
  • GLStencilFuncSeparate() : nvgl
  • GLStencilMask() : nvgl
  • GLStencilMaskSeparate() : nvgl
  • GLStencilOp() : nvgl
  • GLStencilOpSeparate() : nvgl
  • GLStringMarker() : nvgl
  • GLTestFence() : nvgl
  • GLTexBuffer() : nvgl
  • GLTexCoord1d() : nvgl
  • GLTexCoord1dv() : nvgl
  • GLTexCoord1f() : nvgl
  • GLTexCoord1fv() : nvgl
  • GLTexCoord1h() : nvgl
  • GLTexCoord1hv() : nvgl
  • GLTexCoord1i() : nvgl
  • GLTexCoord1iv() : nvgl
  • GLTexCoord1s() : nvgl
  • GLTexCoord1sv() : nvgl
  • GLTexCoord2d() : nvgl
  • GLTexCoord2dv() : nvgl
  • GLTexCoord2f() : nvgl
  • GLTexCoord2fv() : nvgl
  • GLTexCoord2h() : nvgl
  • GLTexCoord2hv() : nvgl
  • GLTexCoord2i() : nvgl
  • GLTexCoord2iv() : nvgl
  • GLTexCoord2s() : nvgl
  • GLTexCoord2sv() : nvgl
  • GLTexCoord3d() : nvgl
  • GLTexCoord3dv() : nvgl
  • GLTexCoord3f() : nvgl
  • GLTexCoord3fv() : nvgl
  • GLTexCoord3h() : nvgl
  • GLTexCoord3hv() : nvgl
  • GLTexCoord3i() : nvgl
  • GLTexCoord3iv() : nvgl
  • GLTexCoord3s() : nvgl
  • GLTexCoord3sv() : nvgl
  • GLTexCoord4d() : nvgl
  • GLTexCoord4dv() : nvgl
  • GLTexCoord4f() : nvgl
  • GLTexCoord4fv() : nvgl
  • GLTexCoord4h() : nvgl
  • GLTexCoord4hv() : nvgl
  • GLTexCoord4i() : nvgl
  • GLTexCoord4iv() : nvgl
  • GLTexCoord4s() : nvgl
  • GLTexCoord4sv() : nvgl
  • GLTexCoordPointer() : nvgl
  • GLTexEnvf() : nvgl
  • GLTexEnvfv() : nvgl
  • GLTexEnvi() : nvgl
  • GLTexEnviv() : nvgl
  • GLTexGend() : nvgl
  • GLTexGenf() : nvgl
  • GLTexGenfv() : nvgl
  • GLTexGeni() : nvgl
  • GLTexImage1D() : nvgl
  • GLTexImage2D() : nvgl
  • GLTexImage3D() : nvgl
  • GLTexParameterf() : nvgl
  • GLTexParameterfv() : nvgl
  • GLTexParameteri() : nvgl
  • GLTexParameterIiv() : nvgl
  • GLTexParameterIuiv() : nvgl
  • GLTexParameteriv() : nvgl
  • GLTexSubImage1D() : nvgl
  • GLTexSubImage2D() : nvgl
  • GLTexSubImage3D() : nvgl
  • GLTextureBorderColor() : nvgl
  • GLTextureEnvColor() : nvgl
  • GLTextureEnvMode() : nvgl
  • GLTextureMagFilter() : nvgl
  • GLTextureMinFilter() : nvgl
  • GLTextureWrapR() : nvgl
  • GLTextureWrapS() : nvgl
  • GLTextureWrapT() : nvgl
  • GLTrackMatrix() : nvgl
  • GLTransformFeedbackAttribs() : nvgl
  • GLTransformFeedbackVaryings() : nvgl
  • GLTranslated() : nvgl
  • GLTranslatef() : nvgl
  • GLUniform1f() : nvgl
  • GLUniform1fv() : nvgl
  • GLUniform1i() : nvgl
  • GLUniform1iv() : nvgl
  • GLUniform1ui() : nvgl
  • GLUniform1uiv() : nvgl
  • GLUniform2f() : nvgl
  • GLUniform2fv() : nvgl
  • GLUniform2i() : nvgl
  • GLUniform2iv() : nvgl
  • GLUniform2ui() : nvgl
  • GLUniform2uiv() : nvgl
  • GLUniform3f() : nvgl
  • GLUniform3fv() : nvgl
  • GLUniform3i() : nvgl
  • GLUniform3iv() : nvgl
  • GLUniform3ui() : nvgl
  • GLUniform3uiv() : nvgl
  • GLUniform4f() : nvgl
  • GLUniform4fv() : nvgl
  • GLUniform4i() : nvgl
  • GLUniform4iv() : nvgl
  • GLUniform4ui() : nvgl
  • GLUniform4uiv() : nvgl
  • GLUniformBuffer() : nvgl
  • GLUniformMatrix2fv() : nvgl
  • GLUniformMatrix2x3fv() : nvgl
  • GLUniformMatrix2x4fv() : nvgl
  • GLUniformMatrix3fv() : nvgl
  • GLUniformMatrix3x2fv() : nvgl
  • GLUniformMatrix3x4fv() : nvgl
  • GLUniformMatrix4fv() : nvgl
  • GLUniformMatrix4x2fv() : nvgl
  • GLUniformMatrix4x3fv() : nvgl
  • GLUnlockArrays() : nvgl
  • GLUnmapBuffer() : nvgl
  • GLUnmapIndexBuffer() : nvgl
  • GLUnmapVertexBuffer() : nvgl
  • GLUploadBuffers() : nvgl
  • GLUseProgram() : nvgl
  • GLUseProgramObject() : nvgl
  • GLValidateProgram() : nvgl
  • GLValidBackBufferHint() : nvgl
  • GLVertex2d() : nvgl
  • GLVertex2dv() : nvgl
  • GLVertex2f() : nvgl
  • GLVertex2fv() : nvgl
  • GLVertex2h() : nvgl
  • GLVertex2hv() : nvgl
  • GLVertex2i() : nvgl
  • GLVertex2iv() : nvgl
  • GLVertex2s() : nvgl
  • GLVertex2sv() : nvgl
  • GLVertex3d() : nvgl
  • GLVertex3dv() : nvgl
  • GLVertex3f() : nvgl
  • GLVertex3fv() : nvgl
  • GLVertex3h() : nvgl
  • GLVertex3hv() : nvgl
  • GLVertex3i() : nvgl
  • GLVertex3iv() : nvgl
  • GLVertex3s() : nvgl
  • GLVertex3sv() : nvgl
  • GLVertex4d() : nvgl
  • GLVertex4dv() : nvgl
  • GLVertex4f() : nvgl
  • GLVertex4fv() : nvgl
  • GLVertex4h() : nvgl
  • GLVertex4hv() : nvgl
  • GLVertex4i() : nvgl
  • GLVertex4iv() : nvgl
  • GLVertex4s() : nvgl
  • GLVertex4sv() : nvgl
  • GLVertexArrayRange() : nvgl
  • GLVertexAttrib1d() : nvgl
  • GLVertexAttrib1dv() : nvgl
  • GLVertexAttrib1f() : nvgl
  • GLVertexAttrib1fv() : nvgl
  • GLVertexAttrib1h() : nvgl
  • GLVertexAttrib1hv() : nvgl
  • GLVertexAttrib1s() : nvgl
  • GLVertexAttrib1sv() : nvgl
  • GLVertexAttrib2d() : nvgl
  • GLVertexAttrib2dv() : nvgl
  • GLVertexAttrib2f() : nvgl
  • GLVertexAttrib2fv() : nvgl
  • GLVertexAttrib2h() : nvgl
  • GLVertexAttrib2hv() : nvgl
  • GLVertexAttrib2s() : nvgl
  • GLVertexAttrib2sv() : nvgl
  • GLVertexAttrib3d() : nvgl
  • GLVertexAttrib3dv() : nvgl
  • GLVertexAttrib3f() : nvgl
  • GLVertexAttrib3fv() : nvgl
  • GLVertexAttrib3h() : nvgl
  • GLVertexAttrib3hv() : nvgl
  • GLVertexAttrib3s() : nvgl
  • GLVertexAttrib3sv() : nvgl
  • GLVertexAttrib4bv() : nvgl
  • GLVertexAttrib4d() : nvgl
  • GLVertexAttrib4dv() : nvgl
  • GLVertexAttrib4f() : nvgl
  • GLVertexAttrib4fv() : nvgl
  • GLVertexAttrib4h() : nvgl
  • GLVertexAttrib4hv() : nvgl
  • GLVertexAttrib4iv() : nvgl
  • GLVertexAttrib4Nbv() : nvgl
  • GLVertexAttrib4Niv() : nvgl
  • GLVertexAttrib4Nsv() : nvgl
  • GLVertexAttrib4Nub() : nvgl
  • GLVertexAttrib4Nubv() : nvgl
  • GLVertexAttrib4Nuiv() : nvgl
  • GLVertexAttrib4Nusv() : nvgl
  • GLVertexAttrib4s() : nvgl
  • GLVertexAttrib4sv() : nvgl
  • GLVertexAttrib4ub() : nvgl
  • GLVertexAttrib4ubv() : nvgl
  • GLVertexAttrib4uiv() : nvgl
  • GLVertexAttrib4usv() : nvgl
  • GLVertexAttribI1i() : nvgl
  • GLVertexAttribI1iv() : nvgl
  • GLVertexAttribI1ui() : nvgl
  • GLVertexAttribI1uiv() : nvgl
  • GLVertexAttribI2i() : nvgl
  • GLVertexAttribI2iv() : nvgl
  • GLVertexAttribI2ui() : nvgl
  • GLVertexAttribI2uiv() : nvgl
  • GLVertexAttribI3i() : nvgl
  • GLVertexAttribI3iv() : nvgl
  • GLVertexAttribI3ui() : nvgl
  • GLVertexAttribI3uiv() : nvgl
  • GLVertexAttribI4bv() : nvgl
  • GLVertexAttribI4i() : nvgl
  • GLVertexAttribI4iv() : nvgl
  • GLVertexAttribI4sv() : nvgl
  • GLVertexAttribI4ubv() : nvgl
  • GLVertexAttribI4ui() : nvgl
  • GLVertexAttribI4uiv() : nvgl
  • GLVertexAttribI4usv() : nvgl
  • GLVertexAttribIPointer() : nvgl
  • GLVertexAttribPointer() : nvgl
  • GLVertexAttribPointerNV() : nvgl
  • GLVertexAttribs1dvNV() : nvgl
  • GLVertexAttribs1fvNV() : nvgl
  • GLVertexAttribs1hv() : nvgl
  • GLVertexAttribs1svNV() : nvgl
  • GLVertexAttribs2dvNV() : nvgl
  • GLVertexAttribs2fvNV() : nvgl
  • GLVertexAttribs2hv() : nvgl
  • GLVertexAttribs2svNV() : nvgl
  • GLVertexAttribs3dvNV() : nvgl
  • GLVertexAttribs3fvNV() : nvgl
  • GLVertexAttribs3hv() : nvgl
  • GLVertexAttribs3svNV() : nvgl
  • GLVertexAttribs4dvNV() : nvgl
  • GLVertexAttribs4fvNV() : nvgl
  • GLVertexAttribs4hv() : nvgl
  • GLVertexAttribs4svNV() : nvgl
  • GLVertexAttribs4ubvNV() : nvgl
  • GLVertexPointer() : nvgl
  • GLViewport() : nvgl
  • GLWindowBackBufferHint() : nvgl
  • GLWindowPos2d() : nvgl
  • GLWindowPos2dv() : nvgl
  • GLWindowPos2f() : nvgl
  • GLWindowPos2fv() : nvgl
  • GLWindowPos2i() : nvgl
  • GLWindowPos2iv() : nvgl
  • GLWindowPos2s() : nvgl
  • GLWindowPos2sv() : nvgl
  • GLWindowPos3d() : nvgl
  • GLWindowPos3dv() : nvgl
  • GLWindowPos3f() : nvgl
  • GLWindowPos3fv() : nvgl
  • GLWindowPos3i() : nvgl
  • GLWindowPos3iv() : nvgl
  • GLWindowPos3s() : nvgl
  • GLWindowPos3sv() : nvgl
  • GLXCreateContext() : nvgl
  • GLXDestroyContext() : nvgl
  • GLXGetCurrentContext() : nvgl
  • GLXGetCurrentDrawable() : nvgl
  • GLXInitializeExtensions() : nvgl
  • GLXIsExtensionAvailable() : nvgl
  • GLXIsExtensionExported() : nvgl

- h -

  • HDAL : nvsg
  • HDAL_INVALID : nvsg
  • highestBit() : nvmath
  • highestBitValue() : nvmath

- i -

  • insert() : nvsg
  • intersectingSphere() : nvmath
  • isEmpty() : nvmath
  • isEmptyBoundingSphere() : nvsg
  • isIdentity() : nvmath
  • isNormalized() : nvmath
  • isNull() : nvmath
  • isOrthogonal() : nvmath
  • isPowerOfTwo() : nvmath
  • isRotation() : nvmath
  • isTypeOf() : nvsg

- l -

  • length() : nvmath
  • lengthSquared() : nvmath
  • lerp() : nvmath
  • LOG_OUTPUT_FUNCTION : nvutil
  • logFileOutput : nvutil
  • LogTest : nvutil

- m -

  • MA_CENTER : nvsg
  • MA_LOWER : nvsg
  • MA_UPPER : nvsg
  • magnitude() : nvmath
  • MapAlignment : nvsg
  • MapOrientation : nvsg
  • MapRelation : nvsg
  • MapTraversalDirection : nvsg
  • MaterialFace : nvsg
  • max() : nvmath
  • maxElement() : nvmath
  • MF_BACK : nvsg
  • MF_FRONT : nvsg
  • MF_FRONT_AND_BACK : nvsg
  • min() : nvmath
  • minElement() : nvmath
  • MO_HORIZONTAL : nvsg
  • MO_VERTICAL : nvsg
  • MR_CENTER : nvsg
  • MR_CENTER_LEFT : nvsg
  • MR_CENTER_RIGHT : nvsg
  • MR_LOWER_CENTER : nvsg
  • MR_LOWER_LEFT : nvsg
  • MR_LOWER_RIGHT : nvsg
  • MR_UPPER_CENTER : nvsg
  • MR_UPPER_LEFT : nvsg
  • MR_UPPER_RIGHT : nvsg
  • MTD_HIGH_TO_LOW : nvsg
  • MTD_LOW_TO_HIGH : nvsg

- n -

  • nearestPoint() : nvmath
  • normalize() : nvsg, nvmath
  • numberOfComponents() : nvsg
  • NVSG_TEXTURE_1D : nvsg
  • NVSG_TEXTURE_1D_ARRAY : nvsg
  • NVSG_TEXTURE_2D : nvsg
  • NVSG_TEXTURE_2D_ARRAY : nvsg
  • NVSG_TEXTURE_3D : nvsg
  • NVSG_TEXTURE_CUBE : nvsg
  • NVSG_TEXTURE_RECTANGLE : nvsg
  • NVSG_TEXTURE_TARGET_COUNT : nvsg
  • NVSG_UNSPECIFIED_TEXTURE_TARGET : nvsg
  • NVSGERRORHANDLER : nvsg
  • nvsgErrorHandler : nvsg
  • nvsgInitialize() : nvsg
  • nvsgSetErrorHandler() : nvsg
  • nvsgTerminate() : nvsg

- o -

  • OC_ALPHATESTATTRIBUTE : nvsg
  • OC_ANIMATED_VERTEX_ATTRIBUTE_SET : nvsg
  • OC_ANIMATEDTRANSFORM : nvsg
  • OC_ANIMATION : nvsg
  • OC_BILLBOARD : nvsg
  • OC_BITMAP : nvsg
  • OC_BLENDATTRIBUTE : nvsg
  • OC_CAMERA : nvsg
  • OC_CGFX : nvsg
  • OC_CUSTOMOBJECT : nvsg
  • OC_DEPTHATTRIBUTE : nvsg
  • OC_DIRECTEDLIGHT : nvsg
  • OC_DRAWABLES : nvsg
  • OC_FACEATTRIBUTE : nvsg
  • OC_FLIPBOOKANIMATION : nvsg
  • OC_FRAMEDINDEXANIMATION : nvsg
  • OC_FRAMEDTRAFOANIMATION : nvsg
  • OC_FRAMEDVERTEXATTRIBUTEANIMATION : nvsg
  • OC_GEONODE : nvsg
  • OC_GROUP : nvsg
  • OC_HIGHLIGHTBOX : nvsg
  • OC_HIGHLIGHTEDGES : nvsg
  • OC_HIGHLIGHTOBJECT : nvsg
  • OC_INVALID : nvsg
  • OC_LIGHTINGATTRIBUTE : nvsg
  • OC_LINEARINTERPOLATEDTRAFOANIMATION : nvsg
  • OC_LINEARINTERPOLATEDVERTEXATTRIBUTEANIMATION : nvsg
  • OC_LINEATTRIBUTE : nvsg
  • OC_LINES : nvsg
  • OC_LINESTRIPS : nvsg
  • OC_LOD : nvsg
  • OC_MAPARRAY : nvsg
  • OC_MAPELEMENT : nvsg
  • OC_MAPLIST : nvsg
  • OC_MAPMATRIX : nvsg
  • OC_MATERIAL : nvsg
  • OC_NODE : nvsg
  • OC_OBJECT : nvsg
  • OC_PARALLELCAMERA : nvsg
  • OC_PERSPECTIVECAMERA : nvsg
  • OC_PIXMAP : nvsg
  • OC_POINTATTRIBUTE : nvsg
  • OC_POINTLIGHT : nvsg
  • OC_POINTS : nvsg
  • OC_QUADMESHES : nvsg
  • OC_QUADS : nvsg
  • OC_QUADSTRIPS : nvsg
  • OC_SHAPE : nvsg
  • OC_SKIN : nvsg
  • OC_SKINNEDTRIANGLES : nvsg
  • OC_SPOTLIGHT : nvsg
  • OC_STATEATTRIBUTE : nvsg
  • OC_STATEPASS : nvsg
  • OC_STATESET : nvsg
  • OC_STATESETEXT : nvsg
  • OC_STATEVARIANT : nvsg
  • OC_SWITCH : nvsg
  • OC_TEXTUREATTRIBUTE : nvsg
  • OC_TEXTUREATTRIBUTEITEM : nvsg
  • OC_TRANSFORM : nvsg
  • OC_TRIANGLES : nvsg
  • OC_TRIFANS : nvsg
  • OC_TRISTRIPS : nvsg
  • OC_UNLITCOLORATTRIBUTE : nvsg
  • OC_VERTEX_ATTRIBUTE_SET : nvsg
  • OC_VOLUMEBRICK : nvsg
  • OC_VOLUMENODE : nvsg
  • operator *() : nvmath
  • operator!=() : nvutil, nvsg, nvmath
  • operator+() : nvmath
  • operator-() : nvmath
  • operator/() : nvmath
  • operator<() : nvutil
  • operator==() : nvutil, nvsg, nvmath
  • operator^() : nvmath
  • operator~() : nvmath
  • orthonormalize() : nvmath

- p -

  • PFNGETPLUGINTERFACE : nvutil
  • PFNQUERYPLUGINTERFACETYPE : nvutil
  • PI : nvmath
  • PI_HALF : nvmath
  • PI_QUARTER : nvmath
  • PIS : nvutil
  • powerOfTwoAbove() : nvmath
  • powerOfTwoBelow() : nvmath
  • powerOfTwoNearest() : nvmath
  • ProblemLogList : nvutil

- r -

  • radToDeg() : nvmath
  • rescale() : nvsg

- s -

  • Segment : nvsg
  • SetCurrentDir() : nvutil
  • setIdentity() : nvmath
  • setMat() : nvmath
  • setVec() : nvmath
  • sign() : nvmath
  • signedDistance() : nvmath
  • sizeOfComponents() : nvsg
  • sizeOfType() : nvsg
  • smoothNormals() : nvmath
  • SQRT_TWO : nvmath
  • SQRT_TWO_HALF : nvmath
  • square() : nvmath

- t -

  • TCA_Q : nvsg
  • TCA_R : nvsg
  • TCA_S : nvsg
  • TCA_T : nvsg
  • TCT_CYLINDRICAL : nvsg
  • TCT_PLANAR : nvsg
  • TCT_SPHERICAL : nvsg
  • TEM_ADD : nvsg
  • TEM_ADD_SIGNED : nvsg
  • TEM_BLEND : nvsg
  • TEM_DECAL : nvsg
  • TEM_DOT3_RGB : nvsg
  • TEM_DOT3_RGBA : nvsg
  • TEM_INTERPOLATE : nvsg
  • TEM_MODULATE : nvsg
  • TEM_REPLACE : nvsg
  • TEM_SUBTRACT : nvsg
  • TES_1X : nvsg
  • TES_2X : nvsg
  • TES_4X : nvsg
  • TESTMODE : nvutil
  • testPixelFormat() : nvui
  • TexCoordAxis : nvsg
  • TexGenLinearPlane : nvsg
  • TexGenMode : nvsg
  • TextureCoordType : nvsg
  • TextureEnvMode : nvsg
  • TextureEnvScale : nvsg
  • TextureMagFilterMode : nvsg
  • TextureMinFilterMode : nvsg
  • TextureTarget : nvsg
  • TextureWrapMode : nvsg
  • TexWrapCoordAxis : nvsg
  • TFM_MAG_BILINEAR : nvsg
  • TFM_MAG_LINEAR : nvsg
  • TFM_MAG_NEAREST : nvsg
  • TFM_MIN_BILINEAR : nvsg
  • TFM_MIN_LINEAR : nvsg
  • TFM_MIN_LINEAR_MIPMAP_LINEAR : nvsg
  • TFM_MIN_LINEAR_MIPMAP_NEAREST : nvsg
  • TFM_MIN_NEAREST : nvsg
  • TFM_MIN_NEAREST_MIPMAP_LINEAR : nvsg
  • TFM_MIN_NEAREST_MIPMAP_NEAREST : nvsg
  • TFM_MIN_TRILINEAR : nvsg
  • TGLP_EYE : nvsg
  • TGLP_OBJECT : nvsg
  • TGLP_OBJECT_AND_EYE : nvsg
  • TGM_EYE_LINEAR : nvsg
  • TGM_NORMAL_MAP : nvsg
  • TGM_OBJECT_LINEAR : nvsg
  • TGM_OFF : nvsg
  • TGM_REFLECTION_MAP : nvsg
  • TGM_SPHERE_MAP : nvsg
  • TM_NONE : nvutil
  • TM_TEST : nvutil
  • TWCA_R : nvsg
  • TWCA_S : nvsg
  • TWCA_T : nvsg
  • TWM_CLAMP : nvsg
  • TWM_CLAMP_TO_BORDER : nvsg
  • TWM_CLAMP_TO_EDGE : nvsg
  • TWM_MIRROR_CLAMP : nvsg
  • TWM_MIRROR_CLAMP_TO_BORDER : nvsg
  • TWM_MIRROR_CLAMP_TO_EDGE : nvsg
  • TWM_MIRROR_REPEAT : nvsg
  • TWM_REPEAT : nvsg

- v -

  • VariantKey : nvsg

- w -

  • WGLBindSwapBarrierNV() : nvgl
  • WGLBindTexImage() : nvgl
  • WGLBindVideoImage() : nvgl
  • WGLChoosePixelFormat() : nvgl
  • WGLCreateAffinityDC() : nvgl
  • WGLCreateContext() : nvgl
  • WGLCreatePbuffer() : nvgl
  • WGLDeleteContext() : nvgl
  • WGLDeleteDC() : nvgl
  • WGLDestroyPbuffer() : nvgl
  • WGLEnumGpuDevices() : nvgl
  • WGLEnumGpus() : nvgl
  • WGLEnumGpusFromAffinityDC() : nvgl
  • WGLGetCurrentContext() : nvgl
  • WGLGetCurrentDC() : nvgl
  • WGLGetPbufferDC() : nvgl
  • WGLGetVideoDevice() : nvgl
  • WGLGetVideoInfo() : nvgl
  • WGLInitializeExtensions() : nvgl
  • WGLIsExtensionAvailable() : nvgl
  • WGLIsExtensionExported() : nvgl
  • WGLJoinSwapGroupNV() : nvgl
  • WGLQueryFrameCountNV() : nvgl
  • WGLQueryMaxSwapGroupsNV() : nvgl
  • WGLQueryPbuffer() : nvgl
  • WGLQuerySwapGroupNV() : nvgl
  • WGLReleasePbufferDC() : nvgl
  • WGLReleaseTexImage() : nvgl
  • WGLReleaseVideoDevice() : nvgl
  • WGLReleaseVideoImage() : nvgl
  • WGLResetFrameCountNV() : nvgl
  • WGLSendPbufferToVideo() : nvgl
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values

  • AlphaFunction : nvsg
  • BlendFunction : nvsg
  • CullCode : nvsg
  • DepthFunction : nvsg
  • MapAlignment : nvsg
  • MapOrientation : nvsg
  • MapRelation : nvsg
  • MapTraversalDirection : nvsg
  • MaterialFace : nvsg
  • TESTMODE : nvutil
  • TexCoordAxis : nvsg
  • TexGenLinearPlane : nvsg
  • TexGenMode : nvsg
  • TextureCoordType : nvsg
  • TextureEnvMode : nvsg
  • TextureEnvScale : nvsg
  • TextureMagFilterMode : nvsg
  • TextureMinFilterMode : nvsg
  • TextureTarget : nvsg
  • TextureWrapMode : nvsg
  • TexWrapCoordAxis : nvsg
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values
b | c | m | n | o | t

- b -

  • BF_DESTINATION_ALPHA : nvsg
  • BF_DESTINATION_COLOR : nvsg
  • BF_ONE : nvsg
  • BF_ONE_MINUS_DESTINATION_ALPHA : nvsg
  • BF_ONE_MINUS_DESTINATION_COLOR : nvsg
  • BF_ONE_MINUS_SOURCE_ALPHA : nvsg
  • BF_ONE_MINUS_SOURCE_COLOR : nvsg
  • BF_SOURCE_ALPHA : nvsg
  • BF_SOURCE_ALPHA_SATURATE : nvsg
  • BF_SOURCE_COLOR : nvsg
  • BF_ZERO : nvsg

- c -

  • CC_IN : nvsg
  • CC_OUT : nvsg
  • CC_PART : nvsg

- m -

  • MA_CENTER : nvsg
  • MA_LOWER : nvsg
  • MA_UPPER : nvsg
  • MF_BACK : nvsg
  • MF_FRONT : nvsg
  • MF_FRONT_AND_BACK : nvsg
  • MO_HORIZONTAL : nvsg
  • MO_VERTICAL : nvsg
  • MR_CENTER : nvsg
  • MR_CENTER_LEFT : nvsg
  • MR_CENTER_RIGHT : nvsg
  • MR_LOWER_CENTER : nvsg
  • MR_LOWER_LEFT : nvsg
  • MR_LOWER_RIGHT : nvsg
  • MR_UPPER_CENTER : nvsg
  • MR_UPPER_LEFT : nvsg
  • MR_UPPER_RIGHT : nvsg
  • MTD_HIGH_TO_LOW : nvsg
  • MTD_LOW_TO_HIGH : nvsg

- n -

  • NVSG_TEXTURE_1D : nvsg
  • NVSG_TEXTURE_1D_ARRAY : nvsg
  • NVSG_TEXTURE_2D : nvsg
  • NVSG_TEXTURE_2D_ARRAY : nvsg
  • NVSG_TEXTURE_3D : nvsg
  • NVSG_TEXTURE_CUBE : nvsg
  • NVSG_TEXTURE_RECTANGLE : nvsg
  • NVSG_TEXTURE_TARGET_COUNT : nvsg
  • NVSG_UNSPECIFIED_TEXTURE_TARGET : nvsg

- o -

  • OC_ALPHATESTATTRIBUTE : nvsg
  • OC_ANIMATED_VERTEX_ATTRIBUTE_SET : nvsg
  • OC_ANIMATEDTRANSFORM : nvsg
  • OC_ANIMATION : nvsg
  • OC_BILLBOARD : nvsg
  • OC_BITMAP : nvsg
  • OC_BLENDATTRIBUTE : nvsg
  • OC_CAMERA : nvsg
  • OC_CGFX : nvsg
  • OC_CUSTOMOBJECT : nvsg
  • OC_DEPTHATTRIBUTE : nvsg
  • OC_DIRECTEDLIGHT : nvsg
  • OC_DRAWABLES : nvsg
  • OC_FACEATTRIBUTE : nvsg
  • OC_FLIPBOOKANIMATION : nvsg
  • OC_FRAMEDINDEXANIMATION : nvsg
  • OC_FRAMEDTRAFOANIMATION : nvsg
  • OC_FRAMEDVERTEXATTRIBUTEANIMATION : nvsg
  • OC_GEONODE : nvsg
  • OC_GROUP : nvsg
  • OC_HIGHLIGHTBOX : nvsg
  • OC_HIGHLIGHTEDGES : nvsg
  • OC_HIGHLIGHTOBJECT : nvsg
  • OC_INVALID : nvsg
  • OC_LIGHTINGATTRIBUTE : nvsg
  • OC_LINEARINTERPOLATEDTRAFOANIMATION : nvsg
  • OC_LINEARINTERPOLATEDVERTEXATTRIBUTEANIMATION : nvsg
  • OC_LINEATTRIBUTE : nvsg
  • OC_LINES : nvsg
  • OC_LINESTRIPS : nvsg
  • OC_LOD : nvsg
  • OC_MAPARRAY : nvsg
  • OC_MAPELEMENT : nvsg
  • OC_MAPLIST : nvsg
  • OC_MAPMATRIX : nvsg
  • OC_MATERIAL : nvsg
  • OC_NODE : nvsg
  • OC_OBJECT : nvsg
  • OC_PARALLELCAMERA : nvsg
  • OC_PERSPECTIVECAMERA : nvsg
  • OC_PIXMAP : nvsg
  • OC_POINTATTRIBUTE : nvsg
  • OC_POINTLIGHT : nvsg
  • OC_POINTS : nvsg
  • OC_QUADMESHES : nvsg
  • OC_QUADS : nvsg
  • OC_QUADSTRIPS : nvsg
  • OC_SHAPE : nvsg
  • OC_SKIN : nvsg
  • OC_SKINNEDTRIANGLES : nvsg
  • OC_SPOTLIGHT : nvsg
  • OC_STATEATTRIBUTE : nvsg
  • OC_STATEPASS : nvsg
  • OC_STATESET : nvsg
  • OC_STATESETEXT : nvsg
  • OC_STATEVARIANT : nvsg
  • OC_SWITCH : nvsg
  • OC_TEXTUREATTRIBUTE : nvsg
  • OC_TEXTUREATTRIBUTEITEM : nvsg
  • OC_TRANSFORM : nvsg
  • OC_TRIANGLES : nvsg
  • OC_TRIFANS : nvsg
  • OC_TRISTRIPS : nvsg
  • OC_UNLITCOLORATTRIBUTE : nvsg
  • OC_VERTEX_ATTRIBUTE_SET : nvsg
  • OC_VOLUMEBRICK : nvsg
  • OC_VOLUMENODE : nvsg

- t -

  • TCA_Q : nvsg
  • TCA_R : nvsg
  • TCA_S : nvsg
  • TCA_T : nvsg
  • TCT_CYLINDRICAL : nvsg
  • TCT_PLANAR : nvsg
  • TCT_SPHERICAL : nvsg
  • TEM_ADD : nvsg
  • TEM_ADD_SIGNED : nvsg
  • TEM_BLEND : nvsg
  • TEM_DECAL : nvsg
  • TEM_DOT3_RGB : nvsg
  • TEM_DOT3_RGBA : nvsg
  • TEM_INTERPOLATE : nvsg
  • TEM_MODULATE : nvsg
  • TEM_REPLACE : nvsg
  • TEM_SUBTRACT : nvsg
  • TES_1X : nvsg
  • TES_2X : nvsg
  • TES_4X : nvsg
  • TFM_MAG_BILINEAR : nvsg
  • TFM_MAG_LINEAR : nvsg
  • TFM_MAG_NEAREST : nvsg
  • TFM_MIN_BILINEAR : nvsg
  • TFM_MIN_LINEAR : nvsg
  • TFM_MIN_LINEAR_MIPMAP_LINEAR : nvsg
  • TFM_MIN_LINEAR_MIPMAP_NEAREST : nvsg
  • TFM_MIN_NEAREST : nvsg
  • TFM_MIN_NEAREST_MIPMAP_LINEAR : nvsg
  • TFM_MIN_NEAREST_MIPMAP_NEAREST : nvsg
  • TFM_MIN_TRILINEAR : nvsg
  • TGLP_EYE : nvsg
  • TGLP_OBJECT : nvsg
  • TGLP_OBJECT_AND_EYE : nvsg
  • TGM_EYE_LINEAR : nvsg
  • TGM_NORMAL_MAP : nvsg
  • TGM_OBJECT_LINEAR : nvsg
  • TGM_OFF : nvsg
  • TGM_REFLECTION_MAP : nvsg
  • TGM_SPHERE_MAP : nvsg
  • TM_NONE : nvutil
  • TM_TEST : nvutil
  • TWCA_R : nvsg
  • TWCA_S : nvsg
  • TWCA_T : nvsg
  • TWM_CLAMP : nvsg
  • TWM_CLAMP_TO_BORDER : nvsg
  • TWM_CLAMP_TO_EDGE : nvsg
  • TWM_MIRROR_CLAMP : nvsg
  • TWM_MIRROR_CLAMP_TO_BORDER : nvsg
  • TWM_MIRROR_CLAMP_TO_EDGE : nvsg
  • TWM_MIRROR_REPEAT : nvsg
  • TWM_REPEAT : nvsg
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values
a | b | c | d | e | f | g | h | i | l | m | n | o | p | r | s | t | w

- a -

  • areCollinear() : nvmath
  • areOfSameType() : nvsg
  • areOnOppositeSides() : nvmath
  • areOnSameSide() : nvmath
  • areOpposite() : nvmath
  • areOrthogonal() : nvmath
  • areOrthonormal() : nvmath
  • areSimilar() : nvmath
  • assertMipMapChainComplete() : nvsg
  • attribIndex() : nvsg

- b -

  • boundingBox() : nvmath
  • boundingSphere() : nvmath

- c -

  • calculateContributions() : nvsg
  • cgfxContext() : nvsg
  • clamp() : nvmath
  • compare() : nvmath
  • convertPixelFormat() : nvsg
  • createClipPlanesElement() : nvtraverser
  • createHighlightElement() : nvtraverser
  • createLightsElement() : nvtraverser
  • createRenderElement() : nvtraverser
  • createTransformElement() : nvtraverser

- d -

  • dbgAllocImagePixels() : nvsg
  • decompose() : nvmath
  • degToRad() : nvmath
  • determinant() : nvmath
  • determinePixelFormat() : nvui
  • determineTextureTarget() : nvsg
  • distance() : nvmath

- e -

  • EnableLocking() : nvutil
  • equal3f() : nvgl
  • equal3fv() : nvgl
  • equal4f() : nvgl
  • equal4fv() : nvgl
  • equalf() : nvgl
  • errorMessage() : nvutil::IO

- f -

  • FileExists() : nvutil
  • FileSize() : nvutil
  • FindFile() : nvutil
  • FindFileFirst() : nvutil
  • freeImagePixels() : nvsg

- g -

  • genericAttrib() : nvsg
  • getBoundingSphere() : nvsg
  • getCopyrightString() : nvsg
  • GetCurrentDir() : nvutil
  • GetDirFromPath() : nvutil
  • GetDrvAndDirFromPath() : nvutil
  • GetDrvFromPath() : nvutil
  • GetFileExtFromPath() : nvutil
  • GetFileNameFromPath() : nvutil
  • GetModulePath() : nvutil
  • getSDKName() : nvsg
  • getSubBrickPosition() : nvsg
  • getSupportedFeatures() : nvsg
  • getVendorName() : nvsg
  • getVersionString() : nvsg
  • GLAccum() : nvgl
  • GLActiveStencilFace() : nvgl
  • GLActiveTexture() : nvgl
  • GLActiveVarying() : nvgl
  • GLAddSwapHintRect() : nvgl
  • GLAlphaFunc() : nvgl
  • GLAreProgramsResident() : nvgl
  • GLAreTexturesResident() : nvgl
  • GLArrayElement() : nvgl
  • GLAttachObject() : nvgl
  • GLAttachShader() : nvgl
  • GLBegin() : nvgl
  • GLBeginOcclusionQuery() : nvgl
  • GLBeginQuery() : nvgl
  • GLBeginTransformFeedback() : nvgl
  • GLBindArraySet() : nvgl
  • GLBindAttribLocation() : nvgl
  • GLBindBuffer() : nvgl
  • GLBindBufferBase() : nvgl
  • GLBindBufferOffset() : nvgl
  • GLBindBufferRange() : nvgl
  • GLBindFragDataLocation() : nvgl
  • GLBindFramebuffer() : nvgl
  • GLBindIndexBuffer() : nvgl
  • GLBindProgram() : nvgl
  • GLBindRenderbuffer() : nvgl
  • GLBindTexture() : nvgl
  • GLBindTransformFeedbackBuffer() : nvgl
  • GLBindVertexBuffer() : nvgl
  • GLBitmap() : nvgl
  • GLBlendColor() : nvgl
  • GLBlendEquation() : nvgl
  • GLBlendEquationSeparate() : nvgl
  • GLBlendFunc() : nvgl
  • GLBlendFuncSeparate() : nvgl
  • GLBlitFramebuffer() : nvgl
  • GLBufferData() : nvgl
  • GLBufferSubData() : nvgl
  • GLBuildVertexBufferCache() : nvgl
  • GLCallList() : nvgl
  • GLCallLists() : nvgl
  • GLCheckFramebufferStatus() : nvgl
  • GLClampColor() : nvgl
  • GLClear() : nvgl
  • GLClearAccum() : nvgl
  • GLClearColor() : nvgl
  • GLClearColorIi() : nvgl
  • GLClearColorIui() : nvgl
  • GLClearDepth() : nvgl
  • GLClearDepthd() : nvgl
  • GLClearIndex() : nvgl
  • GLClearStencil() : nvgl
  • GLClientActiveTexture() : nvgl
  • GLClipPlane() : nvgl
  • GLColor3b() : nvgl
  • GLColor3bv() : nvgl
  • GLColor3d() : nvgl
  • GLColor3dv() : nvgl
  • GLColor3f() : nvgl
  • GLColor3fv() : nvgl
  • GLColor3h() : nvgl
  • GLColor3hv() : nvgl
  • GLColor3i() : nvgl
  • GLColor3iv() : nvgl
  • GLColor3s() : nvgl
  • GLColor3sv() : nvgl
  • GLColor3ub() : nvgl
  • GLColor3ubv() : nvgl
  • GLColor3ui() : nvgl
  • GLColor3uiv() : nvgl
  • GLColor3us() : nvgl
  • GLColor3usv() : nvgl
  • GLColor4b() : nvgl
  • GLColor4bv() : nvgl
  • GLColor4d() : nvgl
  • GLColor4dv() : nvgl
  • GLColor4f() : nvgl
  • GLColor4fv() : nvgl
  • GLColor4h() : nvgl
  • GLColor4hv() : nvgl
  • GLColor4i() : nvgl
  • GLColor4iv() : nvgl
  • GLColor4s() : nvgl
  • GLColor4sv() : nvgl
  • GLColor4ub() : nvgl
  • GLColor4ubv() : nvgl
  • GLColor4ui() : nvgl
  • GLColor4uiv() : nvgl
  • GLColor4us() : nvgl
  • GLColor4usv() : nvgl
  • GLColorMask() : nvgl
  • GLColorMaskIndexed() : nvgl
  • GLColorMaterial() : nvgl
  • GLColorPointer() : nvgl
  • GLColorSubTable() : nvgl
  • GLColorTable() : nvgl
  • GLColorTableParameterfv() : nvgl
  • GLColorTableParameteriv() : nvgl
  • GLCombinerInput() : nvgl
  • GLCombinerOutput() : nvgl
  • GLCombinerParameterf() : nvgl
  • GLCombinerParameterfv() : nvgl
  • GLCombinerParameteri() : nvgl
  • GLCombinerParameteriv() : nvgl
  • GLCombinerStageParameterfv() : nvgl
  • GLCompileShader() : nvgl
  • GLCompressedTexImage1D() : nvgl
  • GLCompressedTexImage2D() : nvgl
  • GLCompressedTexImage3D() : nvgl
  • GLCompressedTexSubImage1D() : nvgl
  • GLCompressedTexSubImage2D() : nvgl
  • GLCompressedTexSubImage3D() : nvgl
  • glContext() : nvgl
  • GLConvolutionFilter1D() : nvgl
  • GLConvolutionFilter2D() : nvgl
  • GLConvolutionParameterf() : nvgl
  • GLConvolutionParameterfv() : nvgl
  • GLConvolutionParameteri() : nvgl
  • GLConvolutionParameteriv() : nvgl
  • GLCopyColorSubTable() : nvgl
  • GLCopyColorTable() : nvgl
  • GLCopyConvolutionFilter1D() : nvgl
  • GLCopyConvolutionFilter2D() : nvgl
  • GLCopyPixels() : nvgl
  • GLCopyTexImage1D() : nvgl
  • GLCopyTexImage2D() : nvgl
  • GLCopyTexSubImage1D() : nvgl
  • GLCopyTexSubImage2D() : nvgl
  • GLCopyTexSubImage3D() : nvgl
  • GLCreateProgram() : nvgl
  • GLCreateProgramObject() : nvgl
  • GLCreateShader() : nvgl
  • GLCreateShaderObject() : nvgl
  • GLCullFace() : nvgl
  • GLCullFaceLock() : nvgl
  • GLCullFaceUnlock() : nvgl
  • GLDeleteArraySets() : nvgl
  • GLDeleteBuffers() : nvgl
  • GLDeleteFences() : nvgl
  • GLDeleteFramebuffers() : nvgl
  • GLDeleteIndexBuffer() : nvgl
  • GLDeleteLists() : nvgl
  • GLDeleteObject() : nvgl
  • GLDeleteOcclusionQueries() : nvgl
  • GLDeleteProgram() : nvgl
  • GLDeletePrograms() : nvgl
  • GLDeleteQueries() : nvgl
  • GLDeleteRenderbuffers() : nvgl
  • GLDeleteShader() : nvgl
  • GLDeleteTextures() : nvgl
  • GLDeleteVertexBuffer() : nvgl
  • GLDepthBounds() : nvgl
  • GLDepthBoundsd() : nvgl
  • GLDepthFunc() : nvgl
  • GLDepthMask() : nvgl
  • GLDepthRange() : nvgl
  • GLDepthRanged() : nvgl
  • GLDetachObject() : nvgl
  • GLDetachShader() : nvgl
  • GLDisable() : nvgl
  • GLDisableAlphaTest() : nvgl
  • GLDisableAutoNormal() : nvgl
  • GLDisableBlend() : nvgl
  • GLDisableClientState() : nvgl
  • GLDisableClipPlane() : nvgl
  • GLDisableColorArray() : nvgl
  • GLDisableColorLogicOp() : nvgl
  • GLDisableColorMaterial() : nvgl
  • GLDisableCullFace() : nvgl
  • GLDisableCullFaceLock() : nvgl
  • GLDisableCullFaceUnlock() : nvgl
  • GLDisableDepthTest() : nvgl
  • GLDisableDither() : nvgl
  • GLDisableFog() : nvgl
  • GLDisableFogCoordinateArray() : nvgl
  • GLDisableIndexed() : nvgl
  • GLDisableLight() : nvgl
  • GLDisableLighting() : nvgl
  • GLDisableLightingLock() : nvgl
  • GLDisableLightingUnlock() : nvgl
  • GLDisableLineSmooth() : nvgl
  • GLDisableLineStipple() : nvgl
  • GLDisableLogicOp() : nvgl
  • GLDisableNormalArray() : nvgl
  • GLDisableNormalize() : nvgl
  • GLDisablePointSmooth() : nvgl
  • GLDisablePolygonOffsetFill() : nvgl
  • GLDisablePolygonOffsetLine() : nvgl
  • GLDisablePolygonOffsetPoint() : nvgl
  • GLDisablePolygonSmooth() : nvgl
  • GLDisablePolygonStipple() : nvgl
  • GLDisableScissorTest() : nvgl
  • GLDisableSecondaryColorArray() : nvgl
  • GLDisableStencilTest() : nvgl
  • GLDisableTexture() : nvgl
  • GLDisableTextureCoordArray() : nvgl
  • GLDisableTextureGen() : nvgl
  • GLDisableVertexArray() : nvgl
  • GLDisableVertexAttribArray() : nvgl
  • GLDrawArrays() : nvgl
  • GLDrawArraysInstanced() : nvgl
  • GLDrawBuffer() : nvgl
  • GLDrawBuffers() : nvgl
  • GLDrawElements() : nvgl
  • GLDrawElementsInstanced() : nvgl
  • GLDrawPixels() : nvgl
  • GLDrawRangeElements() : nvgl
  • GLEdgeFlag() : nvgl
  • GLEdgeFlagPointer() : nvgl
  • GLEdgeFlagv() : nvgl
  • GLEnable() : nvgl
  • GLEnableAlphaTest() : nvgl
  • GLEnableAutoNormal() : nvgl
  • GLEnableBlend() : nvgl
  • GLEnableClientState() : nvgl
  • GLEnableClipPlane() : nvgl
  • GLEnableColorArray() : nvgl
  • GLEnableColorLogicOp() : nvgl
  • GLEnableColorMaterial() : nvgl
  • GLEnableCullFace() : nvgl
  • GLEnableCullFaceLock() : nvgl
  • GLEnableCullFaceUnlock() : nvgl
  • GLEnableDepthTest() : nvgl
  • GLEnableDither() : nvgl
  • GLEnableFog() : nvgl
  • GLEnableFogCoordinateArray() : nvgl
  • GLEnableIndexed() : nvgl
  • GLEnableLight() : nvgl
  • GLEnableLighting() : nvgl
  • GLEnableLineSmooth() : nvgl
  • GLEnableLineStipple() : nvgl
  • GLEnableLogicOp() : nvgl
  • GLEnableNormalArray() : nvgl
  • GLEnableNormalize() : nvgl
  • GLEnablePointSmooth() : nvgl
  • GLEnablePolygonOffsetFill() : nvgl
  • GLEnablePolygonOffsetLine() : nvgl
  • GLEnablePolygonOffsetPoint() : nvgl
  • GLEnablePolygonSmooth() : nvgl
  • GLEnablePolygonStipple() : nvgl
  • GLEnableScissorTest() : nvgl
  • GLEnableSecondaryColorArray() : nvgl
  • GLEnableStencilTest() : nvgl
  • GLEnableTexture() : nvgl
  • GLEnableTextureCoordArray() : nvgl
  • GLEnableTextureGen() : nvgl
  • GLEnableVertexArray() : nvgl
  • GLEnableVertexAttribArray() : nvgl
  • GLEnd() : nvgl
  • GLEndList() : nvgl
  • GLEndOcclusionQuery() : nvgl
  • GLEndQuery() : nvgl
  • GLEndTransformFeedback() : nvgl
  • GLEvalCoord1d() : nvgl
  • GLEvalCoord1f() : nvgl
  • GLEvalCoord2d() : nvgl
  • GLEvalCoord2f() : nvgl
  • GLEvalMesh1() : nvgl
  • GLEvalMesh2() : nvgl
  • GLEvalPoint1() : nvgl
  • GLEvalPoint2() : nvgl
  • GLExecuteProgram() : nvgl
  • GLFeedbackBuffer() : nvgl
  • GLFinalCombinerInput() : nvgl
  • GLFinish() : nvgl
  • GLFinishFence() : nvgl
  • GLFlush() : nvgl
  • GLFlushPixelDataRange() : nvgl
  • GLFlushVertexArrayRange() : nvgl
  • GLFogColor() : nvgl
  • GLFogCoordd() : nvgl
  • GLFogCoorddv() : nvgl
  • GLFogCoordf() : nvgl
  • GLFogCoordfv() : nvgl
  • GLFogCoordh() : nvgl
  • GLFogCoordhv() : nvgl
  • GLFogCoordPointer() : nvgl
  • GLFogDensity() : nvgl
  • GLFogEnd() : nvgl
  • GLFogf() : nvgl
  • GLFogfv() : nvgl
  • GLFogi() : nvgl
  • GLFogiv() : nvgl
  • GLFogMode() : nvgl
  • GLFogStart() : nvgl
  • GLFramebufferRenderbuffer() : nvgl
  • GLFramebufferTexture() : nvgl
  • GLFramebufferTexture1D() : nvgl
  • GLFramebufferTexture2D() : nvgl
  • GLFramebufferTexture3D() : nvgl
  • GLFramebufferTextureFace() : nvgl
  • GLFramebufferTextureLayer() : nvgl
  • GLFrameTerminator() : nvgl
  • GLFrontFace() : nvgl
  • GLFrustum() : nvgl
  • GLGenArraySets() : nvgl
  • GLGenBuffers() : nvgl
  • GLGenerateMipmap() : nvgl
  • GLGenFences() : nvgl
  • GLGenFramebuffers() : nvgl
  • GLGenIndexBuffer() : nvgl
  • GLGenLists() : nvgl
  • GLGenOcclusionQueries() : nvgl
  • GLGenPrograms() : nvgl
  • GLGenQueries() : nvgl
  • GLGenRenderbuffers() : nvgl
  • GLGenTextures() : nvgl
  • GLGenVertexBuffer() : nvgl
  • GLGetActiveAttrib() : nvgl
  • GLGetActiveUniform() : nvgl
  • GLGetActiveVarying() : nvgl
  • GLGetAttachedObjects() : nvgl
  • GLGetAttachedShaders() : nvgl
  • GLGetAttribLocation() : nvgl
  • GLGetBooleanIndexedv() : nvgl
  • GLGetBooleanv() : nvgl
  • GLGetBufferParameteriv() : nvgl
  • GLGetBufferPointerv() : nvgl
  • GLGetBufferSubData() : nvgl
  • GLGetClipPlane() : nvgl
  • GLGetColorTable() : nvgl
  • GLGetColorTableParameterfv() : nvgl
  • GLGetColorTableParameteriv() : nvgl
  • GLGetCombinerInputParameterfv() : nvgl
  • GLGetCombinerInputParameteriv() : nvgl
  • GLGetCombinerOutputParameterfv() : nvgl
  • GLGetCombinerOutputParameteriv() : nvgl
  • GLGetCombinerStageParameterfv() : nvgl
  • GLGetCompressedTexImage() : nvgl
  • GLGetConvolutionFilter() : nvgl
  • GLGetConvolutionParameterfv() : nvgl
  • GLGetConvolutionParameteriv() : nvgl
  • GLGetDoublev() : nvgl
  • GLGetFenceiv() : nvgl
  • GLGetFinalCombinerInputParameterfv() : nvgl
  • GLGetFinalCombinerInputParameteriv() : nvgl
  • GLGetFloatv() : nvgl
  • GLGetFragDataLocation() : nvgl
  • GLGetFramebufferAttachmentParameteriv() : nvgl
  • GLGetHandle() : nvgl
  • GLGetHistogram() : nvgl
  • GLGetHistogramParameterfv() : nvgl
  • GLGetHistogramParameteriv() : nvgl
  • GLGetIndexBufferOffset() : nvgl
  • GLGetInfoLog() : nvgl
  • GLGetIntegerIndexedv() : nvgl
  • GLGetIntegerv() : nvgl
  • GLGetLightfv() : nvgl
  • GLGetLightiv() : nvgl
  • GLGetMapdv() : nvgl
  • GLGetMapfv() : nvgl
  • GLGetMapiv() : nvgl
  • GLGetMaterialfv() : nvgl
  • GLGetMaterialiv() : nvgl
  • GLGetMaxTexCoords() : nvgl
  • GLGetMaxTexImageUnits() : nvgl
  • GLGetMaxTexUnits() : nvgl
  • GLGetMinmax() : nvgl
  • GLGetMinmaxParameterfv() : nvgl
  • GLGetMinmaxParameteriv() : nvgl
  • GLGetObjectParameterfv() : nvgl
  • GLGetObjectParameteriv() : nvgl
  • GLGetOcclusionQueryiv() : nvgl
  • GLGetOcclusionQueryuiv() : nvgl
  • GLGetPixelMapfv() : nvgl
  • GLGetPixelMapuiv() : nvgl
  • GLGetPixelMapusv() : nvgl
  • GLGetPointerv() : nvgl
  • GLGetPolygonStipple() : nvgl
  • GLGetProgramEnvParameterdv() : nvgl
  • GLGetProgramEnvParameterfv() : nvgl
  • GLGetProgramEnvParameterIiv() : nvgl
  • GLGetProgramEnvParameterIuiv() : nvgl
  • GLGetProgramInfoLog() : nvgl
  • GLGetProgramiv() : nvgl
  • GLGetProgramLocalParameterdv() : nvgl
  • GLGetProgramLocalParameterfv() : nvgl
  • GLGetProgramLocalParameterIiv() : nvgl
  • GLGetProgramLocalParameterIuiv() : nvgl
  • GLGetProgramNamedParameterdv() : nvgl
  • GLGetProgramNamedParameterfv() : nvgl
  • GLGetProgramParameterdv() : nvgl
  • GLGetProgramParameterfv() : nvgl
  • GLGetProgramString() : nvgl
  • GLGetQueryiv() : nvgl
  • GLGetQueryObjecti64v() : nvgl
  • GLGetQueryObjectiv() : nvgl
  • GLGetQueryObjectui64v() : nvgl
  • GLGetQueryObjectuiv() : nvgl
  • GLGetRenderbufferParameteriv() : nvgl
  • GLGetSeparableFilter() : nvgl
  • GLGetShaderInfoLog() : nvgl
  • GLGetShaderiv() : nvgl
  • GLGetShaderSource() : nvgl
  • GLGetString() : nvgl
  • GLGetTexEnvfv() : nvgl
  • GLGetTexEnviv() : nvgl
  • GLGetTexGendv() : nvgl
  • GLGetTexGenfv() : nvgl
  • GLGetTexGeniv() : nvgl
  • GLGetTexImage() : nvgl
  • GLGetTexLevelParameterfv() : nvgl
  • GLGetTexLevelParameteriv() : nvgl
  • GLGetTexParameterfv() : nvgl
  • GLGetTexParameterIiv() : nvgl
  • GLGetTexParameterIuiv() : nvgl
  • GLGetTexParameteriv() : nvgl
  • GLGetTexWrapMode() : nvgl
  • GLGetTrackMatrixiv() : nvgl
  • GLGetTransformFeedbackVarying() : nvgl
  • GLGetUniformBufferSize() : nvgl
  • GLGetUniformfv() : nvgl
  • GLGetUniformiv() : nvgl
  • GLGetUniformLocation() : nvgl
  • GLGetUniformOffset() : nvgl
  • GLGetUniformuiv() : nvgl
  • GLGetVaryingLocation() : nvgl
  • GLGetVersion() : nvgl
  • GLGetVertexAttribdv() : nvgl
  • GLGetVertexAttribfv() : nvgl
  • GLGetVertexAttribIiv() : nvgl
  • GLGetVertexAttribIuiv() : nvgl
  • GLGetVertexAttribiv() : nvgl
  • GLGetVertexAttribPointerv() : nvgl
  • GLGetVertexBufferOffset() : nvgl
  • GLHint() : nvgl
  • GLHistogram() : nvgl
  • GLIndexd() : nvgl
  • GLIndexf() : nvgl
  • GLIndexi() : nvgl
  • GLIndexMask() : nvgl
  • GLIndexPointer() : nvgl
  • GLIndexs() : nvgl
  • GLIndexub() : nvgl
  • GLInitNames() : nvgl
  • GLInterleavedArrays() : nvgl
  • GLintToGLfloat() : nvgl
  • GLIsArraySet() : nvgl
  • GLIsBuffer() : nvgl
  • GLIsEnabled() : nvgl
  • GLIsEnabledAlphaTest() : nvgl
  • GLIsEnabledAutoNormal() : nvgl
  • GLIsEnabledBlend() : nvgl
  • GLIsEnabledClipPlane() : nvgl
  • GLIsEnabledColorLogicOp() : nvgl
  • GLIsEnabledColorMaterial() : nvgl
  • GLIsEnabledCullFace() : nvgl
  • GLIsEnabledDepthTest() : nvgl
  • GLIsEnabledDither() : nvgl
  • GLIsEnabledFog() : nvgl
  • GLIsEnabledIndexed() : nvgl
  • GLIsEnabledLight() : nvgl
  • GLIsEnabledLighting() : nvgl
  • GLIsEnabledLineSmooth() : nvgl
  • GLIsEnabledLineStipple() : nvgl
  • GLIsEnabledLogicOp() : nvgl
  • GLIsEnabledNormalize() : nvgl
  • GLIsEnabledPointSmooth() : nvgl
  • GLIsEnabledPolygonOffsetFill() : nvgl
  • GLIsEnabledPolygonOffsetLine() : nvgl
  • GLIsEnabledPolygonOffsetPoint() : nvgl
  • GLIsEnabledPolygonSmooth() : nvgl
  • GLIsEnabledPolygonStipple() : nvgl
  • GLIsEnabledScissorTest() : nvgl
  • GLIsEnabledStencilTest() : nvgl
  • GLIsEnabledTexture() : nvgl
  • GLIsEnabledTextureGen() : nvgl
  • GLIsExtensionAvailable() : nvgl
  • GLIsExtensionExported() : nvgl
  • GLIsFence() : nvgl
  • GLIsFramebuffer() : nvgl
  • GLIsIndexBuffer() : nvgl
  • GLIsList() : nvgl
  • GLIsOcclusionQuery() : nvgl
  • GLIsProgram() : nvgl
  • GLIsQuery() : nvgl
  • GLIsRenderbuffer() : nvgl
  • GLIsShader() : nvgl
  • GLIsTexture() : nvgl
  • GLIsVertexBuffer() : nvgl
  • GLLightAmbient() : nvgl
  • GLLightConstantAttenuation() : nvgl
  • GLLightDiffuse() : nvgl
  • GLLightf() : nvgl
  • GLLightfv() : nvgl
  • GLLighti() : nvgl
  • GLLightiv() : nvgl
  • GLLightLinearAttenuation() : nvgl
  • GLLightModelAmbient() : nvgl
  • GLLightModelf() : nvgl
  • GLLightModelfv() : nvgl
  • GLLightModeli() : nvgl
  • GLLightModeliv() : nvgl
  • GLLightModelLocalViewer() : nvgl
  • GLLightModelTwoSide() : nvgl
  • GLLightModelTwoSideLock() : nvgl
  • GLLightModelTwoSideUnlock() : nvgl
  • GLLightPosition() : nvgl
  • GLLightQuadraticAttenuation() : nvgl
  • GLLightSpecular() : nvgl
  • GLLightSpotCutoff() : nvgl
  • GLLightSpotDirection() : nvgl
  • GLLightSpotExponent() : nvgl
  • GLLineStipple() : nvgl
  • GLLineWidth() : nvgl
  • GLLinkProgram() : nvgl
  • GLListBase() : nvgl
  • GLLoadIdentity() : nvgl
  • GLLoadMatrixd() : nvgl
  • GLLoadMatrixf() : nvgl
  • GLLoadName() : nvgl
  • GLLoadProgram() : nvgl
  • GLLoadTransposedMatrixd() : nvgl
  • GLLoadTransposeMatrixf() : nvgl
  • GLLockArrays() : nvgl
  • GLLogicOp() : nvgl
  • GLMap1d() : nvgl
  • GLMap1f() : nvgl
  • GLMap2d() : nvgl
  • GLMap2f() : nvgl
  • GLMapBuffer() : nvgl
  • GLMapGrid1d() : nvgl
  • GLMapGrid1f() : nvgl
  • GLMapGrid2d() : nvgl
  • GLMapGrid2f() : nvgl
  • GLMapIndexBuffer() : nvgl
  • GLMapVertexBuffer() : nvgl
  • GLMaterialAmbient() : nvgl
  • GLMaterialAmbientBack() : nvgl
  • GLMaterialAmbientFront() : nvgl
  • GLMaterialAmbientFrontAndBack() : nvgl
  • GLMaterialDiffuse() : nvgl
  • GLMaterialDiffuseBack() : nvgl
  • GLMaterialDiffuseFront() : nvgl
  • GLMaterialDiffuseFrontAndBack() : nvgl
  • GLMaterialEmission() : nvgl
  • GLMaterialEmissionBack() : nvgl
  • GLMaterialEmissionFront() : nvgl
  • GLMaterialEmissionFrontAndBack() : nvgl
  • GLMaterialf() : nvgl
  • GLMaterialfv() : nvgl
  • GLMateriali() : nvgl
  • GLMaterialiv() : nvgl
  • GLMaterialShininess() : nvgl
  • GLMaterialShininessBack() : nvgl
  • GLMaterialShininessFront() : nvgl
  • GLMaterialShininessFrontAndBack() : nvgl
  • GLMaterialSpecular() : nvgl
  • GLMaterialSpecularBack() : nvgl
  • GLMaterialSpecularFront() : nvgl
  • GLMaterialSpecularFrontAndBack() : nvgl
  • GLMatrixMode() : nvgl
  • GLMinmax() : nvgl
  • GLMultiDrawArrays() : nvgl
  • GLMultiDrawElements() : nvgl
  • GLMultiTexCoord1d() : nvgl
  • GLMultiTexCoord1dv() : nvgl
  • GLMultiTexCoord1f() : nvgl
  • GLMultiTexCoord1fv() : nvgl
  • GLMultiTexCoord1h() : nvgl
  • GLMultiTexCoord1hv() : nvgl
  • GLMultiTexCoord1i() : nvgl
  • GLMultiTexCoord1iv() : nvgl
  • GLMultiTexCoord1s() : nvgl
  • GLMultiTexCoord1sv() : nvgl
  • GLMultiTexCoord2d() : nvgl
  • GLMultiTexCoord2dv() : nvgl
  • GLMultiTexCoord2f() : nvgl
  • GLMultiTexCoord2fv() : nvgl
  • GLMultiTexCoord2h() : nvgl
  • GLMultiTexCoord2hv() : nvgl
  • GLMultiTexCoord2i() : nvgl
  • GLMultiTexCoord2iv() : nvgl
  • GLMultiTexCoord2s() : nvgl
  • GLMultiTexCoord2sv() : nvgl
  • GLMultiTexCoord3d() : nvgl
  • GLMultiTexCoord3dv() : nvgl
  • GLMultiTexCoord3f() : nvgl
  • GLMultiTexCoord3fv() : nvgl
  • GLMultiTexCoord3h() : nvgl
  • GLMultiTexCoord3hv() : nvgl
  • GLMultiTexCoord3i() : nvgl
  • GLMultiTexCoord3iv() : nvgl
  • GLMultiTexCoord3s() : nvgl
  • GLMultiTexCoord3sv() : nvgl
  • GLMultiTexCoord4d() : nvgl
  • GLMultiTexCoord4dv() : nvgl
  • GLMultiTexCoord4f() : nvgl
  • GLMultiTexCoord4fv() : nvgl
  • GLMultiTexCoord4h() : nvgl
  • GLMultiTexCoord4hv() : nvgl
  • GLMultiTexCoord4i() : nvgl
  • GLMultiTexCoord4iv() : nvgl
  • GLMultiTexCoord4s() : nvgl
  • GLMultiTexCoord4sv() : nvgl
  • GLMultiTexCoordPointer() : nvgl
  • GLMultMatrixd() : nvgl
  • GLMultMatrixf() : nvgl
  • GLMultTransposeMatrixd() : nvgl
  • GLMultTransposeMatrixf() : nvgl
  • GLNewList() : nvgl
  • GLNormal3b() : nvgl
  • GLNormal3bv() : nvgl
  • GLNormal3d() : nvgl
  • GLNormal3dv() : nvgl
  • GLNormal3f() : nvgl
  • GLNormal3fv() : nvgl
  • GLNormal3h() : nvgl
  • GLNormal3hv() : nvgl
  • GLNormal3i() : nvgl
  • GLNormal3iv() : nvgl
  • GLNormal3s() : nvgl
  • GLNormal3sv() : nvgl
  • GLNormalPointer() : nvgl
  • GLOrtho() : nvgl
  • GLPassThrough() : nvgl
  • GLPixelDataRange() : nvgl
  • GLPixelMapfv() : nvgl
  • GLPixelMapuiv() : nvgl
  • GLPixelMapusv() : nvgl
  • GLPixelStoref() : nvgl
  • GLPixelStorei() : nvgl
  • GLPixelTransferf() : nvgl
  • GLPixelTransferi() : nvgl
  • GLPixelZoom() : nvgl
  • GLPointParameterf() : nvgl
  • GLPointParameterfv() : nvgl
  • GLPointParameteri() : nvgl
  • GLPointParameteriv() : nvgl
  • GLPointSize() : nvgl
  • GLPolygonMode() : nvgl
  • GLPolygonModeBack() : nvgl
  • GLPolygonModeFront() : nvgl
  • GLPolygonModeFrontAndBack() : nvgl
  • GLPolygonModeLock() : nvgl
  • GLPolygonModeUnlock() : nvgl
  • GLPolygonOffset() : nvgl
  • GLPolygonStipple() : nvgl
  • GLPopAttrib() : nvgl
  • GLPopClientAttrib() : nvgl
  • GLPopMatrix() : nvgl
  • GLPopName() : nvgl
  • GLPrimitiveRestart() : nvgl
  • GLPrimitiveRestartIndex() : nvgl
  • GLPrioritizeTextures() : nvgl
  • GLProgramBufferParametersfv() : nvgl
  • GLProgramBufferParametersIiv() : nvgl
  • GLProgramBufferParametersIuiv() : nvgl
  • GLProgramEnvParameter4d() : nvgl
  • GLProgramEnvParameter4dv() : nvgl
  • GLProgramEnvParameter4f() : nvgl
  • GLProgramEnvParameter4fv() : nvgl
  • GLProgramEnvParameterI4i() : nvgl
  • GLProgramEnvParameterI4iv() : nvgl
  • GLProgramEnvParameterI4ui() : nvgl
  • GLProgramEnvParameterI4uiv() : nvgl
  • GLProgramEnvParameters4fv() : nvgl
  • GLProgramEnvParametersI4iv() : nvgl
  • GLProgramEnvParametersI4uiv() : nvgl
  • GLProgramLocalParameter4d() : nvgl
  • GLProgramLocalParameter4dv() : nvgl
  • GLProgramLocalParameter4f() : nvgl
  • GLProgramLocalParameter4fv() : nvgl
  • GLProgramLocalParameterI4i() : nvgl
  • GLProgramLocalParameterI4iv() : nvgl
  • GLProgramLocalParameterI4ui() : nvgl
  • GLProgramLocalParameterI4uiv() : nvgl
  • GLProgramLocalParameters4fv() : nvgl
  • GLProgramLocalParametersI4iv() : nvgl
  • GLProgramLocalParametersI4uiv() : nvgl
  • GLProgramNamedParameter4d() : nvgl
  • GLProgramNamedParameter4dv() : nvgl
  • GLProgramNamedParameter4f() : nvgl
  • GLProgramNamedParameter4fv() : nvgl
  • GLProgramParameter4d() : nvgl
  • GLProgramParameter4dv() : nvgl
  • GLProgramParameter4f() : nvgl
  • GLProgramParameter4fv() : nvgl
  • GLProgramParameteri() : nvgl
  • GLProgramParameters4dv() : nvgl
  • GLProgramParameters4fv() : nvgl
  • GLProgramString() : nvgl
  • GLProgramVertexLimit() : nvgl
  • GLPushAttrib() : nvgl
  • GLPushClientAttrib() : nvgl
  • GLPushMatrix() : nvgl
  • GLPushName() : nvgl
  • GLRasterPos2d() : nvgl
  • GLRasterPos2f() : nvgl
  • GLRasterPos2i() : nvgl
  • GLRasterPos2s() : nvgl
  • GLRasterPos3d() : nvgl
  • GLRasterPos3f() : nvgl
  • GLRasterPos3i() : nvgl
  • GLRasterPos3s() : nvgl
  • GLRasterPos4d() : nvgl
  • GLRasterPos4f() : nvgl
  • GLRasterPos4i() : nvgl
  • GLRasterPos4s() : nvgl
  • GLReadBuffer() : nvgl
  • GLReadPixels() : nvgl
  • GLRectd() : nvgl
  • GLRectf() : nvgl
  • GLRecti() : nvgl
  • GLRects() : nvgl
  • GLRenderbufferStorage() : nvgl
  • GLRenderbufferStorageMultisample() : nvgl
  • GLRenderbufferStorageMultisampleCoverage() : nvgl
  • GLRenderMode() : nvgl
  • GLRequestResidentPrograms() : nvgl
  • GLResetAlphaFunc() : nvgl
  • GLResetAlphaTest() : nvgl
  • GLResetAutoNormal() : nvgl
  • GLResetBlend() : nvgl
  • GLResetBlendFunc() : nvgl
  • GLResetBlendFuncSeparate() : nvgl
  • GLResetClearColor() : nvgl
  • GLResetClearDepth() : nvgl
  • GLResetClearStencil() : nvgl
  • GLResetClipPlane() : nvgl
  • GLResetClipPlaneEquation() : nvgl
  • GLResetColorLogicOp() : nvgl
  • GLResetColorMask() : nvgl
  • GLResetColorMaterial() : nvgl
  • GLResetColorMaterialMode() : nvgl
  • GLResetCullFace() : nvgl
  • GLResetCullFaceMode() : nvgl
  • GLResetDepthFunc() : nvgl
  • GLResetDepthMask() : nvgl
  • GLResetDepthRange() : nvgl
  • GLResetDepthTest() : nvgl
  • GLResetDither() : nvgl
  • GLResetFog() : nvgl
  • GLResetFogColor() : nvgl
  • GLResetFogDensity() : nvgl
  • GLResetFogEnd() : nvgl
  • GLResetFogMode() : nvgl
  • GLResetFogStart() : nvgl
  • GLResetFrontFace() : nvgl
  • GLResetHistogram() : nvgl
  • GLResetLight() : nvgl
  • GLResetLightAmbient() : nvgl
  • GLResetLightConstantAttenuation() : nvgl
  • GLResetLightDiffuse() : nvgl
  • GLResetLighting() : nvgl
  • GLResetLightLinearAttenuation() : nvgl
  • GLResetLightModelAmbient() : nvgl
  • GLResetLightModelLocalViewer() : nvgl
  • GLResetLightModelTwoSide() : nvgl
  • GLResetLightPosition() : nvgl
  • GLResetLightQuadraticAttenuation() : nvgl
  • GLResetLightSpecular() : nvgl
  • GLResetLightSpotCutoff() : nvgl
  • GLResetLightSpotDirection() : nvgl
  • GLResetLightSpotExponent() : nvgl
  • GLResetLineSmooth() : nvgl
  • GLResetLineStipple() : nvgl
  • GLResetLineStippleDefinition() : nvgl
  • GLResetLineWidth() : nvgl
  • GLResetLogicOp() : nvgl
  • GLResetMaterialAmbientBack() : nvgl
  • GLResetMaterialAmbientFront() : nvgl
  • GLResetMaterialAmbientFrontAndBack() : nvgl
  • GLResetMaterialDiffuseBack() : nvgl
  • GLResetMaterialDiffuseFront() : nvgl
  • GLResetMaterialDiffuseFrontAndBack() : nvgl
  • GLResetMaterialEmissionBack() : nvgl
  • GLResetMaterialEmissionFront() : nvgl
  • GLResetMaterialEmissionFrontAndBack() : nvgl
  • GLResetMaterialShininessBack() : nvgl
  • GLResetMaterialShininessFront() : nvgl
  • GLResetMaterialShininessFrontAndBack() : nvgl
  • GLResetMaterialSpecularBack() : nvgl
  • GLResetMaterialSpecularFront() : nvgl
  • GLResetMaterialSpecularFrontAndBack() : nvgl
  • GLResetMinmax() : nvgl
  • GLResetNormalize() : nvgl
  • GLResetPointSize() : nvgl
  • GLResetPointSmooth() : nvgl
  • GLResetPolygonModeBack() : nvgl
  • GLResetPolygonModeFront() : nvgl
  • GLResetPolygonModeFrontAndBack() : nvgl
  • GLResetPolygonOffset() : nvgl
  • GLResetPolygonOffsetFill() : nvgl
  • GLResetPolygonOffsetLine() : nvgl
  • GLResetPolygonOffsetPoint() : nvgl
  • GLResetPolygonSmooth() : nvgl
  • GLResetPolygonStipple() : nvgl
  • GLResetScissor() : nvgl
  • GLResetScissorTest() : nvgl
  • GLResetShadeModel() : nvgl
  • GLResetStencilFunc() : nvgl
  • GLResetStencilMask() : nvgl
  • GLResetStencilOp() : nvgl
  • GLResetStencilTest() : nvgl
  • GLResetTexture() : nvgl
  • GLRotated() : nvgl
  • GLRotatef() : nvgl
  • GLSampleCoverage() : nvgl
  • GLScaled() : nvgl
  • GLScalef() : nvgl
  • GLScissor() : nvgl
  • GLSecondaryColor3b() : nvgl
  • GLSecondaryColor3bv() : nvgl
  • GLSecondaryColor3d() : nvgl
  • GLSecondaryColor3dv() : nvgl
  • GLSecondaryColor3f() : nvgl
  • GLSecondaryColor3fv() : nvgl
  • GLSecondaryColor3h() : nvgl
  • GLSecondaryColor3hv() : nvgl
  • GLSecondaryColor3i() : nvgl
  • GLSecondaryColor3iv() : nvgl
  • GLSecondaryColor3s() : nvgl
  • GLSecondaryColor3sv() : nvgl
  • GLSecondaryColor3ub() : nvgl
  • GLSecondaryColor3ubv() : nvgl
  • GLSecondaryColor3ui() : nvgl
  • GLSecondaryColor3uiv() : nvgl
  • GLSecondaryColor3us() : nvgl
  • GLSecondaryColor3usv() : nvgl
  • GLSecondaryColorPointer() : nvgl
  • GLSelectBuffer() : nvgl
  • GLSelectTexture() : nvgl
  • GLSelectTextureCoordSet() : nvgl
  • GLSeparableFilter2D() : nvgl
  • GLSetFence() : nvgl
  • GLSetWindowStereoMode() : nvgl
  • GLShadeModel() : nvgl
  • GLShaderSource() : nvgl
  • GLStencilClearTag() : nvgl
  • GLStencilFunc() : nvgl
  • GLStencilFuncSeparate() : nvgl
  • GLStencilMask() : nvgl
  • GLStencilMaskSeparate() : nvgl
  • GLStencilOp() : nvgl
  • GLStencilOpSeparate() : nvgl
  • GLStringMarker() : nvgl
  • GLTestFence() : nvgl
  • GLTexBuffer() : nvgl
  • GLTexCoord1d() : nvgl
  • GLTexCoord1dv() : nvgl
  • GLTexCoord1f() : nvgl
  • GLTexCoord1fv() : nvgl
  • GLTexCoord1h() : nvgl
  • GLTexCoord1hv() : nvgl
  • GLTexCoord1i() : nvgl
  • GLTexCoord1iv() : nvgl
  • GLTexCoord1s() : nvgl
  • GLTexCoord1sv() : nvgl
  • GLTexCoord2d() : nvgl
  • GLTexCoord2dv() : nvgl
  • GLTexCoord2f() : nvgl
  • GLTexCoord2fv() : nvgl
  • GLTexCoord2h() : nvgl
  • GLTexCoord2hv() : nvgl
  • GLTexCoord2i() : nvgl
  • GLTexCoord2iv() : nvgl
  • GLTexCoord2s() : nvgl
  • GLTexCoord2sv() : nvgl
  • GLTexCoord3d() : nvgl
  • GLTexCoord3dv() : nvgl
  • GLTexCoord3f() : nvgl
  • GLTexCoord3fv() : nvgl
  • GLTexCoord3h() : nvgl
  • GLTexCoord3hv() : nvgl
  • GLTexCoord3i() : nvgl
  • GLTexCoord3iv() : nvgl
  • GLTexCoord3s() : nvgl
  • GLTexCoord3sv() : nvgl
  • GLTexCoord4d() : nvgl
  • GLTexCoord4dv() : nvgl
  • GLTexCoord4f() : nvgl
  • GLTexCoord4fv() : nvgl
  • GLTexCoord4h() : nvgl
  • GLTexCoord4hv() : nvgl
  • GLTexCoord4i() : nvgl
  • GLTexCoord4iv() : nvgl
  • GLTexCoord4s() : nvgl
  • GLTexCoord4sv() : nvgl
  • GLTexCoordPointer() : nvgl
  • GLTexEnvf() : nvgl
  • GLTexEnvfv() : nvgl
  • GLTexEnvi() : nvgl
  • GLTexEnviv() : nvgl
  • GLTexGend() : nvgl
  • GLTexGenf() : nvgl
  • GLTexGenfv() : nvgl
  • GLTexGeni() : nvgl
  • GLTexImage1D() : nvgl
  • GLTexImage2D() : nvgl
  • GLTexImage3D() : nvgl
  • GLTexParameterf() : nvgl
  • GLTexParameterfv() : nvgl
  • GLTexParameteri() : nvgl
  • GLTexParameterIiv() : nvgl
  • GLTexParameterIuiv() : nvgl
  • GLTexParameteriv() : nvgl
  • GLTexSubImage1D() : nvgl
  • GLTexSubImage2D() : nvgl
  • GLTexSubImage3D() : nvgl
  • GLTextureBorderColor() : nvgl
  • GLTextureEnvColor() : nvgl
  • GLTextureEnvMode() : nvgl
  • GLTextureMagFilter() : nvgl
  • GLTextureMinFilter() : nvgl
  • GLTextureWrapR() : nvgl
  • GLTextureWrapS() : nvgl
  • GLTextureWrapT() : nvgl
  • GLTrackMatrix() : nvgl
  • GLTransformFeedbackAttribs() : nvgl
  • GLTransformFeedbackVaryings() : nvgl
  • GLTranslated() : nvgl
  • GLTranslatef() : nvgl
  • GLUniform1f() : nvgl
  • GLUniform1fv() : nvgl
  • GLUniform1i() : nvgl
  • GLUniform1iv() : nvgl
  • GLUniform1ui() : nvgl
  • GLUniform1uiv() : nvgl
  • GLUniform2f() : nvgl
  • GLUniform2fv() : nvgl
  • GLUniform2i() : nvgl
  • GLUniform2iv() : nvgl
  • GLUniform2ui() : nvgl
  • GLUniform2uiv() : nvgl
  • GLUniform3f() : nvgl
  • GLUniform3fv() : nvgl
  • GLUniform3i() : nvgl
  • GLUniform3iv() : nvgl
  • GLUniform3ui() : nvgl
  • GLUniform3uiv() : nvgl
  • GLUniform4f() : nvgl
  • GLUniform4fv() : nvgl
  • GLUniform4i() : nvgl
  • GLUniform4iv() : nvgl
  • GLUniform4ui() : nvgl
  • GLUniform4uiv() : nvgl
  • GLUniformBuffer() : nvgl
  • GLUniformMatrix2fv() : nvgl
  • GLUniformMatrix2x3fv() : nvgl
  • GLUniformMatrix2x4fv() : nvgl
  • GLUniformMatrix3fv() : nvgl
  • GLUniformMatrix3x2fv() : nvgl
  • GLUniformMatrix3x4fv() : nvgl
  • GLUniformMatrix4fv() : nvgl
  • GLUniformMatrix4x2fv() : nvgl
  • GLUniformMatrix4x3fv() : nvgl
  • GLUnlockArrays() : nvgl
  • GLUnmapBuffer() : nvgl
  • GLUnmapIndexBuffer() : nvgl
  • GLUnmapVertexBuffer() : nvgl
  • GLUploadBuffers() : nvgl
  • GLUseProgram() : nvgl
  • GLUseProgramObject() : nvgl
  • GLValidateProgram() : nvgl
  • GLValidBackBufferHint() : nvgl
  • GLVertex2d() : nvgl
  • GLVertex2dv() : nvgl
  • GLVertex2f() : nvgl
  • GLVertex2fv() : nvgl
  • GLVertex2h() : nvgl
  • GLVertex2hv() : nvgl
  • GLVertex2i() : nvgl
  • GLVertex2iv() : nvgl
  • GLVertex2s() : nvgl
  • GLVertex2sv() : nvgl
  • GLVertex3d() : nvgl
  • GLVertex3dv() : nvgl
  • GLVertex3f() : nvgl
  • GLVertex3fv() : nvgl
  • GLVertex3h() : nvgl
  • GLVertex3hv() : nvgl
  • GLVertex3i() : nvgl
  • GLVertex3iv() : nvgl
  • GLVertex3s() : nvgl
  • GLVertex3sv() : nvgl
  • GLVertex4d() : nvgl
  • GLVertex4dv() : nvgl
  • GLVertex4f() : nvgl
  • GLVertex4fv() : nvgl
  • GLVertex4h() : nvgl
  • GLVertex4hv() : nvgl
  • GLVertex4i() : nvgl
  • GLVertex4iv() : nvgl
  • GLVertex4s() : nvgl
  • GLVertex4sv() : nvgl
  • GLVertexArrayRange() : nvgl
  • GLVertexAttrib1d() : nvgl
  • GLVertexAttrib1dv() : nvgl
  • GLVertexAttrib1f() : nvgl
  • GLVertexAttrib1fv() : nvgl
  • GLVertexAttrib1h() : nvgl
  • GLVertexAttrib1hv() : nvgl
  • GLVertexAttrib1s() : nvgl
  • GLVertexAttrib1sv() : nvgl
  • GLVertexAttrib2d() : nvgl
  • GLVertexAttrib2dv() : nvgl
  • GLVertexAttrib2f() : nvgl
  • GLVertexAttrib2fv() : nvgl
  • GLVertexAttrib2h() : nvgl
  • GLVertexAttrib2hv() : nvgl
  • GLVertexAttrib2s() : nvgl
  • GLVertexAttrib2sv() : nvgl
  • GLVertexAttrib3d() : nvgl
  • GLVertexAttrib3dv() : nvgl
  • GLVertexAttrib3f() : nvgl
  • GLVertexAttrib3fv() : nvgl
  • GLVertexAttrib3h() : nvgl
  • GLVertexAttrib3hv() : nvgl
  • GLVertexAttrib3s() : nvgl
  • GLVertexAttrib3sv() : nvgl
  • GLVertexAttrib4bv() : nvgl
  • GLVertexAttrib4d() : nvgl
  • GLVertexAttrib4dv() : nvgl
  • GLVertexAttrib4f() : nvgl
  • GLVertexAttrib4fv() : nvgl
  • GLVertexAttrib4h() : nvgl
  • GLVertexAttrib4hv() : nvgl
  • GLVertexAttrib4iv() : nvgl
  • GLVertexAttrib4Nbv() : nvgl
  • GLVertexAttrib4Niv() : nvgl
  • GLVertexAttrib4Nsv() : nvgl
  • GLVertexAttrib4Nub() : nvgl
  • GLVertexAttrib4Nubv() : nvgl
  • GLVertexAttrib4Nuiv() : nvgl
  • GLVertexAttrib4Nusv() : nvgl
  • GLVertexAttrib4s() : nvgl
  • GLVertexAttrib4sv() : nvgl
  • GLVertexAttrib4ub() : nvgl
  • GLVertexAttrib4ubv() : nvgl
  • GLVertexAttrib4uiv() : nvgl
  • GLVertexAttrib4usv() : nvgl
  • GLVertexAttribI1i() : nvgl
  • GLVertexAttribI1iv() : nvgl
  • GLVertexAttribI1ui() : nvgl
  • GLVertexAttribI1uiv() : nvgl
  • GLVertexAttribI2i() : nvgl
  • GLVertexAttribI2iv() : nvgl
  • GLVertexAttribI2ui() : nvgl
  • GLVertexAttribI2uiv() : nvgl
  • GLVertexAttribI3i() : nvgl
  • GLVertexAttribI3iv() : nvgl
  • GLVertexAttribI3ui() : nvgl
  • GLVertexAttribI3uiv() : nvgl
  • GLVertexAttribI4bv() : nvgl
  • GLVertexAttribI4i() : nvgl
  • GLVertexAttribI4iv() : nvgl
  • GLVertexAttribI4sv() : nvgl
  • GLVertexAttribI4ubv() : nvgl
  • GLVertexAttribI4ui() : nvgl
  • GLVertexAttribI4uiv() : nvgl
  • GLVertexAttribI4usv() : nvgl
  • GLVertexAttribIPointer() : nvgl
  • GLVertexAttribPointer() : nvgl
  • GLVertexAttribPointerNV() : nvgl
  • GLVertexAttribs1dvNV() : nvgl
  • GLVertexAttribs1fvNV() : nvgl
  • GLVertexAttribs1hv() : nvgl
  • GLVertexAttribs1svNV() : nvgl
  • GLVertexAttribs2dvNV() : nvgl
  • GLVertexAttribs2fvNV() : nvgl
  • GLVertexAttribs2hv() : nvgl
  • GLVertexAttribs2svNV() : nvgl
  • GLVertexAttribs3dvNV() : nvgl
  • GLVertexAttribs3fvNV() : nvgl
  • GLVertexAttribs3hv() : nvgl
  • GLVertexAttribs3svNV() : nvgl
  • GLVertexAttribs4dvNV() : nvgl
  • GLVertexAttribs4fvNV() : nvgl
  • GLVertexAttribs4hv() : nvgl
  • GLVertexAttribs4svNV() : nvgl
  • GLVertexAttribs4ubvNV() : nvgl
  • GLVertexPointer() : nvgl
  • GLViewport() : nvgl
  • GLWindowBackBufferHint() : nvgl
  • GLWindowPos2d() : nvgl
  • GLWindowPos2dv() : nvgl
  • GLWindowPos2f() : nvgl
  • GLWindowPos2fv() : nvgl
  • GLWindowPos2i() : nvgl
  • GLWindowPos2iv() : nvgl
  • GLWindowPos2s() : nvgl
  • GLWindowPos2sv() : nvgl
  • GLWindowPos3d() : nvgl
  • GLWindowPos3dv() : nvgl
  • GLWindowPos3f() : nvgl
  • GLWindowPos3fv() : nvgl
  • GLWindowPos3i() : nvgl
  • GLWindowPos3iv() : nvgl
  • GLWindowPos3s() : nvgl
  • GLWindowPos3sv() : nvgl
  • GLXCreateContext() : nvgl
  • GLXDestroyContext() : nvgl
  • GLXGetCurrentContext() : nvgl
  • GLXGetCurrentDrawable() : nvgl
  • GLXInitializeExtensions() : nvgl
  • GLXIsExtensionAvailable() : nvgl
  • GLXIsExtensionExported() : nvgl

- h -

  • highestBit() : nvmath
  • highestBitValue() : nvmath

- i -

  • insert() : nvsg
  • intersectingSphere() : nvmath
  • isEmpty() : nvmath
  • isEmptyBoundingSphere() : nvsg
  • isIdentity() : nvmath
  • isNormalized() : nvmath
  • isNull() : nvmath
  • isOrthogonal() : nvmath
  • isPowerOfTwo() : nvmath
  • isRotation() : nvmath
  • isTypeOf() : nvsg

- l -

  • length() : nvmath
  • lengthSquared() : nvmath
  • lerp() : nvmath

- m -

  • magnitude() : nvmath
  • max() : nvmath
  • maxElement() : nvmath
  • min() : nvmath
  • minElement() : nvmath

- n -

  • nearestPoint() : nvmath
  • normalize() : nvsg, nvmath
  • numberOfComponents() : nvsg
  • nvsgInitialize() : nvsg
  • nvsgSetErrorHandler() : nvsg
  • nvsgTerminate() : nvsg

- o -

  • operator *() : nvmath
  • operator!=() : nvutil, nvsg, nvmath
  • operator+() : nvmath
  • operator-() : nvmath
  • operator/() : nvmath
  • operator<() : nvutil
  • operator==() : nvutil, nvsg, nvmath
  • operator^() : nvmath
  • operator~() : nvmath
  • orthonormalize() : nvmath

- p -

  • powerOfTwoAbove() : nvmath
  • powerOfTwoBelow() : nvmath
  • powerOfTwoNearest() : nvmath

- r -

  • radToDeg() : nvmath
  • rescale() : nvsg

- s -

  • SetCurrentDir() : nvutil
  • setIdentity() : nvmath
  • setMat() : nvmath
  • setVec() : nvmath
  • sign() : nvmath
  • signedDistance() : nvmath
  • sizeOfComponents() : nvsg
  • sizeOfType() : nvsg
  • smoothNormals() : nvmath
  • square() : nvmath

- t -

  • testPixelFormat() : nvui

- w -

  • WGLBindSwapBarrierNV() : nvgl
  • WGLBindTexImage() : nvgl
  • WGLBindVideoImage() : nvgl
  • WGLChoosePixelFormat() : nvgl
  • WGLCreateAffinityDC() : nvgl
  • WGLCreateContext() : nvgl
  • WGLCreatePbuffer() : nvgl
  • WGLDeleteContext() : nvgl
  • WGLDeleteDC() : nvgl
  • WGLDestroyPbuffer() : nvgl
  • WGLEnumGpuDevices() : nvgl
  • WGLEnumGpus() : nvgl
  • WGLEnumGpusFromAffinityDC() : nvgl
  • WGLGetCurrentContext() : nvgl
  • WGLGetCurrentDC() : nvgl
  • WGLGetPbufferDC() : nvgl
  • WGLGetVideoDevice() : nvgl
  • WGLGetVideoInfo() : nvgl
  • WGLInitializeExtensions() : nvgl
  • WGLIsExtensionAvailable() : nvgl
  • WGLIsExtensionExported() : nvgl
  • WGLJoinSwapGroupNV() : nvgl
  • WGLQueryFrameCountNV() : nvgl
  • WGLQueryMaxSwapGroupsNV() : nvgl
  • WGLQueryPbuffer() : nvgl
  • WGLQuerySwapGroupNV() : nvgl
  • WGLReleasePbufferDC() : nvgl
  • WGLReleaseTexImage() : nvgl
  • WGLReleaseVideoDevice() : nvgl
  • WGLReleaseVideoImage() : nvgl
  • WGLResetFrameCountNV() : nvgl
  • WGLSendPbufferToVideo() : nvgl
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values

  • CBS : nvsg
  • CgFxAnnotation : nvsg
  • CgFxParameter : nvsg
  • CgFxPass : nvsg
  • CgFxProgram : nvsg
  • CgFxTechnique : nvsg
  • DataID : nvsg
  • DestroyCallback : nvutil
  • Face3 : nvsg
  • Face4 : nvsg
  • HDAL : nvsg
  • LOG_OUTPUT_FUNCTION : nvutil
  • LogTest : nvutil
  • NVSGERRORHANDLER : nvsg
  • PFNGETPLUGINTERFACE : nvutil
  • PFNQUERYPLUGINTERFACETYPE : nvutil
  • PIS : nvutil
  • ProblemLogList : nvutil
  • Segment : nvsg
  • VariantKey : nvsg
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values

  • cIdentity44f : nvmath
  • glError : nvgl
  • HDAL_INVALID : nvsg
  • logFileOutput : nvutil
  • nvsgErrorHandler : nvsg
  • PI : nvmath
  • PI_HALF : nvmath
  • PI_QUARTER : nvmath
  • SQRT_TWO : nvmath
  • SQRT_TWO_HALF : nvmath
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Page Index

NVSGSDK Related Pages

Here is a list of all related documentation pages:
  • Building the Sample Files
  • Understanding the Contents Pane
  • NVSG Core Objects
  • Creating a New NVSG Project
  • Creating a New Plug-in Project
  • NVSG License Agreement
  • Frequently Asked Questions - FAQ
  • Fundamental Concepts of the NVSGSDK
  • Hit Testing
  • How to Use Volumes and the Volume Bricker
  • How to Derive an NVSG Object
  • How to Derive a Traverser
  • How to Enable Memory Leak Detection in Debug Mode
  • Working with Traversers
  • How to Use the Sample Viewer
  • Legal Notice
  • NVSG SDK 3.2 Migration Guide
  • Working with Multitexturing
  • Important Concepts - Must Read for All Developers
  • Overview of the Principal Classes
  • Recommended Reading
  • Separation of Data from Their Operations
  • Skinning Support in NVSG
  • Traversers
  • Using the NVSGSDK
  • Defining the View Frustum
  • What You Need to Get Started
  • Working with Lights
  • Working With NVSG Classes
  • Working with State Attributes
  • Working with Texture Maps
  • Writing a Loader/Saver Plug-In
  • NVSG COLLADA/FX File Format Loader
  • NVSG MultiGen OpenFlight(tm) File Format Loader
  • Working with cube map textures
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


Building the Sample Files

The NVSGSDK provides some sample code which is located in the sub-directories of /NVSGSDK/SRC/SAMPLES. This section provides information on building and running the sample code.

A VCPROJ file is provided to build each sample. Each VCPROJ file includes a Release configuration and a Debug configuration, and developers may use any of these.

The differences between the Release configuration and the Debug configuration are as follows:

  • Code Optimizations
    Only the Release configuration creates optimized code.

  • Debug Symbols
    Only the Debug configuration includes debug symbols.

  • Use of Runtime Libraries
    The Release configuration uses the Multithreaded runtime DLL in VC++.
    The Debug configuration uses the Debug Multithreaded DLL library.

    Note:
    Also, because heaps cannot be mixed and matched, the Debug configuration must not use a different heap to track memory.

    Back to Getting Started
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Understanding the Contents Pane

The Contents pane lets you access the following detailed information on the NVSGSDK:

The File List lists all documented files with a brief description.

The Compound List lists of all classes, structs, unions and interfaces with brief descriptions. The alphabetical sort here ignores the namespace.

The Class Hierarchy lists all classes where the derived classes are listed indented after their base class.

The Compound Members lists all documented class members with links to the classes they belong to.

The Namespace List lists all documented namespaces with brief descriptions.

The File Members lists all documented file members with links to the documentation.

The Namespace Members lists all documented namespace members with links to the namespaces they belong to.

The Related Pages lists all related documentation pages that are available, for example, via the main page.

Finally, the Graphics Class Hierarchy gives a graphical representation of the Class Hierarchy .

Back to Getting Started

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


NVSG Core Objects

This article gives a brief overview of the kind of objects covering the C++ class hierarchy that we call the NVSG Core Objects. It also generally describes how to deal with these objects in terms of instantiation, lifetime control, and access control. Beside this, it briefly introduces Handles, an administrative wrapper for core objects, that we use to carry concrete core objects through interfaces.

Introduction

The term NVSG Core Objects relates to all the C++ classes that form the building blocks to create a directed acyclic graph (DAG) - a structure that we use to represent a scenegraph. These core components all live in the nvsg namespace and build a class hierarchy with nvsg::Object as its common base class. The article 'Overview of the Principal Classes' lists a complete set of all the concrete NVSG core classes that are delivered with the current NVSG SDK.

In general, we distinguish between three kinds of objects:

  1. Nodes

    In general, a scenegraph consists of nodes arranged in a tree structure. Scenegraph nodes encapsulate coherent parts of the scene to be represented, and hence, support the natural grouping of the geometric objects in the scene.

    In NVSG, Node represents the base class for all concrete and non-concrete node classes. Two types of nodes are distinguished:
    • Leaf nodes are nodes that can only have parent nodes
    • Group nodes are nodes that can have other nodes as children
    In NVSG, all concrete and non-concrete group nodes inherit from Group . For example, nodes that all undergo a certain transformation are grouped together under a Transform node.
  2. Node Components

    Node components are objects that are referenced by nodes. These components hold, for example, geometrical or topological informations, or they define certain state attributes for rendering. LightSource , Material , or Triangles are examples of node components.
  3. Superior Objects

    Superior objects are not part of the graph tree, but are objects to which a scenegraph is connected, or that define a certain view to the scene. Scene , ViewState , or Camera are examples of superior objects.

Working with NVSG Core Objects

NVSG Core Objects provide interfaces to store or manipulate data in a scenegraph. Lifetime control as well as access control for the NVSG Core Objects has been elevated to some wrapper classes, that we call handles. The particular interface of a handle is provided by the Handle utility template class.

Each NVSG core object has an associated handle type. A particular handle type will be defined by means of the Handle class template. The handle type definitions for all handle types that are delivered with the NVSG SDK can be found in the CoreTypes.h header file.

Object Instantiation

A 'handled' object is not instantiated explicitely but implicitely as its associated handle gets created. And in the same way, the handled object implicitely will be destroyed when its handle dies.

A handle can live on heap only, and a handle's lifetime is controlled by reference counting. Due to these limitations the ways of instantiating a handle are limited. A handle can be newly instantiated through the CreateHandle, and CreateHandleFromBase macros, or it can be instantiated as a copy of an already existing handle by invoking the handel's clone member handle.

  // instatiation of a GroupHandle through CreateHandle macro
  GroupHandle * hgroup = CreateHandle(GroupHandle);

  // instantiation of a LODHandle through GreateHandleFromBase
  LODHandle * hlod = CreateHandleFromBase(LODHandle, *hgroup);

  // instantiation of a second GroupHandle as copy
  GroupHandle * hgroupclone = hgroup->clone();

The CreateHandle as well as the CreateHandleFromBase do not allow additional constructor parameters to be passed for the implicit object instantiation. That is, for an object D that derives from B, the only constructors, that will be invoked as the associated handle will be instantiated, are the object's default constructor, the object's 'partial' copy cnstructor, and the object's copy constructor.

  class B : public Object
  {
  protected:
      virtual ~B();
    [...]
  };

  class D : public B
  {
  public:
    D(); // default constructor will be implicitely invoked through CreateHandle
    D(const B&); // partial copy constructor will be implicitely invoked through CreateHandleFromBase
    D(const D&); // copy constructor will be implicitely invoked through the associated handle's clone member
    [...]
  };

  typedef nvutil::Handle<B, ObjectHandle> BHandle;
  typedef nvutil::Handle<D, BHandle> DHandle;

If an object requires additional initialization, which cannot be handled by this limited set of constructors, a dedicated init member function can be provided by the class designer to serve this purpose.

  class D : public B
  {
  public:
    D(); // default constructor will be implicitely invoked through CreateHandle
    D(const B&); // partial copy constructor will be implicitely invoked through CreateHandleFromBase
    D(const D&); // copy constructor will be implicitely invoked through the associated handle's clone member

    // init provides extra initialization not provided by available constructors
    void init(int a, int b);
    [...]
  private:
    int m_a;
    int m_b;
  };

Instantiation and proper initialization of such an object would then look like this:

  DHandle * hd = CreateHandle(DHandle);

    // default construction doesn't suffice - need to perform some additional init
  {
    WritableObject<D> d(hd);
    d->init(12, 4);
    [...]
  }
  [...]

Lifetime of an Object

After instantiation, the handle's reference count is 0. That is, a handle is not automatically referenced after instantiation. The reason for this is, that in most cases the code that creates a handle, directly passes it to another layer which references the handle. Doing so, there is no need for the creating code to take care of the handle's lifetime. You can think of a Node that will be added to a Group as child. In this particular case, the Group takes over responsibility for referencing the child node.

An Object itself can be referenced mutiple times only through its Handle. For this, the Handle class template provides reference counting through addRef / removeRef APIs.
The handle's reference count can be explicitely incremented by calling addRef on the handle. In the same way, call removeRef, to explicitely decrement, and thus unreference a handle.
A Handle, and thus the handled object, will be automatically deleted when the handle's reference count drops to zero.

Whenever you need to access a handle that already is referenced by some other layer, it is strongly recommended to explicitely reference the handle while you access it. Doing so ensures to keep the handle, and thus the handled object, during access.

Obtain Access to an Object's API

Modifying a certain object, or query a certain information from an object, requires access to the object's API. This access can be obtained through the associated handle by means of the dedicated beginEdit or beginRead APIs, that also are provided by the Handle template class.

When giving access to the handled object, we differentiate between write access, which is given exclusively, and read access, which can be given to concurrent threads simultaneous, if no other thread is currently writing the object.

To obtain write access to the handled object, you need to call beginEdit on the associated handle, which returns a pointer to the handled object. In a multithreaded environment, the beginEdit function locks the object before returning a pointer to the object. This gives the calling thread exclusive access to the object.
After the desired modification has been completed, you need to release the exclusive write lock through a call to endEdit on the same handle. This in particular is necessary to resume concurrent threads that are waiting to obtain either read or write access to the same object.

Alternatively, you can use the WritableObject class to convert a handle into a writable object. The exclusive write access to the handled object will be automatically released when the WritableObject runs out of scope:

  // create a GroupHandle carrying a Group node
  GroupHandle * hgroup = CreateHandle(GroupHandle);

  // obtain write access to the Group to add a child node
  {
    WritableObject<Group> theGroup(hgroup);
    theGroup->addChild(...);
  } // write lock will be released when the WritableObject runs out of scope

Similar to obtaining write access, you can obtain read-only access to a handled object. Use either beginRead/endRead to obtain/release read access, or use the ReadableObject class in the same way as described for WritableObject above.
Read-only access can be given simultaneous to concurrent threads, as mentioned earlier.

Note:
You can dead-lock your application when requesting write access to an object that already is locked for read access from the same thread!
See also:
Overview of the Principal Classes
Back to Fundamental Concepts
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Creating a New NVSG Project

This section describes a sample application that you can use to see how to create a new NVSG Project using MFC. The sample code is located in the nvsgsdk/src/samples/SimpleViewer directory.

About the Simple Viewer Sample Application

This simple application creates a viewer showing a simple model. You can rotate, zoom and pan the model by using the mouse.
  • Rotate: left mouse button
  • Pan: middle mouse button
  • Zoom: left + middle mouse button
  • View all (recenter): right mouse button

The application was created with the developer studios’ project wizard. (MFC project, single document application)

Simple Viewer Project Settings

C/C++ Compiler Settings

Additional include directories (General / Additional Include Directories):
  • "$(NVSGSDKHOME)\inc"
  • "$(NVSGSDKHOME)\inc\nvsg"

Define NOMINMAX (Preprocessor / Preprocessor Definitions) to avoid problems between STL and Windows definitions:

  • NOMINMAX

Enable run-time type information (Language / Enable Run-Time Type Info):

  • Yes (/GR)

Linker Settings

Additional library directories: (General / Additional Library Directories ):
  • "$(NVSGSDKHOME)\lib\<ARCH>\win\<CRT>\$(ConfigurationName)"

can be either 'x86' or 'amd64', and can be either 'crt71' or 'crt80'.

If you intend to develop a 32-bit application, must be set to 'x86'. For 64-bit AMD compatible applications, must be set to 'amd64'.

Depending on whether you use the VC71 compiler or the VC8 compiler, must be set to 'crt71' or 'crt80' resp..

Additional libs (Input / Additional Dependencies):

  • opengl32.lib
  • ramfc.lib
  • nvsg.lib

DLL Requirements

  • nvsg3.dll
  • ramfc.dll
  • Cg.dll
  • CgGL.dll

Include Files

NVSG storage-class defines

You need to add the following include statement to your source files or once into e.g. stadafx.h.
#include "nvsg/nvsgapi.h" // NVSG storage-class defines

Memory Leak Detection

To enable the NVSG Memory leak detection make sure to add the following include statement at the end of your include statements to your source files.
#include "nvutil/DbgNew.h" // this must be the last include

Source

In the sources the relevant code for NVSG is marked by
// NVSG ------------------begin
…
// NVSG ------------------end
so it is very easy to identify the relevant code snippets.
The relevant classes for the “SimpleViewer” example are:
  • SimpleViewer
  • SimpleViewerDoc
  • SimpleViewerView

You will find further explanation in the comments of the code.

Back to Getting Started

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Creating a New Plug-in Project

A plug-in or a 'NVSG Extension Module' (nxm), should be developed as a dynamic link library. The default extensions for all plug-ins that ship with the NVSG SDK is '.nxm'. If you intend to use another extension for your plug-ins, your application needs to configure the NVSG at runtime to also consider the newly introduced plug-in exensions:

  BOOL YourApplication::InitInstance()
  {
    nvsg::nvsgInitialize();

    // in addition to the default '*.nxm' extension,
    // the '*.xyz' extension should also be considered
    // when searching for plug-ins.

    nvutil::setPlugInFileFilter("*.nxm;*.xyz");
    [...]
  }

The following compiler and linker settings are required for creating a new plug-in project:

C/C++ Compiler Settings

Additional include directories (General / Additional Include Directories):
  • "\$(NVSGSDKHOME)\inc"
  • "\$(NVSGSDKHOME)\inc\nvsg"

Preprocessor definitions (Preprocessor / Preprocessor Definitions):

  • "_USRDLL"

Runtime library (Code Generation / Runtime Library):

  • "Multi-threaded DLL (/MD)" for release configuration, and
  • "Multi-threaded Debug DLL (/MDd)" for debug configuration

Linker Settings

Additional library directories: (General / Additional Library Directories ):
  • "$(NVSGSDKHOME)\lib\<ARCH>\win\<CRT>\$(ConfigurationName)"

can be either 'x86' or 'amd64', and can be either 'crt71' or 'crt80'.

If you intend to develop a 32-bit plug-in, must be set to 'x86'. For 64-bit AMD compatible plug-ins, must be set to 'amd64'.

Depending on whether you use the VC71 compiler or the VC8 compiler, must be set to 'crt71' or 'crt80' resp..

Additional libs (Input / Additional Dependencies):

  • nvsg.lib

See also the EXRLoader tutorial for further information.

Back to Advanced

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


NVSG License Agreement

Copyright 2005 NVIDIA Corporation

BY DOWNLOADING, INSTALLING, OR USING THE SOFTWARE AND OTHER AVAILABLE MATERIALS, YOU ("DEVELOPER") AGREE TO BE BOUND BY THE FOLLOWING TERMS AND CONDITIONS

The materials available for download to Developers include software in both source ("Source Code") and object code ("Object Code") versions, documentation ("Documentation"), certain art work ("Art Assets") and other materials (collectively, these materials referred to herein as "Materials"). Except as expressly indicated herein, all terms and conditions of this Agreement apply to all of the Materials.

Except as expressly set forth herein, NVIDIA owns all of the Materials and makes them available to Developer only under the terms and conditions set forth in this Agreement.

LICENSE: NVIDIA hereby grants to Developer a royalty-free, non-exclusive, non-transferable, license without the right to sublicense, to possess and to internally use the Materials for both commercial and non-commercial purposes but only in connection with NVIDIA products. Except as expressly set forth below, Developer agrees not to distribute the Materials or any derivative works created therewith without the express written permission of an authorized NVIDIA officer or employee. The following terms apply to the specified type of Material:

Source Code: Developer shall have the right to modify and create derivative works with the Source Code. Developer shall own any derivative works ("Derivatives") it creates to the Source Code, subject to NVIDIA's right, title and interest in the underlying Source Code, provided that Developer uses the Materials in accordance with the terms of this Agreement. Developer may distribute the Derivatives in object code form only, provided that all NVIDIA copyright notices and trademarks are used properly and the Derivatives include the following statement: "This software contains source code provided by NVIDIA Corporation." Developer hereby grants to NVIDIA a worldwide, irrevocable, perpetual, transferable, sublicenseable (through multiple tiers of sublicensees), royalty-free, fully paid-up license and rights to the Derivatives (in both source code and object code format), including all of Developers intellectual property rights therein, to use, copy, modify, create derivative works of, perform, publicly display, distribute (through multiple tiers of subdistributors) and otherwise exploit the Derivatives.

Object Code: Developer agrees not to disassemble, decompile or reverse engineer the Object Code versions of any of the Materials. Developer acknowledges that certain of the Materials provided in Object Code version may contain third party components that may be subject to restrictions, and expressly agrees not to attempt to modify or distribute such Materials without first receiving consent from NVIDIA. Notwithstanding any other provision to the contrary, Developer may redistribute the Object Code versions of of the NV Scene Graph product (i) provided such Object Code may only be redistributed together with the Developer's commercial or non-commercial application; (ii) provided that all NVIDIA copyright notices and trademarks are used properly; and (iii) provided that the Developer applications containing and/or bundled with the Object Code of the NV Scene Graph product include the following statement: "This software contains code provided by NVIDIA Corporation." Any such redistribution shall be subject to the terms and conditions of this Agreement. Without limiting the foregoing sentence, no Materials, including the Object Code of the NV Scene Graph product, shall be distributed on a stand-alone basis.

Art Assets: Developer shall have the right to modify and create Derivatives of the Art Assets, but may not distribute any of the Art Assets or Derivatives created therefrom without NVIDIA's prior written consent.

TERM: The license granted by this Agreement shall be perpetual, unless terminated by NVIDIA. NVIDIA may terminate this Agreement (and with it, all of Developer's right to any NVIDIA Materials) upon written notice (which may include email) to Developer, with or without cause.

SUPPORT: NVIDIA has no obligation to support or to continue providing or updating any of the Materials.

NO WARRANTY: THE SOFTWARE AND ANY OTHER MATERIALS PROVIDED BY NVIDIA TO DEVELOPER HEREUNDER ARE PROVIDED "AS IS." NVIDIA DISCLAIMS ALL WARRANTIES, EXPRESS, IMPLIED OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

LIMITATION OF LIABILITY: NVIDIA SHALL NOT BE LIABLE TO DEVELOPER, DEVELOPER'S CUSTOMERS, OR ANY OTHER PERSON OR ENTITY CLAIMING THROUGH OR UNDER DEVELOPER FOR ANY LOSS OF PROFITS, INCOME, SAVINGS, OR ANY OTHER CONSEQUENTIAL, INCIDENTAL, SPECIAL, PUNITIVE, DIRECT OR INDIRECT DAMAGES (WHETHER IN AN ACTION IN CONTRACT, TORT OR BASED ON A WARRANTY), EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF THE ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. IN NO EVENT SHALL NVIDIA'S AGGREGATE LIABILITY TO DEVELOPER OR ANY OTHER PERSON OR ENTITY CLAIMING THROUGH OR UNDER DEVELOPER EXCEED THE AMOUNT OF MONEY ACTUALLY PAID BY DEVELOPER TO NVIDIA FOR THE SOFTWARE OR ANY OTHER MATERIALS.

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Frequently Asked Questions - FAQ

  • Where can I get support for NVSG?
  • What is the NVSG License model?
  • How do I enable memory leak detection?
  • Why are there so many memory leaks when I use MFC?
  • Where can I get additional file loader plug-ins?
  • How do I derive my own RenderArea?
  • How can I use jitter?
  • Why does my application crash when I destroy objects?
  • How can I build a scene graph with NVSG?
  • How do I set up multi-texturing?
  • How do I use streaming textures?
  • How do I use cube map textures?
  • How do I set up a CgFx effect loaded from a file?
  • How do I set up a CgFX effect from a text string?
  • How do I use reference counted objects as local variables?
  • How do I set up hit testing?
  • How can I highlight an object in the scene?
  • How can I set the rotation point?
  • How do I extend the NBF loader or saver?
  • How do I use Geometry Shaders/Programs?
  • How do I use Texture Arrays?
  • How do I use the new Texture Formats?
  • What are the general guidelines to achieve render performance?

Where can I get support for NVSG?

The best place to get support is to go to http://forums.nvidia.com/ and go to the NVSG forum.
There are many experienced NVSG users and NVSG developers who can help you. Please use the search feature of the forum to check if the solution for your issue is already there.

The second way to get support is to write to nvsghelp@nvidia.com. This email distribution list makes sure that your request will not get lost. Use this e-mail for subjects that you can't discuss or disclose to people other than NVIDIA.

What is the NVSG License model?

You can use NVSG in your product free of charge if you respect the following license: NVSG License Agreement

How do I enable memory leak detection?

To enable memory leak detection, the last include entry in your implementation file (.cpp) should be:
#include "nvutil/DbgNew.h"

If you need memory leak detection in you header file (.h) because you do a lot of implementation in the header, you can't add this include statement, but you can add the following code sequence at the beginning of the header file:

#if !defined(NDEBUG)
# ifndef new
#  define new new(__FILE__, __LINE__)
#  define _DEFINED_DBGNEW // restrict the 'new' macro to this header file only
# endif
#endif

And the following code sequence at the end:

#ifdef _DEFINED_DBGNEW
# undef new
#endif

Why are there so many memory leaks when I use MFC?

These memory leaks are most likely pseudo leaks. The Viewer application that we ship dynamically links to MFC. When the program ends, the MFC dll gets unmapped from the process memory, and performs an explicit memory leak dump far too early for global/static variables that will be cleaned up when the c-runtime terminates. So the problem here is the explicit call to CrtDumpMemoryLeaks from inside the MFC dll. The NVSG core already defines its own data section for global/static vars, so it can control initialization and termination of these variables. However, we currently have no control of other dlls that we link to in order to do it in a similar way. We are continuing to seek for a solution.

Where can I get additional file loader plug-ins?

You will find some file loader plug-ins in the nvsg-forum (http://forums.nvidia.com/ and go to the NVSG forum).
Currently we know about the following additional file formats:
  • OpenFlight (coming soon in NVSG)
  • XSI

How do I derive my own RenderArea?

Creating a render target window and context for NVSG
The following classes are available:
  • RenderArea
    This is the base class of all render areas. It does not create any window or render context.
  • GLWinRenderArea (Win32 OpenGL) (*)
    This class does not create a window, but does create a render context. Attach a valid window handle to it and call GLWinRenderArea::init() to create the OpenGL context. Do not create the OpenGL context yourself! The pixel format will be selected depending on the requested features.
    Samples: ConsoleViewer
  • GLMFCRAWnd (Win32 OpenGL, using an MFC window)
    This is derived from CWnd and GLWinRenderArea. It creates an MFC window and GL context (see above).
    Samples: ViewerVR, SimpleViewer, etc.

Notes for using GUI toolkits other than MFC
If you plan on using other GUI libraries such as Qt, wxWidgets, etc., there are two ways of creating a render area for NVSG:

Method 1)
Create a normal window (without an OpenGL context) using your GUI library, grab the handle and attach it to a GLWinRenderArea. (*)

If your GUI-library is class-based, you might want to create a new render area class by deriving from both GLWinRenderArea and that specific window class from your library. (See "inc/nvsg/RAmfc/GLMFCRAWnd.h" to get an idea.) Do not create a GL context, and ensure that your GUI toolkit does not do this either. Also, ensure that your window does not erase its background, e.g. by calling QWidget::setBackgroundMode(Qt::Nobackground) for Qt or by filtering the WM_ERASEBKGND (Win32 only) in any other way.
See the following samples to see how Method 1 works in detail:
  • "src/samples/ConsoleViewer"

Method 2)
Use the GUI toolkit functionality for creating the GL context and derive from the RenderArea base class, e.g. for Qt derive from QGLWidget and RenderArea.
Make sure your render context supports the required features:
  • double buffering
  • RGBA
  • 24bit depth buffer
  • (stereo, if requested)
NVSG also needs to know about the GL context, and usually this is achieved by creating, destroying, and switching the context through our capital-letter GL wrapper functions (WGLCreateContext(), WGLDeleteContext(), WGLMakeCurrent(), GLXCreateContext(), GLXDestroyContext(), GLXMakeCurrent()). When creating the context through another toolkit which calls the regular wgl*()/glX*() functions, you have to take care of the following:
  • After creation, introduce the context to NVSG by calling WGLAttachContext() (win32) or GLXAttachContext() (Linux).
  • After destruction, remove the context from NVSG by calling WGLDetachContext() (win32) or GLXDetachContext() (Linux).
  • After switching the context, call WGLMakeCurrent() or GLXMakeCurrent() once more in order to let NVSG know about the context switch.
See the following samples to see how Method 2 works in detail:
  • "src/samples/glut"
  • "src/samples/Linux/wxWidgets/SimpleViewer"

(*)Linux notes
There is a native Xlib window/render area class available in "src/samples/Linux/Xlib". See the ConsoleViewer sample ("src/samples/Linux/ConsoleViewer") on how to use it. To avoid Xlib linking and version problems, this class was not integrated into the NVSG core.

Alternatively, you can easily use Method 2, as explained above, if you use any GUI toolkit that offers OpenGL support (e.g. Qt, wxWidgets, SDL, ...).

How can I use jitter?

The jitter feature can be used, for example, for doing software FSAA. The main concept behind this is to render the scene multiple time (mutipass approach) with a small offset for the camera at every single pass. All the images will be blended together for the final image. See nvsg::ViewState::setJitter for information on how to set up jittering for software FSAA using the accumulation buffer technique.

Why does my application crash when I destroy objects?

In most cases, the root cause for this is that a wrong c-runtime is used for the project. Example: When a loader plug-in is linked to the single threaded c-runtime, the single threaded allocator is used to allocate memory for objects. The NVSG core uses the multithreaded c-runtime. If somewhere an object needs to be destroyed, the wrong (multithreaded) memory deallocator is called. This leads typically to undefined behavior and crashes.

How can I build a scene graph with NVSG?

Sometimes you do not want to load a scene but you want to program a tree. The following code shows how to program a simple tree with NVSG calls. See the SimpleViewer tutorial source code for more information - "src/samples/SimpleViewer".

// This method creates a more or less complex tree and
// returns a pointer to the root node of the tree.
NodeHandle * CSimpleViewerDoc::createSimpleTree() const
{
  // Create the root node and apply a rotation.
  // Note:
  // We do not increment the ref count here,
  // because we throw the root into the scene
  // via setRoot(), and setRoot() will increment
  // it for us.
  // setup vertices and faces
  Vec3f vertices[8] = { Vec3f(-0.2f, -0.2f,  0.2f)
    , Vec3f(-0.2f,  0.2f,  0.2f)
    , Vec3f( 0.2f,  0.2f,  0.2f)
    , Vec3f( 0.2f, -0.2f,  0.2f)
    , Vec3f( 0.2f, -0.2f, -0.2f)
    , Vec3f( 0.2f,  0.2f, -0.2f)
    , Vec3f(-0.2f,  0.2f, -0.2f)
    , Vec3f(-0.2f, -0.2f, -0.2f) };

  Face3 faces[12]     = { {0,2,1}, {2,0,3}
  , {3,5,2}, {5,3,4}
  , {4,6,5}, {6,4,7}
  , {7,1,6}, {1,7,0}
  , {0,4,3}, {4,0,7}
  , {1,5,6}, {5,1,2} };

  // calculating face normals
  Vec3f v[36];
  Vec3f n[36];
  Face3 f[12];
  Vec3f v0, v1, v2, d0, d1, fn;
  for ( int kf=0, kv=0; kf<12; kf++, kv+=3 )
  {
    v0 = vertices[faces[kf][0]];
    v1 = vertices[faces[kf][1]];
    v2 = vertices[faces[kf][2]];

    d0 = v1 - v0;
    d1 = v2 - v0;

    fn = d0^d1;
    fn.normalize();

    f[kf][0] = kv;
    f[kf][1] = kv+1;
    f[kf][2] = kv+2;

    v[kv]    = v0;
    v[kv+1]  = v1;
    v[kv+2]  = v2;

    n[kv]    = fn;
    n[kv+1]  = fn;
    n[kv+2]  = fn;
  }

  // Create a VertexAttributeSet with vertices and normals
  VertexAttributeSetHandle * vasHdl = CreateHandle(VertexAttributeSetHandle);
  {
    WritableObject<VertexAttributeSet> vas(vasHdl);
    vas->setVertices( v, 36 );
    vas->setNormals( n, 36 );
  }

  // Create a PrimitiveSet, in this case triangles.
  TrianglesHandle * shapeHdl = CreateHandle(TrianglesHandle);
  {
    WritableObject<Triangles> triangles(shapeHdl);
    triangles->setVertexAttributeSet( vasHdl );
    triangles->setFaces(f, 12);
  }

  // Create a material.
  MaterialHandle * materialHdl = CreateHandle(MaterialHandle);
  {
    WritableObject<Material> material(materialHdl);
    material->setAmbientColor( Vec3f(0.f, 0.f, 1.f) );
    material->setDiffuseColor( Vec3f(0.4f, 0.4f, 0.4f) );
    material->setEmissiveColor( Vec3f(0.f, 0.f, 0.f) );
    material->setSpecularColor( Vec3f(1.f, 1.f, 1.f) );
    material->setSpecularExponent( 10.f );
    material->setOpacity( 1.0f );
  }

  StateSetHandle * stateSetHdl = CreateHandle(StateSetHandle);
  WritableObject<StateSet>(stateSetHdl)->addAttribute(materialHdl);

  // Setup the whole scene graph
  GeoNodeHandle * geoNodeHdl = CreateHandle(GeoNodeHandle);
  WritableObject<GeoNode>(geoNodeHdl)->addGeometry(shapeHdl,stateSetHdl);

  GeoNodeHandle * geoNodeHdl2 = geoNodeHdl->clone();

  // Note:
  // AddChild() will increment the reference count
  // of the added node.
  Trafo shapeTrafo2;
  shapeTrafo2.setOrientation( Quatf(Vec3f(0.0f, 1.0f, 0.0f ), float(PI_QUARTER)) );
  TransformHandle * pShapeTrafo2 = CreateHandle(TransformHandle);
  {
    WritableObject<Transform> wot(pShapeTrafo2);
    wot->setTrafo( shapeTrafo2 );
    wot->addChild( geoNodeHdl );
  }

  Trafo shapeTrafo;
  shapeTrafo.setOrientation( Quatf(Vec3f(1.0f, 0.0f, 0.0f ), float(PI_QUARTER)) );
  TransformHandle * pShapeTrafo = CreateHandle(TransformHandle);
  {
    WritableObject<Transform> wot(pShapeTrafo);
    wot->setTrafo(shapeTrafo);
    wot->addChild( pShapeTrafo2 );
  }

  Trafo shape2Trafo2;
  shape2Trafo2.setOrientation( Quatf(Vec3f(0.0f, 1.0f, 0.0f ), float(PI_QUARTER)) );
  TransformHandle * pShape2Trafo2 = CreateHandle(TransformHandle);
  {
    WritableObject<Transform> wot(pShape2Trafo2);
    wot->setTrafo(shape2Trafo2);
    wot->addChild(geoNodeHdl2);
  }

  Trafo shape2Trafo;
  shape2Trafo.setOrientation( Quatf(Vec3f(1.0f, 0.0f, 0.0f ), 0.0f) );
  shape2Trafo.setTranslation( Vec3f( -1.0f, 0.0f, 0.0f ) );
  TransformHandle * pShape2Trafo = CreateHandle(TransformHandle);
  {
    WritableObject<Transform> wot(pShape2Trafo);
    wot->setTrafo(shape2Trafo);
    wot->addChild(pShape2Trafo2);
  }

  Trafo shape3Trafo;
  shape3Trafo.setOrientation( Quatf(Vec3f(1.0f, 0.0f, 0.0f ), 0.0f) );
  shape3Trafo.setTranslation( Vec3f( 1.0f, 0.0f, 0.0f ) );
  TransformHandle * pShape3Trafo = CreateHandle(TransformHandle);
  {
    WritableObject<Transform> wot(pShape3Trafo);
    wot->setTrafo(shape3Trafo);
    wot->addChild( geoNodeHdl2 );
  }

  GroupHandle * rootHdl = CreateHandle(GroupHandle);
  {
    WritableObject<Group> root(rootHdl);
    root->addChild( pShapeTrafo );
    root->addChild( pShape2Trafo );
    root->addChild( pShape3Trafo );
  }

  return( rootHdl );
}

How do I set up multi-texturing?

See the following article: Working with Multitexturing

How do I use streaming textures?

The following sample code shows how to set up a streaming texture, and how to stream in the image changes. For further details see the TextureStreamViewer tutorial source code - "/src/samples/TextureStreamViewer".

  unsigned int creationFlags = TextureImage::F_IMAGE_STREAM;

  gTexStream = CreateHandle(TextureImageHandle);
  {
    WritableObject<TextureImage> texStream(gTexStream);
    texStream->setCreationFlags( creationFlags );
    texStream->createImage( gImage.width(), gImage.height(), gImage.depth(), 0
                          , Image::IMG_RGBA, Image::IMG_UNSIGNED_BYTE, gImage.pixels() );
  }

  gTexItem = CreateHandle(TextureAttributeItemHandle);
  {
    WritableObject<TextureAttributeItem> texItem(gTexItem);
    texItem->setTextureImage(gTexStream);
    texItem->setEnvMode(nvsg::TEM_DECAL);

    // specify texture generation
    nvmath::Vec4f plane[3];
    plane[0] = nvmath::Vec4f(1,0,0,0);
    plane[1] = nvmath::Vec4f(0,1,0,0);
    plane[2] = nvmath::Vec4f(0,0,0,0);

    texItem->setTexGenLinearPlane(nvsg::TCA_S, nvsg::TGLP_OBJECT_AND_EYE, plane[0]);
    texItem->setTexGenLinearPlane(nvsg::TCA_T, nvsg::TGLP_OBJECT_AND_EYE, plane[1]);
    texItem->setTexGenLinearPlane(nvsg::TCA_R, nvsg::TGLP_OBJECT_AND_EYE, plane[2]);
    texItem->setTexGenMode(nvsg::TCA_S, nvsg::TGM_OBJECT_LINEAR);
    texItem->setTexGenMode(nvsg::TCA_T, nvsg::TGM_OBJECT_LINEAR);
    texItem->setTexGenMode(nvsg::TCA_R, nvsg::TGM_OBJECT_LINEAR);

    // specify wrap modes
    texItem->setWrapMode(nvsg::TWCA_S, nvsg::TWM_REPEAT);
    texItem->setWrapMode(nvsg::TWCA_T, nvsg::TWM_REPEAT);
    texItem->setWrapMode(nvsg::TWCA_R, nvsg::TWM_REPEAT);
  }

  TextureAttributeHandle * texAttribHdl = CreateHandle(TextureAttributeHandle);
  WritableObject<TextureAttribute>(texAttribHdl)->bindTextureAttributeItem(gTexItem,0);

[...] // put all the stuff into the tree

Somewhere in your code you need to stream in the image changes and trigger a redraw.

[...] // change the rgbas using some method..

  gImage.exchange();
  WritableObject<TextureImage>(gTexStream)->demandUpload();
  gpRenderer->triggerRedraw();

[...]

How do I use cube map textures?

See the following article: Working with cube map textures

How do I set up a CgFx effect loaded from a file?

The following code sample shows how you can set up a CgFx effect where you load the shader discription from a CgFx effect file. For further information on how to create a CgFx effect, see: nvsg::CgFxEffect::createFromFile
More detailed information about Cg/CgFX can be found at http://developer.nvidia.com/page/cg_main.html

  bool effectValid = false;
  RCObject_AutoPtr< CgFxHandle > hCgfx( CreateHandle( CgFxHandle ) );
  {
    WritableObject< CgFx > cgfx( hCgfx.get() );
    WritableObject< CgFxEffect > effect( cgfx->getEffect() );

    string err;
    if( !pEffect->createFromFile(cgfxFile, err) )
    {
      printError( "Failed to create effect from file: ", err );
    }
    else
    {
      effectValid = true;
    }
  }

  RCObject_AutoPtr< StateSetHandle > hSS( CreateHandle( StateSetHandle ) );
  {
    WritableObject< StateSet > ss( hSS.get() );
    ss->addAttribute( [...] );

    if ( effectValid )
    {
      ss->addAttribute( hCgfx.get() );
    }
  }

How do I set up a CgFX effect from a text string?

The following code sample shows how you can set up a CgFX effect that you create inside of your application without loading the shader code from a file. For further information on how to create a CgFx effect, see: nvsg::CgFxEffect::createFromLump
More detailed information about Cg/CgFX can be found at http://developer.nvidia.com/page/cg_main.html

string srcCode(
    "float4x4 wvp    : WorldViewProjection; \n"
    "float4x4 world  : World;            \n"
    "float4x4 worldI : WorldI;           \n"
    "float4x4 viewI  : ViewI;            \n"
    "                                    \n"
    "struct appdata {                    \n"
    "  float4 Position   : POSITION;     \n"
    "  float4 texcoord0  : TEXCOORD0;    \n"
    "  float4 Normal     : NORMAL;       \n"
    "};                                  \n"
    "                                    \n"
    "struct vertexOutput {               \n"
    "  float4 Position   : POSITION;     \n"
    "  float4 texcoord0  : TEXCOORD0;    \n"
    "  float4 texcoord1  : TEXCOORD1;    \n"
    "  float4 texcoord2  : TEXCOORD2;    \n"
    "  float4 texcoord3  : TEXCOORD3;    \n"
    "  float4 texcoord4  : TEXCOORD4;    \n"
    "};                                  \n"
    "                                    \n"
    "struct pixelOutput {                \n"
    "  float4 col : COLOR;               \n"
    "};                                  \n"
    "                                    \n"
    "vertexOutput mainVS(appdata IN,     \n"
    "  uniform float4x4 WorldViewProj,   \n"
    "  uniform float4x4 World,           \n"
    "  uniform float4x4 WorldI,          \n"
    "  uniform float4x4 ViewI)           \n"
    "{                                   \n"
    "  vertexOutput OUT;                 \n"
    "                                    \n"
    "  OUT.Position = mul(WorldViewProj, IN.Position); \n"
    "  OUT.texcoord0 = IN.texcoord0;     \n"
    "                                    \n"
    "  OUT.texcoord1.xyz = mul(ViewI, float4(0.0, 0.0, 0.0, 1.0)).xyz; \n"
    "  OUT.texcoord2.xyz = mul(World, IN.Position).xyz; \n"
    "  OUT.texcoord3.xyz = mul(IN.Normal, WorldI).xyz; \n"
    "                                    \n"
    "  return OUT;                       \n"
  "}                                     \n"
  "                                      \n"
  "pixelOutput mainPS(vertexOutput IN, uniform samplerCUBE EnvironmentMap) \n"
  "{                                     \n"
  "  pixelOutput OUT;                    \n"
  "                                      \n"
  "  float3 normal       = IN.texcoord3.xyz; \n"
  "  float3 viewVector   = IN.texcoord2.xyz - IN.texcoord1.xyz; \n"
  "                                      \n"
  "  float3 reflVect = reflect(viewVector, normal); \n"
  "  float4 reflColor = texCUBE(EnvironmentMap, reflVect); \n"
  "                                      \n"
  "  OUT.col = reflColor;                \n"
  "                                      \n"
  "  return OUT;                         \n"
  "}                                     \n"
  "                                      \n"
  "texture cubeMap : EnvMap              \n"
  "<                                     \n"
  "  string File = \"nvlobby_new.dds\";  \n"
  "  string TextureType = \"Cube\";      \n"
  ">;                                    \n"
  "                                      \n"
  "samplerCUBE environmentMapSampler = sampler_state \n"
  "{                                     \n"
  "  Texture = <cubeMap>;                \n"
  "                                      \n"
  "  MinFilter = Linear;                 \n"
  "  MagFilter = Linear;                 \n"
  "                                      \n"
  "  WrapS  = Clamp;                     \n"
  "  WrapT  = Clamp;                     \n"
  "  WrapR  = Clamp;                     \n"
  "};                                    \n"
  "                                      \n"
  "technique SimpleReflect               \n"
  "{                                     \n"
  "  pass p0                             \n"
  "  {                                   \n"
  "    VertexProgram = compile vp30 mainVS(wvp, world, worldI, viewI); \n"
  "                                      \n"
  "    DepthTestEnable = true;           \n"
  "    DepthMask = true;                 \n"
  "                                      \n"
  "    FragmentProgram = compile fp30 mainPS(environmentMapSampler); \n"
  "  }                                   \n"
  "}                                     \n"
  );

  bool effectValid = false;
  RCObject_AutoPtr< CgFxHandle > hCgfx( CreateHandle( CgFxHandle ) );
  {
    WritableObject< CgFx > cgfx( hCgfx.get() );
    WritableObject< CgFxEffect > effect( cgfx->getEffect() );

    string err;
    if( !pEffect->createFromLump(srcCode, err) )
    {
      printError( "Failed to create effect from lump: ", err );
    }
    else
    {
      effectValid = true;
    }
  }

  RCObject_AutoPtr< StateSetHandle > hSS( CreateHandle( StateSetHandle ) );
  {
    WritableObject< StateSet > ss( hSS.get() );
    ss->addAttribute( [...] );

    if ( effectValid )
    {
      ss->addAttribute( hCgfx.get() );
    }
  }

How do I use reference counted objects as local variables?

If you want to use reference counted objects as local variables, you can make the code shorter by simply using nvutil::RCObject_AutoPtr pointer.

The following code shows one way to work with reference counted objects, and RCObject_AutoPtr.
void modifySubtree(nvsg::NodeHandle * hNode)
{
  RCObject_AutoPtr< SceneHandle > hScene( CreateHandle( SceneHandle ) );
  {
    WritableObject< Scene > editScene( hScene.get() );
    editScene->setRootNode(hNode);
  }

  RCObject_AutoPtr< ModifyTraverser > traveser( new ModifyTraverser );
  traverser->apply(hScene.get());
}

When using nvutil::RCObject_AutoPtr pointers, you do not have to think about the reference counting. The result is much safer, easier to read, and leads to fewer code lines.

How do I set up hit testing?

The following pseudo code can be used to pick an object in the scene by using a RayIntersectTraverser.

   nvmath::Vec3f rayOrigin;
   nvmath::Vec3f rayDirection;
   int raHeight = int(m_pRA->getViewporitHeight());
   int raWidth  = int(m_pRA->getViewportWidth());

   {
     WritableObject< Camera > camera( m_pRA->getViewState()->getCamera() );
     camera->getPickRay( mousePosX
                       , raHeight-mousePosY
                       , raWidth
                       , raHeight
                       , rayOrigin
                       , rayDirection);
   }

   RCObject_AutoPtr<RayIntersectTraverser> rit(new RayIntersectTraverser);
   rit->setViewState(m_pRA->getViewState());
   rit->setRay( rayOrigin, rayDirection );
   // if you are using MFC
   rit->apply(GetDocument()->getScene());

   if (rit->getNumberOfIntersections() > 0)
   {
       nvtraverser::Intersection intersection = rit->getNearest();
       RCObject_AutoPtr<DrawableHandle> drawable(intersection.getDrawable());

       [...] // now you can, for example, highlight this object
   }

How can I highlight an object in the scene?

The following sample code shows how to do box highlighting of scene objects. See How do I set up hit testing? for details on how to use hit testing to select an object in the scene.

[...] // example code from the hittesting
PrimitiveSetHandle * hPSet = dynamic_cast<PrimitiveSetHandle*>(drawable);
if (hPSet)
{
  {
    WritableObject< PrimitiveSet > ncPrimitiveSet( hPSet );

    if(ncPrimitiveSet->getHighlightObject() != NULL)
    {
      // already highlighted, so remove highlight
      ncPrimitiveSet->attachHighlightObject(NULL);
    }
    else
    {
      // do bounding box highlighting
      ncPrimitiveSet->attachHighlightObject(CreateHandle( HighlightBoxHandle ));
    }
  }

  renderArea->triggerRedraw();
}

How can I set the rotation point?

Use the target point for setting the rotation point. The nvui::RenderArea provides a convenient function (nvui::RenderArea::pickCameraTargetPoint) that needs the current mouse position to set the rotation point. The rotation point is the point on the surface of the object that will be picked at the given mouse position.

if (  setRotationPoint == true
   && renderArea->pickCameraTargetPoint(mousePosX, mousePosY))
{
  setRotationPoint = false;
  renderArea->triggerRedraw();
  [...]
}

How do I extend the NBF loader or saver?

Saver
The NBF saver saves the scene with the help of a traverser (NBFSaveTraverser). This is a 2-pass process. The first pass pre-calculates the file size needed to store the scene. The second pass finally writes scene data to the file. A handler for a custom object could look like the following pseudo code:
enum
{
  NBF_MY_NODE = NBF_CUSTOM_OBJECT,
  NBF_MY_XYZ  // more custom objects
  [...]
}

struct NBFMyNode : public NBFObject
{
  DataType data;
  uint_t offsToRelatedData;
};

void handleMyNode(const MyNode* p)
{
  if ( calculatingStorageRequirements() )
  {
    pseudoAlloc(sizeof(NBFMyNode));
   // pseudoAlloc(anything else related to NBFMyNode);
    [...]
  }
  else
  {
    NBFMyNode * mynode;
    alloc(mynode, sizeof(NBFMyNode));

    // write NBFObject data
    mynode->objectCode = NBF_MY_NODE;
    mynode->isShared = p->isShared();
    mynode->objectDataID = p->getDataID();
    [...]
    // write MyNode data to the file
    mynode->data = p->getData();

    [...]

    // write offset to related data
    RelatedData * reldata;
    mynode->offsToRelatedData = alloc(reldata, x*sizeof(RelatedData));
    // write related data
    reldata->moredata = ...
  }
}
NBFSaveTraverser::calculatingStorageRequirements returns whether the current traverser pass is for calculating what the file size would be. NBFSaveTraverser::pseudoAlloc simply updates the internal byte count by the amount of bytes passed.

For writing data, you should not use m_file directly but alloc! In any case, using m_file directly is prohibited by the compiler (private access). alloc allocates the passed amount of bytes from the file mapping used and returns the file offset of the mapped memory block. After the call to alloc, you can use the pointer passed as the first argument to write data to the file.

Loader
When reading custom objects from an NBF file, it is best to override NBFLoader::loadCustomObject and use mapOffset to map an appropriate amount of bytes into your address space:
void NBFLoader::loadCustomObject(uint_t objectCode, uint_t fileOffset)
{
    switch ( objectCode )
    {
    case NBF_MY_NODE:
        {
            NBFMyNode * mynode = mapOffset(fileOffset, sizeof(NBFMyOffset));
            ....
        }
        break;
    case ...
    }
}
NBFLoader::loadCustomObject will be called from the framework with the custom object code found and the offset at which the object resides inside the file.

How do I use Geometry Shaders/Programs?

There is an example called "geometryShaderBall.nbf" in the media/scenes directory. It uses geometry.cgfx in the media/effects directory to visualize the normals on the ball. Note that you must have a Quadro 4600 or better (G80 class) in order to use Geometry Programs.

How do I use Texture Arrays?

There is a new sample called TextureArrayViewer that shows how to set up texture arrays and how to use them from a shader. Note that texture arrays are not supported by the fixed function pipeline, and therefore MUST be used from a cgfx effect.

How do I use the new Texture Formats?

See the separate document on all of the new texture formats.

What are the general guidelines to achieve render performance?

The following is a list of general guidelines the application programer should follow to achieve reasonable render performance.

Reuse tree objects if appropriate
Extensive memory consumption could have negative impact on application performance. Hence, reuse objects wherever appropriate instead of using real copies (clones) of these objects. Car wheels are a good example of objects that are appropriate for reuse them. In the below example the car wheel is referenced 4 times. This saves 3/4 of the memory that would be consumed if 4 separate wheels were used instead.
...
// a GeoNode representing a car wheel
RCObject_AutoPtr< GeoNodeHandle > wheel( CreateHandle( GeoNodeHandle ) );
// ... setup wheel - not shown here

// create transforms
RCObject_AutoPtr< TransformHandle > hChassis(CreateHandle( TransformHandle ) );
RCObject_AutoPtr< TransformHandle > hfrontLeft(CreateHandle( TransformHandle ));
RCObject_AutoPtr< TransformHandle > hfrontRight(CreateHandle( TransformHandle));
RCObject_AutoPtr< TransformHandle > hbackLeft(CreateHandle( TransformHandle ));
RCObject_AutoPtr< TransformHandle > hbackRight(CreateHandle( TransformHandle ));

// create nodes for positioning the wheels
{
  WritableObject< Transform > frontLeft( hfrontLeft.get() );
  WritableObject< Transform > frontRight( hfrontRight.get() );
  WritableObject< Transform > backRight( hbackRight.get() );
  WritableObject< Transform > backLeft( hbackLeft.get() );

  // ... setup the transforms - not shown here

  // put it all together
  frontLeft->addChild( wheel.get() );
  frontRight->addChild( wheel.get() );
  backLeft->addChild( wheel.get() );
  backRight->addChild( wheel.get() );
}

{
  // for positioning the whole car
  WritableObject< Transform > chassis( CreateHandle( TransformHandle ) );

  chassis->addChild( hfrontLeft.get() );
  chassis->addChild( hfrontRight.get() );
  chassis->addChild( hbackRight.get() );
  chassis->addChild( hbackLeft.get() );
}

Always strive to build balanced trees
The horizontal and vertical extends of a render tree should be balanced to some extent.
Apply the VertexUnifyTraverser if appropriate.
The VertexUnifyTraverser changes the vertex data sets in a way that the vertex usage count will be maximized the particular scene. This could save memory bandwith, and hence, helps to increase performance of applications that are bound by memory bandwith.
Put topographical connected geometries in one GeoNode.
Geometries that are topographically connected should be placed underneath one single GeoNode to reduce traversal overhead. This in particular helps to increase performance of applications that are CPU bound.
Do not apply optimize traversers every single frame
Optimize traversers as, for example, the VertexUnifyTraverser, perform complex, and hence, almost expensive tasks. Therefore, optimize traverser are intended to perform one time operations on the render tree. It is recomented to apply optimize traversers right after the scene has been loaded into process memory.
Always share OpenGL contexts running on the same render tree
Shared OpenGL contexts share resources like VBOs, display lists, textures, and programs. This can save a lot of video memory on you graphics board, and hence, might have a positive impact on render performance.
Always share TextureImages where appropriate.
Objects that use the same texture should always reference the same TextureImage to save both, system memory and video memory.
Try different geometry cache techniques to find the one providing the best performance
Dependent on the particular scene, one geometry cache technique, that is - either display lists or VBOs, might perform better than the other and vice versa. This is easy to test with the ViewerVR application - it allows you to switch back and forth between VBO and Display List caching to view the performance impact on your databases.
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Fundamental Concepts of the NVSGSDK

See also:
Important Concepts - Must Read for All Developers

Overview

This section provides an overview of the fundamental concepts involved in using the NVSGSDK. It provides an explanation of many of the basic issues that developers deal with when creating NVSG-based applications.

The NVSGSDK provides tremendous control over almost all aspects of scenegraph programming. While there is a large amount of explanatory information, the material is broken down into smaller sections to make the information more manageable. This section discusses most of the basic issues in simple terms, with hyperlinks to sections in the NVSGSDK that contain more detailed information.

Writing NVSG-Based Applications

Development Tool to Use

The development tool for creating an Windows-based and NVSG-based application is Microsoft Visual C++. For a Linux-based and NVSG-based application one can use the gcc compiler.
See also:
What You Need to Get Started

Refer to the Sample Programs

Included with the SDK are sample programs that provide examples of how to write NVSG-based applications. These sample programs are found in the sub-directories of /NVSGSDK/SRC/SAMPLES, and the source code for these sample programs is very instructive.

See also:
Building the Sample Files for information on building and running the sample programs.

Basic Development Process

Using NVSG essentially involves the following processes:

1 - Create an NVSG Project

See also:
Creating a New NVSG Project

2 - Create a Scenegraph

A scenegraph is created and maintained with NVSG objects such as nvsg::Triangles, nvsg::Transform, or nvsg::StateSet. These classes determine the geometries and the visual attributes of the scene, and don't know anything about rendering, storing, etc..
See also:
Working With NVSG Classes

3 - Traverse the Scenegraph

After the scenegraph is created, actions such as rendering, storing, or searching, are performed on the scenegraph by a class called Traverser. These classes know how to traverse a scene and perform actions on the scene objects based on the traverser type. For example, there is an nvtraverser::GLTraverser, that renders the scene using OpenGL. Another traverser is the nvtraverser::SearchTraverser, that traverses a scene and searches for all occurrences of a specified class.
See also:
Traversers
Working with Traversers

Don't do this!

Here are some simple things you should be aware of...

Changing the number and or the position of children while iterating

(Groups)

During child traversal you must not change the number or the position of children. Overload and use postTraverseGroup() for this.

Back to Fundamental Concepts

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Hit Testing

Hit testing is accomplished using the RayIntersectTraverser class. NVSG does not use OpenGL-specific hit testing. Instead, NVSG performs hit testing directly on the scenegraph data, making it device independent.

The following sample code makes use of RayIntersectTraverser. In this example we try to determine the nearest object the ray hits, starting at the origin.

//[...]

// setup the RayIntersectTraverser
RayIntersectTraverser * pPicker;
pPicker = new RayIntersectTraverser;
pPicker->addRef();
pPicker->setRay(rayOrigin, rayDirection);

// do the hit test
pPicker->apply(m_viewState, m_scene);

// determine the nearest object
Drawable * pHitObject = NULL;
if (pPicker->getNumberOfIntersections() > 0)
{
  Intersection intersection = picker->getNearest();
  pHitObject = intersection.getDrawable();
  pHitObject->addRef();
}

//[...]

// clean up
pPicker->removeRef();
pPicker = NULL;

if (pHitObject)
{
  pHitObject->removeRef();
  pHitObject = NULL;
}

//[...]

See nvtraverser::Intersection and nvtraverser::RayIntersectTraverser documentation for further details.

Back to Advanced

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


How to Use Volumes and the Volume Bricker

There is a small selection of prepared volume files, ready to be loaded with the ViewerVR, located at "media/volumes". Each consists of the scene file (.nbf), a volume texture description file (.dat), and a volume texture (.raw). When you load one of those scene files into the ViewerVR, the Volume Editor is filled with the corresponding data in the Transfer Function Editor and the CgFx section. There are a number of sample effect files in the "media/effects" directory, each one starting with "volvis" (e.g. "volvisIsoSurface.fx").

At the top of the Volume Editor, you can select the Voxel Limit Fraction. When you have bricked the volume file (see How to brick volumes for NVSG usage?), the volume is available in different levels of accuracy. If you have, for example, three levels of accuracy available, but a single voxel in the first level covers approximately only less than that fraction of the window, in both x and y, that first level is used for rendering. If it's larger than that fraction, the next accurate level is tested for usage.

In the Transfer Function Editor section of the Volume Editor, you can modify the Transfer Functions to use. By default, a simple ramp is used. Each voxel value is mapped to a specified RGBA value, and that mapping can be modified in the Transfer Function Editor. The upper pane controls the mapping to the red, green, and blue channel, the middle pane controls the mapping to the alpha channel, while the lower pane controls the gradient mapping.

In the CgFx section of the Volume Editor, you can select the CgFx effect to be used for rendering volume file. There are some sample effects for example an XRay effect (volvisXRay), an isosurface effect (volvisIsoSurface), and some others. You can easily create others, but should always provide the following tweakables, defined in volvisBase.h: brickPosition, brickTextureSize, overlappedBrickSize, and overlapSize. These tweakables are used by the framework to position and scale the bricks appropriately. They should not be modified manually. All the other tweakables of the effect are displayed in the CgFx section of the Volume Editor for manual manipulation.

How to use CgFx shaders for volume rendering

As mentioned above, there are a number of tweakables that have to be part of the CgFx shaders to run properly in the volume rendering step. All those values are calculated by the framework on a per-brick basis and fed into the shader.

The tweakable "brickPosition" has to be a vector of three floats (float3). It specifies the position of the current volume brick in the world.

The tweakable "brickTexture" has to be a texture, and this texture has to be used in a sampler3D. It specifies the texture holding the volume data for the current volume brick.

The tweakable "brickTextureSize" has to be a vector of three ints (int3). It specifies the size of the current texture in texels, with the x-component specifying the width, y-component specifying the height, and z-component specifying the depth.

The tweakable "overlappedBrickSize has to be a vector of three floats (float3). It specifies the size of a brick including any overlapping.

The tweakable "overlapSize" has to be a vector of three floats (float3). It specifies the size of the overlapping in a volume brick.

Note, that brickPosition, overlappedBrickSize, and overlapSize can be used to transform coordinates from texture space to object space and vice versa, using the following functions:

float3 objectToTextureSpace( float3 objCoord )
{
  return( (objCoord - brickPosition) / overlappedBrickSize + overlapSize );
}

float3 textureToObjectSpace( float3 texCoord )
{
  return( (texCoord - overlapSize) * overlappedBrickSize + brickPosition );
}

Using Annotations in the CgFx shaders

One can add annotations to the tweakables of a CgFx shader to communicate information to the application.

In the file media.cg, for example, there are three tweakables of type sampler1D, named TFColorSampler, TFAlphaSampler, and TFGradientSampler. Each one holds a set of three annotations, to be used in the VolumeTexture editor of the sample application ViewerVR: an annotation of type string, named Type; an annotation of type string, named Description; and an annotation of type int, named Channels. The sampler1D TFColorSampler, for example looks like that:

sampler1D TFColorSampler
< string Type = "TransferFunction";
  string Description = "Color Mapping";
  int Channels = 3;
> = sampler_state
{
  Texture   = <colorTransFunc>;
  MinFilter = Linear;
  MagFilter = Linear;
  WrapS = ClampToEdge;
};

The annotation named Type is set to "TransferFunction" for each of the samplers, thus allowing the application to look for tweakables with an annotation named Type with that value, to allow dynamic creation of interface elements for each "TransferFunction" found.

The annotation named Description then can be used to name the interface elements for that "TransferFunction".

And the annotation named Channels holds the number of channels to be expected in the texture of that sampler.

All those annotations are optional. The shader does not need them, neither does the application. But if they are there, the application can react on them and modify its behaviour or user interface accordingly.

How to brick volumes for NVSG usage?

1) If you have a *.raw file (such as sample.raw), make sure to have a corresponding *.dat file (sample.dat):
A *.dat file is a simple text file with the following contents:

ObjectFileName: "sample.raw"
Resolution: 60 143 212
SliceThickness: 1 1 1
Format: UCHAR
ObjectModel: LUMINANCE

The entry "ObjectFileName" must be set to the name of the .raw file.

The entry "Resolution" must be set to the width, height, and depth - in that order - of the dataset.

The entry "SliceThickness" must be set to the width, height, and depth - in that order - of each voxel in the dataset (the spacing).

The entry "Format"> must be set to the format of each component of each voxel. The supported formats are UCHAR, CHAR, USHORT, SHORT, UINT, INT, HALF, and FLOAT.

The entry "ObjectModel" must be set to the format of each voxel. The supported formats are RGB (three values per voxel), RGBA (four values per voxel), LUMINANCE (one value per voxel), and LUMINANCE_ALPHA (two values per voxel).

2) Call VolumeBricker.exe to create a bricked version of the .raw file.

VolumeBricker.exe is a small console program that creates a number of .dat/.raw files, each pair representing one brick of the original .raw file. Those bricks are used with NVSG.

Use VolumeBricker.exe as follows:

VolumeBricker.exe sourceFile destinationFile width height depth overlap [filter]

"sourceFile" is the name of the .dat file to brick.

"destinationFile" is the name of the top level brick file. The other brick files are derived from that file name by extending it by a number of digits. In that scheme, the top level brick will be named "destinationFile.raw/.dat". Second level bricks will be named "destinationFile0.raw/.dat", "destinationFile1.raw/.dat", ..., "destinationFile7.raw/.dat", where "destinationFile0.raw/.dat" represents the left lower front octel, "destinationFile1.raw/.dat" represents the right lower front octel, and so on. Third level bricks wil be named "destinationFile00.raw/.dat", "destinationFile01.raw/.dat">, ..., "destinationFile07.raw/.dat", "destinationFile10.raw/.dat", ..., "destinationFile77.raw/.dat" with same reasoning on positions inside the corresponding bricks on the second level.

"width", "height", and "depth" are the size of each brick file. They all must be power-of-two.

"overlap" gives the size of the overlap between the bricks. Note that this overlap is part of the size given by "width", "height", and "depth"! Therefore, "overlap" must be less than half of the smallest value of "width", "height", and "depth".

Finally, "filter" describes how to filter down between the brick levels. The supported filters are "box", "triangle", "bell", "bspline", and "lanczos3".

After VolumeBricker has bricked a .raw file, the lowest level bricks (those with the largest number of digits appended to the "destinationFile" name) are an exact representation of the original volume. No filtering has been performed. Because the size of the bricks is always a power of two, that lowest level of bricks might represent a larger volume than the original dataset (with a size that is not necessarily a power of two). Bricks that are not completely located inside the original volume are padded with zeros; bricks that would be completely outside the original volume are omitted. Each of the higher level bricks is created by filtering up to eight bricks of the lower level brick that represent the same part of the volume. That is, "destinationFile.raw/.dat" is a filtered combination of "destinationFile0.raw/.dat",...,"destinationFile7.raw/.dat". Each brick, then, no matter on what level, has the same (texture-)size, but the volume it represents depends on its level.

3. Now the volume files are ready to use with NVSG.

A VolumeNode needs both the "sourceFile" name and the "destinationFile" name (that is the name of the level 0 brick). The names of the bricks of the other levels are automatically determined as described above.

Back to Advanced
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


How to Derive an NVSG Object

Introduction

The NVSGSDK comes with an extensive set of NVSG objects that we also refer to as NVSG Core Classes (see also Overview of the Principal Classes). However, some situations might require the creation of one or more new NVSG objects in order to extend the set of available core classes. This section discusses the key points in inventing and customizing NVSG objects.

See also the source code of the CuboidViewer tutorial in nvsgsdk/src/samples/CuboidViewer to see how to derive your own node.

The Base Class for NVSG Objects

Objects that are intended to become a part of the scenegraph - that is, an NVSG object - must inherit from Object or an object-derived class.

Example of a custom defined GeoNode:

// MyGeoNode.h
#include "nvsg/CoreTypes.h"
#include "nvsg/GeoNode.h" // base class definition

class MyGeoNode : public nvsg::GeoNode
{
public:
  MyGeoNode();
  //...
};

// convenient typedef for the associated handle
typedef nvutil::Handle<MyGeoNode, GeoNodeHandle> MyGeoNodeHandle;

NVSG Object Type Identification

For a custom traverser (see How to Derive a Traverser) it is essential to identify all actual scenegraph components (nodes and nodecomponents) while traversing the scenegraph, and to call the corresponding handler routine for a particular object. For this reason, all concrete NVSG object types must be assigned to a unique object code. Secure object codes for custom defined NVSG objects start at nvsg::OC_CUSTOMOBJECT.

Choosing an object code lower than nvsg::OC_CUSTOMOBJECT for a custom-defined NVSG object results in undefined runtime behavior!

Example of custom object code definitions:

// MyObjectCodes.h
#include "nvsg/Object.h" // object code defines

enum
{
  OC_MYGEONODE = OC_CUSTOMOBJECT
, OC_MYGEOSET   // = OC_CUSTOMOBJECT+1
, OC_MYMATERIAL // = OC_CUSTOMOBJECT+2
};

// ...

It is best to assign the unique object code at the object's construction time:

// MyGeoNode.cpp
#include "MyGeoNode.h" // MyGeoNode definition
#include "MyObjectCodes.h" // custom object codes

using namespace nvsg;

MyGeoNode::MyGeoNode()
{ // assign the unique object code
  m_objectCode = OC_MYGEONODE;
}

Back to Advanced

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


How to Derive a Traverser

Operations on an NVIDIA Scenegraph (NVSG) are typically performed by means of a Traverser. In this operation a traverser, starting at the scene's root node, iterates a scenegraph and performs a defined operation for each object (nodes, etc.) in the scenegraph.

Using Traverser Base Classes

In its core, the NVSGSDK provides a set of different traversers for performing different tasks. When customizing operations on an NVSG, the developer must derive from the appropriate traverser. With regard to the type of operations that a traverser can perform on an NVSG, we distinguish between shared traversers, having nvtraverser::SharedTraverser as base class, and exclusive traversers, having nvtraverser::ExclusiveTraverser as base class.

A SharedTraverser provides read-only access to the objects that make up a NVSG tree. A RenderTraverser is a typical example of a SharedTraverser. An arbitrary amount of SharedTraverser can simultaneously operate on a single tree in a multithreaded runtime environment. To ensure multithreaded safeness, the NVSG runtime must be appropriately initialized through a call to nvsg::nvsgInitialize:

    // the application's entry point
    int main(int argc, char *argv[])
    {
      // inititialize the NVSG runtime to run safe in a multithreaded environment
      nvsg::nvsgInitialize(NVSG_MULTITHREADED);
      [...]

      // perform proper termination of the NVSG runtime immediately before the program ends
      nvsg::nvsgTerminate();
    }

A SharedTraverser's handler functions will be called with a pointer to a const object of the corresponding type of object to be handled. The implementer of the particular override function can rely on the framework already has locked the object for shared (read-only) access when the override handle function is called.

Example: Declaration of a handleGeoNode override of a SharedTraverser derived class.

    class MySharedTraverser : public SharedTraverser
    {
        [...]
    protected:
        // handleGeoNode override
        void handleGeoNode( const GeoNode * gnode ); // the passed GeoNode already is locked
                                                     // for shared access when called!
        [...]
    }

A traverser that intends to modify objects in a tree while traversing, must derive from ExclusiveTraverser. An OptimizeTraverser is a typical example of an ExclusiveTraverser. Only a single ExclusiveTraverser at a time can operate on the same tree objects. An ExclusiveTraverser's handler functions will be called with a pointer to an object of the corresponding type of object to be handled. The implementer of the particular override function can rely on the framework already has locked the object for exclusive (read-write) access when the override handler function is called, and hence, can access the full public interface of that particular object.

Example: Declaration of a handleGeoNode override of an ExclusiveTraverser derived class.

    class MyExclusiveTraverser : public ExclusiveTraverser
    {
        [...]
    protected:
        // handleGeoNode override
        void handleGeoNode( GeoNode * gnode ); // the passed GeoNode already is locked
                                               // for exclusive access when called!
        [...]
    }

Iterating Functionality

The two traverser base classes SharedTraverser and ExclusiveTraverser provide base iteration over a NVSG tree. Derived traversers can and should always fall back on this base functionality for iterating 'known' NVSG objects, or objects that are part of the original NVSGSDK. For a new NVSG object that was invented by a third party developer (see How to Derive an NVSG Object), iteration for that object must be implemented by a derived traverser. It is recommended for a custom traverser to implement the iteration of new invented NVSG objects by means of the nvtraverser::Traverser::traverseObject overloads of the abstract Traverser base class, to ensure proper locking of the iterated object, and to ensure proper calling of the object's corresponding handler function.

Per-Object Locking Functionality

Another fundamental operation that is performed by the SharedTraverser and ExclusiveTraverser base classes is the per-object locking for either shared access or exclusive access, resp.. The particular per-object locking will be performed inside the nvtraverser::Traverser::traverseObject overloads of the abstract Traverser base class.

Deriving a Traverser for Known NVSG Objects

In many cases developers don't need to extend the set of available NVSG Objects but only need to add a new operation to perform on an NVSG using a derived traverser. It is recommended to inherit your custom traverser from an already existing traverser that matches most of the requirements. If none exist, you should derive directly from either SharedTraverser , or ExclusiveTraverser , depending on what access to the tree objects is needed.

To add a new operation for a certain NVSG object, the developer needs to override the matching handler function for that object.

The SharedTraverser and ExclusiveTraverser base classes provide a virtual member function for each known and concrete NVSG object to be handled. The base implementations of these handler functions do not operate on the particular object but instead iterate over that object in a correct manner.For iterating purposes, it is strongly recommended to always fall back on the base implementation for overloaded handler functions:

// MySharedTraverser.cpp implementation file
#include "MySharedTraverser.h"
#include "nvsg/Group.h" // definition of Group

using namespace nvtraverser;
using namespace nvsg;

void MySharedTraverser::handleGroup(const Group * p)
{
  // ... add custom functionality

  // iterate subsequent objects by calling the base implementation
  SharedTraverser::handleGroup(p);

  // ... add some more custom functionality
}

Deriving a Traverser for Newly Invented NVSG Objects

One can think of situations were an extended functionality requires a newly invented NVSG object (see also How to Derive an NVSG Object). Deriving a custom traverser for traversing newly invented NVSG objects requires additional steps.

The new traverser must provide a new handler function for the new object, and add it to the base class' handler function table by means of the base class' member function SharedTraverser::addObjectHandler , or ExclusiveTraverser::addObjectHandler , resp..

Example of a custom traverser that handles a newly invented NVSG object that inherits from Group:

// NewObject.h
// #include "nvsg/Group.h"

// A NewGroup 'is a' Group
class NewGroup : public nvsg::Group
{
  // ...
};

typedef nvutil::Handle<NewGroup, GroupHandle> NewGroupHandle;

// MySharedTraverser.h file
#include "nvtraverser/Traverser.h" // base class definition

// forward declare class NewGroup to satisfy includees
class NewGroup;
// forward declare class CullData to satisfy includees
namespace nvsg
{
  class CullData;
}

class MySharedTraverser : public SharedTraverser
{
  // ...
  protected:
    // constructor to deal with initial work
    MySharedTraverser();
    // clean up
    virtual ~MySharedTraverser();

    // overloadable handler for NewGroup
    NVSG_API virtual void handleNewGroup(const NewGroup * p);

  private:
    // implementation details that handle iterating over a NewObject
    void a_private_function_that_handles_iteration(const NewGroup * p);
    void a_private_function_that_handles_conditional_iteration(const NewGroup * p, const nvsg::CullData * p);
};

// - - - - - - - - - - - - - - - - - - - - - - - -
// MySharedTraverser.cpp file
#include "MySharedTraverser.h"
#include "NewObject.h" // NewObject definition

MySharedTraverser::MySharedTraverser()
{
  // ...
  // add the new handler function to the base classes handler table
  addObjectHandler(
    OC_NEWGROUP   // object code for the new object NewGroup
                  // this must be provided by the author of NewGroup
  , &MySharedTraverser::handleNewGroup // handler function
  );
  // ...
}

A handler function for a newly invented NVSG object must correctly iterate over the new object in order to ensure that the new object is traversed in a correct manner as part of the NVSG. If, for example, the new NVSG object inherits from Group , the handler function must take care of properly iterating through the child nodes. Or, for a concrete Node , the actual cull tree also needs to be correctly maintained while iterating over the new object.

// MySharedTraverser.cpp

// ...

void MySharedTraverser::handleNewGroup(const NewGroup * p)
{
  // at entry, call overloadable preTraverseGroup
  if ( preTraverseGroup(p) )
  {
    // get the topmost cull tree
    const CullData  * cd = m_cullStack.top();

    if ( ! cd )
    {
      //  if there's no cull data, just traverse

      // ... traverse children
      a_private_function_that_handles_iteration(p);
    }
    else if ( cd->getCullCode() == CC_IN )
    {
      //  this group is trivial in, so just push a NULL pointer on cull stack and traverse
      m_cullStack.push( NULL );
      // ... traverse children
      a_private_function_that_handles_iteration(p);
      m_cullStack.pop();
    }
    else
    {
      //  this group is at least partly visible, so traverse through all children that are not out
      a_private_function_that_handles_conditional_iteration(p, cd);
    }

    // call overloadable postTraverseGroup right before leaving
    postTraverseGroup(p);
  }
}

If, as in the previous example, the newly invented NVSG object inherits from Group, the corresponding handler function must iterate or conditionally iterate over the Group's child nodes. In order to keep the child nodes locked while being traversed, it is strongly recommended to call the base class' member function traverseObject for each child node that should be traversed, instead of just calling the corresponding handler function for the particular child node.

// MySharedTraverser.cpp

// bad implementation:
void MySharedTraverser::a_private_function_that_handles_iteration(const NewGroup * p)
{
  // unconditionally traverse all child nodes
  for ( size_t i=0; i<p->getNumberOfChildren(); ++i )
  {
    // bad idea: identifying a child node's type this way doesn't perform well!
    switch ( p->getChild(i)->getObjectCode() )
    {
    case OC_GEONODE: // handle a GeoNode child
      handleGeoNode(p->getChild(i)); // bad idea: child GeoNode will not be locked during traversal!
                                     // dangerous in multithreaded environments!
      break;
    case ... // handle other typed children
    ...
    }
  }
}

// good implementation:
void MySharedTraverser::a_private_function_that_handles_iteration(const NewGroup * p)
{
  // unconditionally traverse all child nodes
  for ( size_t i=0; i<p->getNumberOfChildren(); ++i )
  {
    traverseObject(p->getChild(i)); // good idea for two reasons:
                                    // (1) fast lookup the corresponding handler function
                                    // (2) the child node is locked during traversal
  }
}

Back to Advanced

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


How to Enable Memory Leak Detection in Debug Mode

Controlling memory leaks (the failure to properly deallocate memory that was previously allocated), is tightly related to heap management. Unlike stack variables that are automatically deallocated when they are running out of scope, heap objects must be actively deallocated if they are no longer referenced. Leaking large amounts of memory leads to out-of-memory conditions, which in turn results in bad runtime behavior. For this reason, the ability to detect memory leaks during development is indispensable.

Including the DbgNew.h Header File

The object allocator used for NVSG Objects provides automated leak detection in debug mode. To enable this feature, implementation files (*.cpp) must include the DbgNew.h header as the last header file.

// memory leak detection
#include "nvutil/DbgNew.h"

When Using Allocation Code Within Header Files

If your application uses allocation code within header files, you need to restrict leak detection to that particular header file. This can be done as follows:

#ifdef _DEBUG
# ifndef new
#  define new new(__FILE__, __LINE__)
#  define _DEFINED_DBGNEW // restrict the 'new' macro to this header file only
# endif
#endif

// implementation within header utilizing object allocation code
// ...

#ifdef _DEFINED_DBGNEW
# undef new
#endif

These statements essentially re-define the 'new' keyword to force the object allocator to track allocations. If you fail to include these statements wherever allocation code is used, you will get an assertion warning you that memory leak detection is bypassed in debug mode.

If the NVSG object allocator detects memory leaks, it outputs the leak warnings to the attached debugger when the NVSG library terminates. A leak warning might look similar to the following line of output:

****Memory Leak Detected*** Source: c:\src\test.cpp, Line: 51, Ptr: 0x0B4D5A80

The output reports the source file and source line where allocation of the leaked memory block took place, and also the memory address of the leaked block.

Leak Detection of Non-NVSG Allocations

This mechanism only tracks allocations performed by the NVSG object allocator nvutil::IAllocator. To track allocations of built-in types or non-NVSG types, refer to the documentation about memory leak detection mechanisms provided by the C-runtime. The C-runtime memory leak detection works in parallel with the memory leak detection provided by the NVSG object allocator.

Back to

  • Important Concepts - Must Read for All Developers
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Working with Traversers

Using a Traverser is very simple. While it is a four-step process, one process might be a one-time operation and two processes are optional:

  1. Create a Traverser.
    A Traverser can be created as any other object. The predefined concrete Traversers don't need a constructor argument.
    For example to create a SearchTraverser , do the following:
        SearchTraverser  * st;
    st = new SearchTraverser;
    st->addRef();
  2. Initialize the Traverser (optional).
    Some Traversers might require some initialization.
    For example, to tell the SearchTraverser cst to look for all Nodes of type LightSource , do the following:
        st->setBaseClassSearch(true);
    st->setClassName("class nvsg::LightSource");
  3. Do the traversal.
    Call the member function apply of the Traverser:
        st->apply(scene);
  4. Get the results of the traversal (optional).
    Some Traversers might create information that can be queried after the traversal. For example, to get the results of a search traversal do the following:
        const vector<const Object *> & searchResults = st->getResults();

  1. Release the traverse.
    If you do not use the traverser anymore, simply decrement the reference count:
        st->removeRef();

A RenderTraverser like the GLTraverser is even easier to use:

  RenderTraverser * rt = new GLTraverser;
  rt->addRef();
  rt->apply(scene);
  rt->removeRef();
However, a RenderTraverser needs some prerequisites to be fullfilled, as there has to be a valid drawing environment. This Environment might depend on the type of RenderTraverser. For Details, see the sample application SimpleViewer.

See also:
How to Derive a Traverser
Back to Fundamental Concepts
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


How to Use the Sample Viewer

NVIDIA provides a sample viewer ViewerVR.exe. This is a demo viewer that you can use to familiarize yourself with the some of the capabilities of NVSG.

The following sections describe how to use ViewerVR.exe:

  • Main Screen

  • Toolbars

  • Command Line Parameters

  • Cluster Viewer

Main Screen

Toolbars

The Render Toolbar

1.-5. Change Drawstyle

Click to switch between different drawstyles:

1. Points - Render the vertices of the model as point primitives.
2. Wireframe - Render the model as wire frame model.
3. Shaded - Render using simple shader support.
4. Textured - Enable textured rendering.
5. Shader On - Render the model with CgFX effects enabled.

6. Shadows

Opens the shadow settings dialog, which offers to enable shadowed rendering. The shadow map size and the shadow intensity are additional options.

7. Material Editor

Opens the material editor, which lets you modify the material, textures, and shaders for a selected object.

  • To make the material of an object the current/active material in the material editor you can simply double-click onto the object and the material editor will highlight the corresponding material.
  • You can also assign a material to a specific object using drag and drop.

8. Volume Editor

Opens the volume editor, which lets you edit transfer functions and volume effect parameters.

9. Geometry Smoothing

Adjusts the vertex normals, so the face joints appear smooth. You can define a crease angle (the angle between the face normals) at which the edge will be smoothed.

10. Optimizer Dialog

Opens the optimizer dialog, which allows to apply different kind of optimizers on the current model. Optimizers strive to modify the current scene graph towards optimal rendering performance.

11. Triangulate Scene

Traverses the current model's geometry and converts quad primitives to triangle primitives, and quad strip primitives to triangle strip primitives.

12. Stripify Scene

Traverses the current model's geometry to convert independent triangle primitives to triangle strips, and independent quad primitives to quad strips. Prior to launch, a dialog opens which offers to modify the minimum strip length to generate during conversion.

13. Performance Settings

Opens the performance settings dialog, which allows to select the geometry caching mode to apply, and which sorting strategy to use. Provided geometry caching modes to select are vertex buffer objects (VBO) or display list (DL). Sorting strategies to choose are either none sorting, sorting by z-depth, which enables rendering of all opaque objects from front to back for optimal z-culling, or state sorting to minimize state changes while rendering.

14. Local Viewer

Enables the local viewer light model. If enabled, specular reflections on a surface are computed from the origin of the eye coordinate system. Otherwise, specular reflection angles take the view direction to be parallel to and in the direction of the z-axis, regardles of the location of the vertex in eye space.

15. Separate Specular Color

Affects appearance of specular highlights on lit surfaces. In particular, for textured objects it produces specular highlights which are the color of the lights.

16. FSAA and DoF Settings

Opens the FSAA and DoF settings dialog, which allows for modifying full-scene anti-aliasing (FSAA) settings, and depth of field (DOF) settings.

17. Transparency Dialog

Opens the transparency dialog, which allows the selection of different transparency modes.

  • You can disable the standard transparency if you use a shader for transparent materials.
  • Stippled is a very cheap transparency, but also the least attractive.
  • When using blended transparency, the viewer does not sort the objects. This can result in artifacts.
  • Sorted blended transparency generates a more convincing appearance of scenes containing transparent objects. This requires sorting.
  • Order-independent transparency does not require ordered rendering.

18. Culling Dialog

Opens the culling dialog, which offers the selection of a certain cull strategies to apply during rendering. Frustum culling and occlusion culling are currently provided.

The Stereo Toolbar

The stereo toolbar allows to manipulate the Quad-buffered OpenGL stereo settings. It is activated only if stereo was enabled before through the NVIDIA Control Panel.

19. Stereo On

Toggles the enable state of stereoscopic rendering.

20.-22. Stereo Offset

These buttons allow you to adjust the eye distance in order to obtain an optimal viewing result

20. Increases the eye distance
21. Resets the eye distance to an appropriate default
22. Decreases the eye offset

23.-25. Zero Offset

These buttons allow you to adjust the focus plane in order to obtain an optimal viewing result

23. Decreases the focus distance
24. Restores the default focus distance
25. Increases the focus distance

26. Reverse Views

This action is required if the left and right images initially are not in sync with the stereo shutter glasses.

The View Toolbar

27. View All

Zooms to the extents of the current model to see the complete scene.

28. Undo View All

Allows you to undo the last view all command.

29. Set Rotation Point

Click to set the rotation point in a scene. When you select a face in the scene, the selected point on the face becomes the new rotation point.

30. Set Selection Mode

Enables the selection mode, which lets you select objects in the scene.

31. Viewing Mode

Re-enables the viewing mode, which lets you manipulate the camera/model using the camera manipulator.

See 44. Trackball Manipulator - Examiner Mode , 45. Walk Manipulator - Walk Mode , and 46. Flight Manipulator - Flight Mode .

32. Bounding Box Highlighting

If enabled, selected objects in the scene are rendered surrounded by their particular bounding box.

33. Wire frame Highlight

If enabled, selected objects in the scene are rendered with the highlighted wire frame model on top.

34. Save Home Position

Saves the current camera settings - such as position and zoom - as new home position.

35. Set To Home Position

Sets the view to the last saved home position.

36.-38. Named Views

These buttons allow for managing named views.

36. Restore a named view from a list of previously saved views
37. Define a new named view.
38. Remove a named view from alist of previously saved views

39. Edit Camera

Opens the camera editor, which enables you to modify camera settings. It also allows for adding or removing camera headlights.

40. Full screen Mode

Click to switch to full-screen mode. No frames, menus, or toolbars are shown in full-screen mode. Right-click the screen to open the context menu in full-screen mode. From the menu you can switch back to windowed mode.

41. Play Animation

This button is enable only if the current scene contains an animation. Click to start the animation. Click again to stop the animation.

42. Convert Animation

Click to convert a framed animation to a linear interpolated animation.

43. Attach Object Manipulator

Allows you to attach a camera manipulator to a particular object. After you clicked this button the cursor changes to a crosshairs. Move the crosshairs over the object of interest, and click again to attach the camera manipulator to the object. The cursor changes back to the hand cursor. You can now zoom, rotate, and pan the object:

Keys & Buttons

  • Left mouse button - Rotate
  • Middle mouse button - Pan
  • Left + middle mouse button - Zoom

Click 31. Viewing Mode to exit from the object manipulator mode.

44. Trackball Manipulator - Examiner Mode

Click to set the trackball camera manipulator, which is active when the viewer is set to viewing mode (See 31. Viewing Mode )

The trackball manipulator interprets mouse movements as a trackball input. (Imagine a big sphere centered inside of the viewport which you lay your hand on and rotate.) The manipulator also allows you to dolly and move the objects of the scene.

Keys & Buttons

  • Left mouse button - Rotate
  • Middle mouse button - Pan
  • Left + right mouse button - Dolly

45. Walk Manipulator - Walk Mode

Click to set the walk camera manipulator, which is active when the viewer is set to viewing mode (See 31. Viewing Mode )

The walk manipulator interprets/converts mouse movements into walk-through camera movements.

Keys & Buttons

  • Left mouse button - Walk forward.
  • Middle mouse button - Walk backward.
  • W-key - Increase speed.
  • S-key - Decrease speed.
  • Ctrl + Left mouse button – Tilt.
  • Ctrl + Middle mouse button – Pan.

46. Flight Manipulator - Flight Mode

Click to set the fly camera manipulator, which is active when the viewer is set to viewing mode (See 31. Viewing Mode )

The fly manipulator interprets/converts mouse movement into fly-through camera movements.

Keys & Buttons

  • Left mouse button – Fly forward.
  • Middle mouse button - Fly backward.
  • W-key - Increase speed.
  • S-key - Decrease speed.

47. Manipulator Editor

Click to open the Manipulator Settings dialog box that lets you fine-tune the manipulator reaction and handling.

Command Line Parameters

  • -slave
    Cluster slave machine/viewer.
  • -master
    Cluster master machine/viewer.
  • -nosplash
    Suppress splash screen on startup
  • -server:[server name]
    Server name (e.g. -server:Cluster-Server) This is the name of the machine where the ServerVR application runs on.
  • -name:[viewer name]
    Name of this viewer. The name is needed to register correctly at the ServerVR application.
  • -x:[x position]
    Output window x position in pixel.
  • -y:[y position]
    Output window y position in pixel.
  • -cx:[size x]
    Output window x extension in pixel.
  • -cy:[size y]
    Output window y extension in pixel.
  • -left:[left border]
    Left viewport border. The viewports dimension runs from 0.0 to 1.0.
  • -right:[right border]
    Right viewport border. The viewports dimension runs from 0.0 to 1.0.
  • -bottom:[bottom border]
    Botttom viewport border. The viewports dimension runs from 0.0 to 1.0.
  • -top:[top border]
    Top viewport border. The viewports dimension runs from 0.0 to 1.0.

Cluster Viewer

You can use the Sample Viewer in a simple cluster setup.

For swap synchronization you should use the Quadro FX3000G graphics card and connect all machines. For more information about hardware swap synchronization see the documentation that comes with your NVIDIA frame-lock capable graphics card.

Cluster 3x3 + Master

This section describes a sample setup of nine cluster machines and one master machine (+ one Cluster Server - see the note Cluster Server Setup)

Master Machine Setup

  • The ViewerVR.exe applications and their DLLs must reside on the master machine.

Cluster Server Setup

  • The ServerVR.exe applications and their DLLs must reside on the master machine.
    Note:
    Due to a known problem with the cluster mode we suggest to start the ServerVR.exe on a non cluster machine that is not synced to the cluster. We will fix this issue with the next release.

Cluster Machine Setup

  • The ViewerVR.exe application and its DLLs must reside on each cluster machine.
  • In this example the cluster machine matrix is as follows:
    20 21 22
    10 11 12
    00 01 02

Starting the Machines

1. Start ServerVR.exe on the Cluster-Server.
2. Start the master viewer on the Cluster-Server.
3. Start the other slave viewers on the cluster machines.
4. Load and control a scene using the master viewer on the Cluster-Server.

Command Line Parameters for the Different Viewers

00: -slave -server:Cluster-Server -name:m00 -x:000 -y:600 -cx:300 -cy:300 -left:0.000 -right:0.333 -top:0.333 -bottom:0.000
01: -slave -server:Cluster-Server -name:m01 -x:300 -y:600 -cx:300 -cy:300 -left:0.333 -right:0.666 -top:0.333 -bottom:0.000
02: -slave -server:Cluster-Server -name:m02 -x:600 -y:600 -cx:300 -cy:300 -left:0.666 -right:1.000 -top:0.333 -bottom:0.000
10: -slave -server:Cluster-Server -name:m10 -x:000 -y:300 -cx:300 -cy:300 -left:0.000 -right:0.333 -top:0.666 -bottom:0.333
11: -slave -server:Cluster-Server -name:m11 -x:300 -y:300 -cx:300 -cy:300 -left:0.333 -right:0.666 -top:0.666 -bottom:0.333
12: -slave -server:Cluster-Server -name:m12 -x:600 -y:300 -cx:300 -cy:300 -left:0.666 -right:1.000 -top:0.666 -bottom:0.333
20: -slave -server:Cluster-Server -name:m20 -x:000 -y:000 -cx:300 -cy:300 -left:0.000 -right:0.333 -top:1.000 -bottom:0.666
21: -slave -server:Cluster-Server -name:m21 -x:300 -y:000 -cx:300 -cy:300 -left:0.333 -right:0.666 -top:1.000 -bottom:0.666
22: -slave -server:Cluster-Server -name:m22 -x:600 -y:000 -cx:300 -cy:300 -left:0.666 -right:1.000 -top:1.000 -bottom:0.666
Master: -master -server:Cluster-Server -name:master

Overlapping

The above setup does not overlap the viewports. If you need overlapping, such as for a set of video projectors or a power wall, control the overlapping by adjusting the viewport borders of the viewer.

For example:
machine A: -left:0.000 -right:0.600
machine B: -left:0.400 -right:1.000

Back to Getting Started

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Legal Notice

Copyright (c) 2007 NVIDIA Corporation. All rights reserved.

Notice
This software may not, in whole or in part, be copied through any means, mechanical, electromechanical, or otherwise, without the express permission of NVIDIA Corporation.

Information furnished is believed to be accurate and reliable. However, NVIDIA assumes no responsibility for the consequences of use of such information nor for any infringement of patents or other rights of third parties, which may result from its use. No License is granted by implication or otherwise under any patent or patent rights of NVIDIA Corporation. Specifications mentioned in the software are subject to change without notice.

NVIDIA Corporation products are not authorized for use as critical components in life support devices or systems without express written approval of NVIDIA Corporation.

Trademarks
NVIDIA, the NVIDIA logo, and NVIDIA Quadro are registered trademarks or trademarks of NVIDIA Corporation in the United States and/or other countries.

Microsoft, Windows, and the Windows logo are registered trademarks of Microsoft Corporation.

Other company and product names may be trademarks or registered trademarks of the respective companies with which they are associated.

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


NVSG SDK 3.2 Migration Guide

Introduction

The NVSG SDK 3.2 marks the beginning of new API-stable series of releases.

This article addresses a number of topics and issues of interest to users updating from a 2.x release to release 3.2. The new release comes with a number of API changes that addresses flaws inherent in previous releases. All API changes in release 3.2 are needed in order to reach the next level of quality.

API Changes

Object Handling

One of the most obvious cutting-edge changes involves object handling itself, which we call the handle-based approach. This major change in object handling was developed because of the lack of multithreaded safeness in earlier releases. This new approach not only affects the general handling of NVSG Core Objects, but also affects the custom-derived classes that extend the NVSG core (see also How to Derive an NVSG Object).

In previous versions, we already had the concept of 'single write - multiple read' access to an Object in a multithreaded runtime environment. On the other hand, we had a 'pointer to const' design for passing Objects throughout the NVSG API. This, in particular, was to explicitly avoid write access to an Object prior to properly write locking it through a call to beginEdit. However, the 'pointer to const' design did not prevent an Object from being read without a prior read lock. This indeed was a leak in multithreaded safeness, because it breaks the 'single write - multiple read' design pattern.

With the new handle-based approach, instead of passing pointers to const, pointers to handle are passed throughout the public NVSG API. The user no longer directly creates Objects, as with previous versions of the NVSG SDK, but instead creates associated handles:

    GeoNodeHandle * hgnode = CreateHandle(GeoNodeHandle);
    // [...]
    GroupHandle * hgroup = CreateHandle(GroupHandle);
    {
        // retrieve the non-const interface of the Group to perform edit operations on the Group
        WritableObject<Group> group(hgroup);
        group->addChild(hgnode);
    }

When passing a pointer to handle, subsequent code cannot access the interface of the handled Object, neither for reads nor for writes, without first performing an appropriate lock. Read access to the Object will be received by invoking the beginRead member function of the passed handle. After locking the handled Object, this function returns a pointer to the const Object, and hence access to the read-only interface of that Object. The object is locked for read access until the endRead member function of the passed handle is invoked to release the lock.

Read access to a particular handled Object can also be gained through instantiation of a ReadableObject pointer object. The ReadableObject's constructor will be passed a pointer to handle. The handled Object then will be read-locked at instantiation of the ReadableObject, and the read lock will be released when the ReadableObject runs out of scope.

Write access to a handle Object will be received similar to read access. To control write access to a handled Object, either invoke the beginEdit and endEdit member functions on the passed handle, or use the WritableObject pointer object using a similar method as ReadableObject described above.

Write locking an object that has already been read locked by the same thread will immediately dead-lock your application! You should always prefer write locks to read locks if you aren't sure which operations are performed on the particular objects in the subsequent calling hierarchy. Another recommended practice is to lock an object no longer than needed, neither for read locks nor for write locks. If you use the convenient ReadableObject and WritableObject, you should surround the corresponding code with curly brackets to limit the scope for these pointer objects.

Object Design

The introduction of the handle-based approach also involves slight changes to the object design. Actually, many of the restrictions we had with the pre-handle-based object design could have been abolished. Most of the earlier properties such as special memory management and reference counting have been elevated to the Handle template class itself. However, there are some restrictions that we were forced to introduce in order for custom-derived objects to properly work with the handle-based approach:

A custom derived object must have a public-accessible default constructor, a public-accessible copy constructor, and a public-accessible destructor.

When a certain Handle type gets instantiated through CreateHandle, a corresponding object will be allocated and the default constructor for that particular object type will be invoked to construct the object. Immediately after instantiation, the reference count of the handle is 0. The reference count will be incremented by calling the addRef member function.

If an already instantiated Handle will be cloned by calling the clone member function, the handled object will be copied by invoking its copy constructor. The reference count of the new instantiated clone is 0, and remains 0 until the addRef member function is invoked to increment its reference count.

A handle, and consequently the handled object, will be automatically deleted after its reference count changes from 1 to 0 by calling the removeRef member function.

One additional restriction with the new handle-based approach is that the user cannot pass an object constructor, nor can he pass constructor parameters to CreateHandle. This limitation is due to the memory management we internally use for handled object allocations. If your object requires some extra initialization that cannot be handled by the default constructor, you should provide a dedicated init member function to serve this purpose. This init function can then be invoked after the handled object has been write-locked:

    // CustomObject.h

    #include "nvsg/Object.h"

    // a custom derived object
    class CustomObject : public nvsg::Object
    {
    public:
        CustomObject(); // default constructor
        CustomObject(const CustomObject&); // copy constructor
        virtual ~CustomObject();

                // init function to perform extra object initialization
        void init(int a, int b) { m_a = a; m_b = b; }

        // [...]
    };

    // convenient CustomObjectHandle typedef
    typedef Handle<CustomObject, ObjectHandle> CustomObjectHandle;

    // somewhere in application code

    // [...]

    CustomObjectHandle * hcustom = CreateHandle(CustomObjectHandle);

    // default construction doesn't suffice - need to perform some additional init
    {
        WritableObject<CustomObject> custom(hcustom);
        custom->init(2, 3);
        // perform further writes
        // [...]
     }
     // [...]

Traverser Design

The Traverser base class has been split into two base classes for shared and exclusive operations on a NVSG tree. This change is a direct consequence of the new handle-based approach we introduced for Object handling, and, as with the NVSG Core Objects, affects the implementation of custom-derived traversers.

With the new release of the NVSG SDK we distinguish between traversers that perform read-only operations on a tree, and traversers that perform write operations on a tree.

SharedTraverser is the base class for all traversers performing read-only operations on a tree. A RenderTraverser is a typical example of a SharedTraverser. In a multithreaded runtime environment, multiple SharedTraverser can operate simultaneously on the same tree.

ExclusiveTraverser represents the base class for all traversers that modify tree objects during traversal. An OptimizeTraverser is a good example of an ExclusiveTraverser.

The traverser framework, for both the SharedTraverser and the ExclusiveTraverser, performs the corresponding locking of a traversed object and passes a pointer to the locked object to the dedicated handler functions. The handler functions of a SharedTraverser expect a pointer to a const object, whereas the handler functions of an ExclusiveTraverser expect a pointer to a non-const object:

    // different prototypes of virtual handleGeoNode functions for
    // SharedTraverser and ExclusiveTraverser allowing for read-only
    // access and read-write access resp..

    class SharedTraverser : public Traverser
    {
        // [...]
    protected:
        // [...]
        NVSG_API virtual void handleGeoNode(const GeoNode * gnode);
        // [...]
    };

    class ExclusiveTraverser : public Traverser
    {
        // [...]
    protected:
        // [...]
        NVSG_API virtual void handleGeoNode(GeoNode * gnode);
        // [...]
    };

In other words, a SharedTraverser handler function has access only to the const public interface of the passed object, whereas an ExclusiveTraverser handler function has full access to the public interface of the passed object. This is the reason for having two dedicated traverser base classes instead of only one as we had it in previous releases of the NVSG SDK.

Matrix Layout

In order to achieve better compatibility with matrix layouts found outside of NVSG, we decided to change the NVSG matrix layout. The NVSG matrices are still row-major; but when interpreted as a transformation, the logic has changed. Essentially, we now interpret a matrix as being the transpose of what it was before.

While in rel2.1.x the translational part of a transformation was located in the top three elements of the last column, in rel3.2.x the translational part of the transformation is located in the first three elements of the last row. For example, when the values of a 4x4 matrix are seen as a consecutive set of 16 values, in rel2.1.x the translational part was at positions 3, 7, and 11 (counting from 0), while in rel3.2.x the translational part is now at positions 12, 13, and 14.

Consequently, there are four issues you must pay attention to:

1. Getting and Setting a Matrix Into and From NVSG.

Whenever you supply a matrix to NVSG that you did not get from NVSG, you must supply the transposed matrix instead. Whenever you get a matrix out of NVSG for your own use, you must transpose it to get it into the same format. Note that the transpose of a matrix is an idempotent operation - that is, the transpose of the transpose of a matrix is the original matrix.

2. Multiplication of a Matrix with a Vector.

As the new NVSG matrices are the transpose of the former ones, multiplication with a vector must also be transposed. That is, if you have a vector va in space A, and a transformation mAtoB mapping from space A into a space B, then to get a vector vb in space B you need to write
  vb = va * mAtoB;

3. Multiplication of Two Matrices.

As the new NVSG matrices are the transpose of the former ones, multiplication of two matrices must also be transposed. That is, if you have a transformation mAToB mapping from space A into space B, and a transformation mBToC mapping from space B into space C, then to get the transformation mAToC mapping from space A into space C you need to write
  mAToC = mAToB * mBToC;

4. Multiplication of Two Quaternions.

In order to have the same concatenation model for quaterions as there is for matrices, we have also changed the multiplication order of quaternions. This was done to ensure that if you have two quaterions q0 and q1, each representing a rotation, the following holds:
  Mat33f( q0 * q1 ) == Mat33f( q0 ) * Mat33f( q1 );
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Working with Multitexturing

The following actions are required for every texture:

1. Create a TextureAttributeItem
2. Bind the item to a specific texture unit
You bind the item via the TextureAttribute object using the bindTextureAttributeItem() method. (A TextureAttribute is a simple StateAttribute such as Material. Refer to the sample viewer sources to see how to set up a simple tree using StateAttributes.)

The following sample code shows how to set up multitexturing:

RCObject_AutoPtr< TextureAttributeHandle > hTAttr( CreateHandle( TextureAttributeItemHandle ) );
{
  WritableObject< TextureAttribute > ncTexAttrib( hTAttr.get() );
  for (unsigned int i=0; i<numTextures; i++)
  {
    RCObject_AutoPtr< TextureAttributeItemHandle > hItem( CreateHandle( TextureAttributeItemHandle ) );
    {
      WritableObject< TextureAttributeItem > ncItem( hItem.get() );
      ncItem->setTextureImageSpec(namelist[i]);

      // just assume it's a 2D-Texture and rotate around the z-axis
      ncItem->setOrientation(Quatf( Vec3f( 0.0f, 0.0f, 1.0f ), m_IDToTextureRotation[mapID] ));
      ncItem->setScaling(m_IDToTextureScaling[mapID]);
      ncItem->setTranslation(m_IDToTextureTranslation[mapID]);

      // texture environment mode
      ncItem->setEnvMode(TEM_BLEND);
    }

    // bind the item to texture unit 'i'
    ncTexAttrib->bindTextureAttributeItem(hItem.get(), i);
  }
}

Back to Advanced

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Important Concepts - Must Read for All Developers

See also:
Fundamental Concepts of the NVSGSDK
The following sections in the help file should be read by all developers. These are fundamental issues every programmer needs to understand to write NVSG-based applications.

Separation of Data from Their Operations
Separating data from operations is one of the key designs of NVSG.

Overview of the Principal Classes
The NVSG core classes form the building blocks to create a directed acyclic graph (DAG).

NVSG Core Objects
This section describes NVSG object concepts, and gives a brief introduction in the use of NVSG objects, including how to derive NVSG objects.

Traversers
Traversers serve as link between the scene graph and the operation to be performed on the scene graph.

Back to Fundamental Concepts

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Overview of the Principal Classes

This section lists the main classes of the NVSGSDK. The classes can be organized in the following general categories:
  • nodes
  • nodecomponents
  • superiorobjects

Node Core Classes

Non-Concrete Node Classes

Non-concrete Node classes are all Node classes that will not be instantiated.

Node

Concrete Node classes

GeoNode

Group
LOD
Switch
Transform
AnimatedTransform

Node Component Core Classes

Non-Concrete Node Component Classes

Animation
InterpolatedAnimation

Drawable

HighlightObject

StateAttribute

LightSource

Concrete Node Component Classes

FramedAnimation
LinearInterpolatedAnimation

Quads
AnimatedQuads
QuadStrips
Triangles
AnimatedTriangles
SkinnedTriangles
TriStrips

HighlightBox
HighlightEdges

StateSet
StateVariant
StatePass

CgFx
FaceAttribute
Material
TextureAttribute
TextureAttributeItem

DirectedLight
PointLight
SpotLight

Superior Object Core Classes

Non-Concrete Superior Object Classes

Camera

Concrete Superior Object Classes

ParallelCamera
PerspectiveCamera

Scene
ViewState

See also:
Working With NVSG Classes
Back to Fundamental Concepts
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Recommended Reading

This section lists several C++, Computer Graphics and Windows books you may find helpful.

C++ and Object Oriented Programming:

Bjarne Stroustrup: The C++ Programming Language (Second edition, Reading, Massachusetts: Addison-Wesley Publishing Company, 1994), ISBN: 0-201-53992-6.

Bruce Eckel: Thinking in C++ (Englewood Cliffs, New Jersey: Prentice Hall, Inc., 1995), ISBN: 0-13-917709-4.

Al Stevens: Teach Yourself... C++ (Fourth edition, New York, New York: MIS:Press). ISBN 1-55828-406-0.

Scott Meyers: Effective C++ (Third edition, Addison-Wesley). ISBN 0-321-33487-6

Computer Graphics Programming:

James D. Foley, Andries van Dam, Steven K. Feiner, and John F. Hughes, Richard L. Phillips: Introduction to Computer Graphics (Reading, Massachusetts: Addison-Wesley Publishing Company, 1993). ISBN: 0-201-60921-5.

John Vince: 3-D Computer Animation (Reading, Massachusetts: Addison-Wesley Publishing Company, 1993). ISBN: 0-201-62756-6.

Alan Watt and Mark Watt: Advanced Animation and Rendering Techniques (Reading, Massachusetts: Addison-Wesley, 1992). ISBN: 0-201-54412-1

James D. Foley, Andries van Dam, Steven K. Feiner, and John F. Hughes: Computer Graphics Principles and Practice (Second edition in C, Reading, Massachusetts: Addison-Wesely Publishing Company, 1995). ISBN: 0-201-84840-6.

James D. Murray and William vanRyper: Encyclopedia of Graphics File Formats (Second Edition, O'Reilly & Associates, Inc., 1996, 1994). ISBN: 1-56592-161-5. This book provides information about various graphic file formats that are applicable to the creation of image loader / saver plug-ins.

Tomas Möller and Eric Haines: Real-Time Rendering (A K Peters, Natick, Massachusetts, 1999) ISBN: 1-56881-101-2

Mason Woo, Jackie Neider, and Tom Davis: OpenGL Programming Guide (Second Edition, Addison-Wesley, 1998). ISBN: 0-201-46138-2

Renate Kempf and Chris Frazier: OpenGL Reference Manual (Second Edition, Addison-Wesley, 1998) ISBN: 0-201-46140-4

Randima Fernando and Mark J. Kilgard: Cg - The Cg Tutorial (Addison-Wesley, 2003) ISBN: 0-321-19496-9

Windows Programming:

Charles Petzold: Programming Windows 95 (Redmond, Washington: Microsoft Press, 1996). ISBN: 1-55615-676-6.

Jeffrey Richter: Advanced Windows The Developer's Guide to the Win32 API for Windows NT 3.5 and Windows 95 (Microsoft Press, 1995). ISBN: 1-55615-677-4.

Back to Getting Started

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Separation of Data from Their Operations

Advantages of Separation of Data and Operations

The rigorous separation of the scenegraph's data from the operations to be performed on that data is a central NVSG design concept. This approach provides the highest flexibility for all fields of NVSG applications, such as CAD applications, Viewer applications, and clusters, to name a few.

This weak coupling also make it very easy for developers to extend NVSG to meet their needs. For example, adding a special operation doesn't require extending any of the NVSG core classes . Conversely, extending the NVSG core classes by means of overloading won't break existing operations.

What Does Separation of Data and Operations Mean?

One can think of a scenegraph as a container holding heterogeneous data - that is, scenegraph class objects. The scenegraph classes themselves encapsulate specific data, but do not know how to perform actions on that data. For example, the Triangles class encapsulates geometry data and additional topological information on how to connect the geometry data to form a geometric object. However, the Triangles class does not know how to render the encapsulated geometry.

An operation on the scenegraph data is performed by means of a Traverser . A Traverser serves as a link between the scenegraph and a defined operation - such as rendering - to be performed on the scenegraph. More precisely, a traverser iterates the scenegraph and performs a specific operation on each component of the scenegraph. In this way, a traverser fullfills two tasks:

  • Iterating the scene graph, starting at the scene graph's root node.
    In general, this is covered by the base class Traverser .
  • Performing a defined operation for each object (nodes, etc.) in the scenegraph.
    In general, this is customized by means of overloading.

Back to Fundamental Concepts

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Skinning Support in NVSG

  • Using Skinning in NVSG
  • AppTraverser and Processors
  • Skinning on the CPU
  • Skinning on the GPU
  • Custom Skinning Processor

Using Skinning in NVSG

Skinning in NVSG is controlled by the class nvsg::Skin. A nvsg::PrimitiveSet might hold a nvsg::Skin, in which case the nvsg::VertexAttributeSet held by that same nvsg::PrimitiveSet is skinned.

Each nvsg::VertexAttribute of a nvsg::VertexAttributeSet might be modified by the skinning process. This is controlled by the Skin::SkinningType. VertexAttributes that shouldn't be changed by the skinning process, e.g. texture coordinates, should get the Skin::SkinningType Skin::NVSG_SKIN_NONE. This also is the default for each nvsg::VertexAttribute. VertexAttributes that should be skinned like points, e.g. positions, should get the Skin::SkinningType Skin::NVSG_SKIN_POINT. VertexAttributes that should be skinned like vectors, e.g. normals or tangents, should get the Skin::SkinningType Skin::NVSG_SKIN_VECTOR.

All skinned VertexAttributes of a nvsg::VertexAttributeSet use the same set of so called influence data for the skinning process. The number of influence data has to be the same as the number of vertices in the skinned nvsg::VertexAttributeSet. The influence data consists of one number per vertex, that specify the number of joints that influence that vertex, the weights for each of those joints, and indices into an array to identify those joints. That is, the number of weights and indices have to be equal to the sum of the number of joints. The number of joints can be any positive number, but in practice some skinning processors might just use a limited number of them. The weights per vertex should sum up to one.

Each joint used in the influence data consists of a nvsg::Transform and a nvmath::Mat44f. The nvsg::Transform has to be part of the scene. The accumulated transformation matrices from the root of the scene to that nvsg::Transform are used for the skinning process. One nvsg::Transform can be used as a joint by multiple Skins, but note, that a joint nvsg::Transform has to be unique in the scene. The nvmath::Mat44f that is part of a joint is the inverse bind matrix, the transformation that is applied to a vertex to express it in the joint coordinate system. A nvsg::Skin holds an array of such joints, and the indices used in the influence data described above index into that array.

Finally, there is a nvmath::Mat44f, the bind shape matrix defined by a nvsg::Skin, which is the transformation that moves the skin in the skeleton coordinate system. The default of this matrix is the identity.

AppTraverser and Processors

The AppTraverser in NVSG is responsible for processing and/or preparing the scene for rendering. The AppTraverser includes the notion of a SkinningProcessor which will prepare any PrimitiveSets that contain Skin's for rendering. The SkinningProcessor class is defined in AppTraverser.h.

NVSG currently implements two types of skinning processors: CPU skinning and GPU Skinning. The CPU skinner uses the CPU to transform skinnable data using the vertex influences and the palette of indexed Transforms, whereas the GPU skinner uses the GPU to perform this task. The methods AppTraverser::isSkinningProcessorSupported, AppTraverser::setSkinningProcessor, and AppTraverser::getSkinningProcessor manipulate the skinning processor in the AppTraverser.

Skinning on the CPU

The CPU skinner is the default SkinningProcessor created by the AppTraverser. As mentioned earlier it will use the CPU to transform vertex data based on the influences in the Skin. The CPUSkinningProcessor should be used as a fallback when the required OpenGL extensions are not available to use the GPUSkinningProcessor. The CPUSkinningProcessor supports any number of influences per vertex and any number of Transforms as joints.

Skinning on the GPU

The GPU skinner will use several OpenGL extensions to accomplish skinning entirely on the GPU. This Processor requires the following extensions: GL_NV_transform_feedback, GL_ATI_texture_float, GL_ARB_pixel_buffer_object, GL_ARB_vertex_buffer_object, and GL_NV_gpu_program4. These extensions are found on a Quadro 4600 or better (G80 class) GPU. A call to AppTraverser::isSkinningProcessorSupported will determine if the GPU skinner will work on the current hardware.

The GPU skinner uses a combination of Cg Vertex and Geometry Programs, Transform Feedback, VBO's, and floating point textures to achieve transform feedback on the GPU. It supports up to 32 influences per vertex, and thousands of matrices in the palette.

As new PrimitiveSets that contain Skin's are added to the scene, the GPU skinner will generate vertex and geometry programs, and fill floating point texture maps with influence and joint data for this PrimitiveSet. Each frame the new Joint information is uploaded into floating-point texture maps that are used by the shaders to render skinning data into new VBO's. This VBO is then used as the source for final screen rendering in the GLTraverser.

Note:
The GPU skinner is currently unable to detect whether data has been dynamically modified inside of a PrimitiveSet. Changing attribute counts, lengths or sizes after a frame has been rendered will cause unpredictable results - especially if the counts have increased. It is therefore recommended that the scene is fully prepared and optimized before applying the GPU skinner using AppTraverser::setSkinningProcessor.

Custom Skinning Processor

Both the GPU and CPU SkinningProcessors derive from AppTraverser::SkinningProcessor. The interface provided to the skinning processor is described in AppTraverser.h.

Several methods are called by the AppTraverser as the scene is rendered. Pre and PostTraverseScene are called at the start and end of scene processing, respectively. addJoint is called as the scene is processed when Transforms that are marked as Joints are encountered in the scene. addSkin is called similarly as PrimitiveSets containing Skins are encountered in the scene. calculateJointMatrices can be used to update a vector of matrices based on a SkinHandle.

Once the scene has been traversed, SkinningProcessor::process is then called to perform the skinning processing for the frame. This method is expected to iterate all of the PrimitiveSets encountered with skins and update the VBO data within them to reflect the current state.

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Traversers

The concept of traversers is one of the key designs of NVSG and goes along with the Separation of Data from Their Operations. A traverser serves as link between the scene graph and a defined operation to be performed on the scene graph. More precisely, a traverser covers the following tasks:

  • Iterating the scene graph, starting at the scene graph's root node.
  • Performing a defined operation for each object (nodes, etc.) in the scene graph.

Besides iterating a scene graph, the base class also provide per-object locking. In particular, this feature allows for multiple read read traversals to run in parallel in a multithreaded environment. One can think of a single scene graph that is rendered to multiple output devices simultaneously.

Performing a special operation (render, save, etc.) on a given scene graph is achieved by means of overloading.

See also:
Working with Traversers and How to Derive a Traverser
Back to Fundamental Concepts
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Using the NVSGSDK

This module of the documentation is intended to teach the developer how to accomplish specific tasks in programming an NVSG-based application.

It includes the following sections:

Fundamental Concepts of the NVSGSDK
This section contains a description of the NVSG architecture and the fundamental concepts of the NVSGSDK.

Important Concepts - Must Read for All Developers
This section describes important concepts with which developers must be familiar.

Working With NVSG Classes
This section includes commented source code and descriptions of categories of methods developers must implement to create and work with each class type.

Back to Getting Started

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Defining the View Frustum

By default, a Camera is positioned on the positive z-axis at (0,0,1), and oriented to view down the negative z-axis (0,0,-1), having the positive y-axis (0,1,0) as the up direction. That way, the positive x-axis (1,0,0), the up direction and the negative view direction make a right handed coordinate system.

The focus distance determines the distance of the projection plane for the camera position along the view direction. That way, with a nvsg::Camera camera, the projection plane is defined as follows:

  nvmath::Vec3f projectionPlanePoint = camera->getPosition() + camera->getFocusDistance() * camera->getDirection();
  nvmath::Vec3f projectionPlaneNormal = camera->getDirection();

In that projection plane, there is a view window defined. The projectionPlanePoint is the center of that window, while the window size describes the width and height of the window.

Using all these values, a view frustum is defined, with the apex at the camera position, and a specified size (window size) at a specified distance (focus distance). To limit the view frustum, a near distance and a far distance are used. They describe the distances to the near and the far clipping plane, measured from the camera position.

Defining Values in One-step

Defining all these values described above can be very easy. Suppose you have a nvsg::Scene with a bounding sphere sphere you want to look at with a nvsg::PerspectiveCamera camera. The following code snippet does all the work:

  camera->zoom( sphere );

This takes the camera from it's current position, and moves it to a point in space, such that the sphere is completely inside the view frustum. It changes the position, but keeps the view and up direction. The focus distance is set to have the projection plane point in the center of the sphere.
Note, that the field of view and the aspect ratio of the window are not changed. If you want to set the field of view to a specific value on zooming, you can do the following:

  camera->zoom( sphere, fovy );

If automatic clip plane adjustment is selected for that camera, the near and far clipping planes are set to the near and far end of the sphere.
Taking that as a starting point, the camera can be easily manipulated with calls to move, orbit, rotate, and zoom.

Setting the Orientation

To specify the camera orientation (that is, a viewing direction and an up direction), you can use one of the following two code snippets:

  camera->setUpVector( up );
  camera->setDirection( dir );
  camera->zoom( sphere );

  camera->setOrientation( orientation );
  camera->zoom( sphere );

Here again, the center of the sphere will be in the view plane. Note that in the first snippet dir and up must not be collinear. Moreover, if they are not orthogonal, setDirection modifies the up direction just set, to keep them orthogonal. In the second snippet, orientation is a nvmath::Quatf that rotates from the default direction (0,0,-1) to the desired direction.

Adjusting the Aspect Ratio

Usually, to prevent distortions, the aspect ratio of the view window in the view plane should be the same as the aspect ratio of the viewport on the screen. Assuming that your viewport is w pixels wide and h pixels high, you would do the following:

  camera->setAspectRatio( (float) w / h );

This keeps the height of your view window constant and adjusts the width accordingly, thus keeping the field of view constant. If you prefer to keep the width constant, call the following instead:

  bool keepWidth = true;
  camera->setAspectRatio( (float) w / h, keepWidth );

Setting Distances Explicitly

The zoom() method used above automatically fits the near and far clipping plane as well as the focus distance. You can switch this automation off and set these values explicitly as follows:

  camera->setAutoClipPlanes( false );
  camera->setNearDistance( near );
  camera->setFocusDistance( foc );
  camera->setFarDistance( far );

Keep in mind, here, that all distance values are positive, near is less than far, and foc should be somewhere in between.

Setting Position and Window Size Explicitly

The zoom() method automatically adjusts the position and the window size. You can set those values explicitly as follows:

  camera->setPosition( pos );

  camera->setWindowSize( size );

The first snippet sets the camera at the given position. No other setting of the camera is changed. The second snippet makes the view window extend from the target point out to the right and left by size[0]/2, and out to the top and bottom by size[1]/2. Note that the window size is given in world coordinate units. Setting the window size in this way might change both the field of view and the aspect ratio. Using zoom operations keeps those values constant.

Defining an Asymmetric Frustum

The previous examples always result in a symmetric view frustum. In some cases, such as for multi-screen solutions, you might need an asymmetric frustum. This can be achieved as follows:

  camera->setWindowRegion( lowerLeft, upperRight );

This function sets the part of the view window to be used for the view frustum. By default, lowerLeft is (0,0) and upperRight is (1,1), which means that the whole view window is used.

To use just a part of the view window, set these values to the desired fractions. For example, to adjust the n times m cameras of a regular n x m multi-screen solution, call the following for the camera corresponding to the jth screen in the ith row:

  camera->setWindowRegion( Vec2f( (float)i/n, (float)j/m ), Vec2f( (float)(i+1)/n, (float)(j+1)/m ) );

This defines the relative part of the view window and no other member function of the camera changes it. For this reason, as long as the desired part of the window doesn't change, you need to set this only once.

Note:
The aspect ratio of the camera is determined by the view window, not the window region. That is, in a multi-screen solution the window of all cameras should be the same, thus having the same aspect ratio. This aspect ratio should be the same as the aspect ratio of the sum of the multi-screen viewports. For example, if you have a one times three viewport solution, each with a resolution of 1280 x 1024, the resulting aspect ratio would be (float) 3 * 1280 / 1024 = 3.75.
Back to Advanced
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


What You Need to Get Started

Technical Expertise

In order to use the NVSGSDK you need to know how to program in C++ and be familiar with object-oriented programming concepts. This document can get you started, but it does not teach C++ or object-oriented programming.

It is also assumed that you are familiar with the Microsoft Visual C++ compiler and development tools.

If you want to use pixel or fragment shaders with your scene models, you should also be familiar with Cg and CgFx.

See also:
Recommended Reading

Software

Microsoft Windows 2000/XP/XP64:
  • Microsoft Visual Studio.NET 2003
  • Normally the setup creates a new environment variable on your machine, NVSGSDKHOME, which points to the NVSG SDK root directory. (e.g. c: Files Corporation)

Linux:

  • glibc 2.2.5 or higher (libc6)
  • libstdc++ 5.0.3 or higher (gcc 3.2.3 or higher system)
  • For building your applications, you must use gcc 3.2, 3.3, 3.4 or 3.5
    Check the NVSG Website for the appropriate package to match your gcc and libc version.
  • In docs/gcc-spec.txt you can see the g++ configuration options. You can use these to configure and build your g++ if you experience any problems or incompabilities.

    Note:
    gcc 3.4 and 4.0 users - especially Fedora Core 3 users:
    Check the configuration of your compiler by running "g++ -v". If it was not configured with "--enable-libstdcxx-allocator=mt" you have to include "force_mtalloc.h" before any other header in your application and the samples. You can either include it manually with "#include force_mtalloc.h" at the very top of your main source file or invoke g++ with the "-include" parameter to have it automatically included first. (When building the samples and using our supplied Makefiles, you do not have to edit anything. Simply export NVSG_CPP_EXTRAFLAGS="-include force_mtalloc.h" in the shell before invoking make.)

Hardware

NVIDIA FX family of graphics cards, such as the NVIDIA Quadro FX 2000.

Back to Getting Started

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Working with Lights

We refer to lights as objects of classes derived from LightSource . The NVSG SDK comes with three concrete LightSources:

DirectedLight
A DirectedLight light has no position, but only a direction. It represents a distant light source with parallel rays, such as the sun for example.

PointLight
A PointLight has a position in space, but no direction. The light rays emanate from it's position in each direction, such as from a light bulb for example.

SpotLight
A spot light has both, a position as well as a direction. The light rays emanate from the position in only a limiting cone around it's direction.

A LightSource is added to a scene by adding it to a particular Group object:

  using namespace nvsg;
  GroupHandle * hGroup = CreateHandle(GroupHandle);
  {
    // add a default-constructed PointLight to the Group
    WritableObject<Group> group(hGroup);
    group->addLightSource(CreateHandle(PointLight));
  }

Light Sources will illuminate all children of the Group they are attached to, but will not illuminate siblings or ancestors of that group. This allows localization of the light sources to a subgraph of the scene. This may be desirable for illuminating building or vehicle interiors where the light source should not affect the surrounding geometry. Infinite light sources, such as the sun, should be added to the top-most group in the hierarchy so that they are applied to all geometry in the scene.

When lights are added to the scene they are automatically "On" and will illuminate geometry as described above. In order to turn a light source "off" it needs to be removed from the group using removeLightSource() and the following code:

  GroupHandle * groupLightIsIn;
  LightSourceHandle * lightIWantToRemove;

  {
    WritableObject< Group > group( groupLightIsIn );
    for( size_t l=0; l < group->getNumberOfLightSources(); ++l )
    {
      if( group->getLightSource(l) == lightIWantToRemove )
      {
        group->removeLightSource(l);
        break;
      }
    }
  }

Note that the reference count for the light source will be decremented when it is removed from the scene and will be deleted if the count falls to zero, so addRef() the light if necessary.

Another method for a switchable light source is to put it under a switch as shown below:

        Orignal Scene:      New Scene:

        [G0]-Light          [Switch]
         |                  m0| m1|
        [Children]          [G1] [G0]-Light
                             |    |
                            [Children]

The original scene contains a group (G0) with a light source and some number of children. The new scene contains a switch node with two children - the original G0 with light and children, and a new group (G1) which simply contains pointers to the same children as G0 (and any clipping planes that may be in G0). Two masks are added to the switch (m0 and m1) that control which subgraph is traversed. If mask 'm0' is selected the geometry will not be lit, whereas if mask m1 is selected the geometry will be lit.

Another method to illuminate a scene, is to add a light to the actual view camera. Lights added to a camera, we refer to as 'headlights', because they always are positioned relative to the camera. All headlights added to a camera are considered 'On'. A headlight also is considered a 'global' light, and as this, illuminates the whole scene currently viewed by the corresponding camera. Use Camera::addHeadLight to add a particular headlight to a camera:

  using namespace nvsg;
  CameraHandle * hCam = CreateHandle(PerspectiveCameraHandle);
  {
    // add a default-constructed PointLight to the Camera as headlight
    WritableObject<Camera> cam(hCam);
    cam->addHeadLight(CreateHandle(PointLight));
  }

There is no other way to turn a headlight off, as by removing it from the particular camera through Camera::removeHeadLight:

  using namespace nvsg;

  CameraHandle * hCam;
  [...]
  // assume hCam a valid handle here

  {
    // acquire write-access to the camera to remove the first headlight found
    WritableObject<Camera> cam(hCam);
    // check whether there is at least on headlight added to the camera
    size_t numHeadLights = cam->getNumberOfHeadLights();
    if ( numHeadLights )
    {
      // there is at least one headlight, so removing the first one is save here
      cam->removeHeadLight(cam->getHeadLight(0));
      // there should be one headlight less now
      NVSG_ASSERT(cam->getNumberOfHeadLights() == numHeadLights-1);
    }
  } // release write-access to the camera

Due to current hardware capabilities, only a limited number of lights, added either as headlights to a camera, or as local lights to several groups, contribute to the overall illumination of a certain geometry in the scene. To handle more lights than your current hardware is capable to consider for illuminating a particular surface, you should think of using phong shading techniques in conjunction with appropriate light maps, that is - textures to capture the contribution of light to a surface.

Back to Fundamental Concepts

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Working With NVSG Classes

Information on how to work with NVSG classes is provided in the following sections:

Working with State Attributes

Working with Multitexturing

Working with Lights

Working with Traversers

Working with Plug-ins

  • Creating a New Plug-in Project
  • Writing a Loader/Saver Plug-In

Working with Camera Views

  • Defining the View Frustum

Hit Testing

Back to

  • Using the NVSGSDK
  • NVIDIA Scene Graph Software Development Kit (NVSGSDK)
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Working with State Attributes

An nvsg::GeoNode holds a number of pairs of nvsg::Drawable and nvsg::StateSet. An nvsg::Drawable contains the geometry, while an nvsg::StateSet holds a number of nvsg::StateAttribute. This set of attributes determine the visual appearance of the corresponding geometry.

Adding Attributes to a Set

The function nvsg::addAttribute adds an nvsg::StateAttribute to an nvsg::StateSet. This function does not prevent multiple instances of equivalent attributes in the list. When traversing a list of attributes with multiple equivalent elements, the last of the equivalent attributes replaces any previous one. Therefore, for performance reasons, it is advisable to avoid multiple equivalent attributes in any one state set.

When a Set Does Not Contain a Special Attribute

Normally, the state attribute that is in this set is used with the corresponding geometry. When the set does not contain a special type of attribute, a default for the attribute type is to be used. This means that the parameters controlled by such an attribute type are explicitly reset to some defined values. This prevents any dependencies on the sequence of the drawables.

Note:
There might exist state attributes that make other state attributes obsolete. For example, when there is an nvsg::CgFx attribute, every other attribute such as nvsg::Material or nvsg::TextureAttribute are ignored.
Back to Fundamental Concepts
Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Working with Texture Maps

NVSG supports Fixed- and Floating-point, Integer, Nonlinear (SRGB), compress-on-upload and pre-compressed texture data formats, in all component formats provided by extended OpenGL. All texture types except buffer textures are supported.

Texture Formats

On-Disk Formats

NVSG uses the DevIL texture library to load texture files. Many different file formats are supported, including BMP, TIF, GIF, TGA, RGB, etc. NVSG's DDS file format loader supports cube maps, mip levels and compression. Compressed textures are supported by being uncompressed at load time. The "vertical cross" cube map texture format is supported and converted to a cube map if the texture's dimensions match 3 units wide by 4 units tall.
OpenGL Texture Types

NVSG supports the following OpenGL texture types:
  • TEXTURE_1D
  • TEXTURE_2D
  • TEXTURE_3D - OpenGL 1.2 or better
  • TEXTURE_CUBE - OpenGL 1.2 or better
  • TEXTURE_1D_ARRAY - EXT_texture_array extension
  • TEXTURE_2D_ARRAY - EXT_texture_array extension
  • TEXTURE_RECTANGLE - ARB_texture_rectangle extension
OpenGL Texturing Extensions

NVSG Supports the following extensions, which all define one or more new texture formats:
  • ARB_depth_texture
  • ARB_texture_compression
  • ARB_texture_float
  • ATI_texture_float
  • EXT_packed_float
  • EXT_packed_depth_stencil
  • EXT_texture_compression_s3tc
  • EXT_texture_compression_latc
  • EXT_texture_compression_rgtc
  • EXT_texture_integer
  • EXT_texture_shared_exponent
  • EXT_texture_sRGB
  • NV_texture_shader*
  • NV_half_float

In-Memory and GPU Formats

NVSG allows applications to request the format a texture will take when resident on the GPU - regardless of the in-memory format of the texture. This mimics OpenGL's notion of "user" and "internal" formats. For instance, a texture in-memory can be RGBA unsigned byte data format, but the user can request that it be converted to RGB float format when uploaded and resident in GPU texture memory.

Definitions

In the remaining sections, the following terminology will be used:
  • PixelFormat: The component-wise CPU-memory format of the bits in the user's buffer. Examples are: IMG_RGB, IMG_LUMINANCE, IMG_INTEGER_BGRA, etc.
  • PixelDataType: The per-component-wise CPU-memory format of the bits in the user's buffer. Examples are: IMG_BYTE, IMG_FLOAT32, IMG_UNSIGNED_INT_2_10_10_10, etc.
  • TextureGPUFormat: The GPU-memory format describing the components and the component bits once uploaded to the GPU. Examples are: TGF_LUMINANCE8, TGF_SIGNED_ALPHA8, etc.
TextureGPUFormat

In versions prior to 4.0, NVSG did not allow separate selection of the TextureGPUFormat - it was automatically selected based on the PixelFormat and PixelDataType. This made it impossible, for instance, to select a 16 bit floating point GPU format while still supplying 32 bit floating point pixel data. NVSG version 4.0 and beyond allow selection of one of three different types of TextureGPUFormats: Generic, Semi-Generic, and Explicit. These are described below.
Generic Formats

Generic formats allow NVSG's texture routines to pick the most appropriate TextureGPUFormat based on the PixelFormat and PixelDataType supplied. A table is provided later that shows how this selection takes place. The Generic format TGF_DEFAULT (the default) tells NVSG to use a selection mechanism similar to pre-4.0 NVSG versions. Selection of other formats are mainly based on the PixelDataType and the OpenGL extensions that are available on the system. Other formats are:
  • TGF_FIXED: Choose a fixed-point format that most closely matches the PixelFormat and PixelDataType. This will typically be an 8, 10, or 16 bit per component format, based on the PixelDataType.
  • TGF_FLOAT: Chose a floating point format that most closely matches the PixelFormat and PixelDataType. Note that there are only 16 bit and 32 bit floating point formats, currently.
  • TGF_NONLINEAR: Chose an SRGB (nonlinear color space) format that most closely matches the PixelFormat and PixelDataType. The SRGB color space only defines 8 bit per component data, and so all data will be 8 bit regardless of the PixelDataType.
  • TGF_INTEGER: Chose a integer format that most closely matches the PixelFormat and PixelDataType. 8, 16, and 32 bit integer textures are supported - so the closest one matching the PixelDataType will be selected. Note that supplying a floating-point PixelDataType is illegal with integer textures.
  • TGF_COMPRESSED_FIXED: Chose a fixed-point compressed format that most closely matches the PixelFormat and PixelDataType. Note that if EXT_texture_compresssion_latc is supported, then 8 bit signed/unsigned compressed formats are supported. Otherwise all compressed formats are unsigned.
Semi-Generic Formats

The Simi-Generic formats allow selection between certain fixed and floating point formats only.
  • TGF_FLOAT16: Choose a 16 bit floating point format, regardless of the PixelDataType.
  • TGF_FLOAT32: Chose a 32 bit floating point format, regardless of the PixelDataType.
  • TGF_FIXED8: Chose an 8 bit format, regardless of the PixelDataType.
  • TGF_FIXED10: Chose a 10 bit format, regardless of the PixelDataType. This will be RGB10 or RGB10A2 depending on the PixelFormat.
  • TGF_FIXED16: Chose a 16 bit format, regardless of the PixelDataType.
Explicit Formats

A fair number of explicit formats are also defined. Look at the TextureGPUFormat enumeration in TextureImage.h for the complete list. Note that NVSG attempts to provide fallbacks if extensions are not supported, but does not attempt to convert PixelDataTypes from extensions that are not supported to those that are supported.
Compressed Texture Formats

Textures may be compresed on upload by using any of the TGF_*COMPRESSED* TextureGPUFormats. However, textures may also be pre-compressed in one of the ARB, S3TC, or LATC formats. In this case, one of the *COMPRESSED* PixelFormat formats should be selected when defining the TextureImage. NVSG does not support creating mipmaps, scaling, or any other conversions on precompressed texture maps. Also, NVSG's texture loaders currently uncompress textures loaded from disk, so the only way to submit a compressed texture map is to load it or generate it manually.
Texture Parameters Conversion Chart

The end of this document contains a table that shows the texture parameters conversion chart, which decodes the texture format given a combination of TextureGPUFormat, PixelFormat and PixelDataType.

TextureGPUFormat Selection Mechanisms

NVSG provides several methods to allow selection of the TextureGPUFormat. These are described below

Programmatic Selection

Both the TextureImage class and CgFx classes have been extended to allow selection of the TextureGPUFormat. TextureImage::setTextureGPUFormat and TextureImage::getTextureGPUFormat are setters and getters for the TextureGPUFormat; as are CgFx::setSamplerTextureGPUFormat and CgFx::getSamplerTextureGPUFormat . These methods must be called before TextureAttributeItem::setTextureImage or CgFx::setSamplerTextureImage is called or they will have no effect.
CgFX-based Parameter Selection

Sampler definitions in CgFx effects may contain annotations that describe the desired TextureGPUFormat to use. The string annotation "GPUFormat" may contain any of the TGF_ formats described earlier, or those in TextureImage.h without the TGF_ prefix. For instance,

sampler2D mysampler
<
   string GPUFormat = "FIXED8";
> = sampler_state
{
   [...]
};

GLTraverser Generic Format

nvsg::GLTraverser includes a new method GLTraverser::setTextureGenericFormat. This method allows all textures that are uploaded AFTER this call is made to be forced to a specific TextureGPUFormat. Setting the value to TGF_COMPRESSED_FIXED, for instance, will compress all textures upon upload to the GPU; or TGF_NONLINEAR will convert all textures to SRGB upon upload. Not all formats make sense - so user-beware.
NVSG Texture Parameters Conversion Chart |  |  |  |  |  |
 | TextureGPUFormat | TGF_FIXED | TGF_FLOAT | TGF_INTEGER | TGF_COMPRESSED_FIXED | TGF_NONLINEAR
PixelFormat | PixelDataType |  |
IMG_COLOR_INDEX | ALL DATA TYPES | ALL INVALID |
IMG_RGB | IMG_BYTE | SIGNED_RGB8_NV | RGB16F_ARB | RGB8I_EXT | SIGNED_RGB8_NV | SRGB8_EXT
IMG_RGBA | IMG_UNSIGNED_BYTE | RGB8 | RGB16F_ARB | RGB8UI_EXT | COMPRESSED_RGB | SRGB8_EXT
IMG_BGR | IMG_SHORT | SIGNED_RGB8_NV | RGB16F_ARB | RGB16I_EXT | SIGNED_RGB8_NV | SRGB8_EXT
IMG_BGRA | IMG_UNSIGNED_SHORT | RGB16 | RGB16F_ARB | RGB16UI_EXT | COMPRESSED_RGB | SRGB8_EXT
 | IMG_INT | SIGNED_RGB8_NV | RGB32F_ARB | RGB32I_EXT | SIGNED_RGB8_NV | SRGB8_EXT
 | IMG_UNSIGNED_INT | RGB16 | RGB32F_ARB | RGB32UI_EXT | COMPRESSED_RGB | SRGB8_EXT
 | IMG_FLOAT | RGB16 | RGB32F_ARB | RGB32I_EXT | RGB32F_ARB | SRGB8_EXT
 | IMG_HALF | RGB16 | RGB16F_ARB | RGB32I_EXT | RGB16F_ARB | SRGB8_EXT
 | IMG_UNSIGNED_INT_2_10_10_10 | RGB10 | RGB16F_ARB | RGB16I_EXT | COMPRESSED_RGB | SRGB8_EXT
 | IMG_UNSIGNED_INT_5_9_9_9 | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT
 | IMG_UNSIGNED_INT_10F_11F_11F | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT
 | IMG_UNSIGNED_INT_24_8 | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
IMG_LUMINANCE | IMG_BYTE | SIGNED_LUMINANCE8_NV | LUMINANCE16F_ARB | LUMINANCE8I_EXT | COMPRESSED_SIGNED_LUMINANCE_LATC1 | SLUMINANCE8_EXT
IMG_ALPHA | IMG_UNSIGNED_BYTE | LUMINANCE8 | LUMINANCE16F_ARB | LUMINANCE8UI_EXT | COMPRESSED_LUMINANCE_LATC1 | SLUMINANCE8_EXT
IMG_LUMINANCE_ALPHA | IMG_SHORT | SIGNED_LUMINANCE8_NV | LUMINANCE16F_ARB | LUMINANCE16I_EXT | COMPRESSED_SIGNED_LUMINANCE_LATC1 | SLUMINANCE8_EXT
 | IMG_UNSIGNED_SHORT | LUMINANCE16 | LUMINANCE16F_ARB | LUMINANCE16UI_EXT | COMPRESSED_LUMINANCE_LATC1 | SLUMINANCE8_EXT
 | IMG_INT | SIGNED_LUMINANCE8_NV | LUMINANCE32F_ARB | LUMINANCE32I_EXT | COMPRESSED_SIGNED_LUMINANCE_LATC1 | SLUMINANCE8_EXT
 | IMG_UNSIGNED_INT | LUMINANCE16 | LUMINANCE32F_ARB | LUMINANCE32UI_EXT | COMPRESSED_LUMINANCE_LATC1 | SLUMINANCE8_EXT
 | IMG_FLOAT | LUMINANCE16 | LUMINANCE32F_ARB | LUMINANCE32I_EXT | COMPRESSED_LUMINANCE_LATC1 | SLUMINANCE8_EXT
 | IMG_HALF | LUMINANCE16 | LUMINANCE16F_ARB | LUMINANCE32I_EXT | COMPRESSED_LUMINANCE_LATC1 | SLUMINANCE8_EXT
 | IMG_UNSIGNED_INT_2_10_10_10 | LUMINANCE16 | LUMINANCE16F_ARB | LUMINANCE16I_EXT | COMPRESSED_LUMINANCE | SLUMINANCE8_EXT
 | IMG_UNSIGNED_INT_5_9_9_9 | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT
 | IMG_UNSIGNED_INT_10F_11F_11F | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT
 | IMG_UNSIGNED_INT_24_8 | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
IMG_DEPTH_COMPONENT | IMG_BYTE | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB
 | IMG_UNSIGNED_BYTE | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB
 | IMG_SHORT | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB
 | IMG_UNSIGNED_SHORT | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB
 | IMG_INT | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB
 | IMG_UNSIGNED_INT | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB
 | IMG_FLOAT | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB | DEPTH_COMPONENT32_ARB
 | IMG_HALF | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB
 | IMG_UNSIGNED_INT_2_10_10_10 | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB | DEPTH_COMPONENT16_ARB
 | IMG_UNSIGNED_INT_5_9_9_9 | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT
 | IMG_UNSIGNED_INT_10F_11F_11F | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT
 | IMG_UNSIGNED_INT_24_8 | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
IMG_DEPTH_STENCIL | IMG_BYTE | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_UNSIGNED_BYTE | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_SHORT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_UNSIGNED_SHORT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_INT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_UNSIGNED_INT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_FLOAT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_HALF | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_UNSIGNED_INT_2_10_10_10 | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
 | IMG_UNSIGNED_INT_5_9_9_9 | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT
 | IMG_UNSIGNED_INT_10F_11F_11F | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT
 | IMG_UNSIGNED_INT_24_8 | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
IMG_INTEGER_ALPHA | IMG_BYTE | RGB8I_EXT | RGB8I_EXT | RGB8I_EXT | RGB8I_EXT | RGB8I_EXT
IMG_INTEGER_LUMINANCE | IMG_UNSIGNED_BYTE | RGB8UI_EXT | RGB8UI_EXT | RGB8UI_EXT | RGB8UI_EXT | RGB8UI_EXT
IMG_INTEGER_LUMINANCE_ALPHA | IMG_SHORT | RGB16I_EXT | RGB16I_EXT | RGB16I_EXT | RGB16I_EXT | RGB16I_EXT
IMG_INTEGER_RGB | IMG_UNSIGNED_SHORT | RGB16UI_EXT | RGB16UI_EXT | RGB16UI_EXT | RGB16UI_EXT | RGB16UI_EXT
IMG_INTEGER_RGBA | IMG_INT | RGB32I_EXT | RGB32I_EXT | RGB32I_EXT | RGB32I_EXT | RGB32I_EXT
IMG_INTEGER_BGR | IMG_UNSIGNED_INT | RGB32UI_EXT | RGB32UI_EXT | RGB32UI_EXT | RGB32UI_EXT | RGB32UI_EXT
IMG_INTEGER_BGRA | IMG_FLOAT | INVALID | INVALID | INVALID | INVALID | INVALID
 | IMG_HALF | INVALID | INVALID | INVALID | INVALID | INVALID
 | IMG_UNSIGNED_INT_2_10_10_10 | RGB16I_EXT | RGB16I_EXT | RGB16I_EXT | RGB16I_EXT | RGB16I_EXT
 | IMG_UNSIGNED_INT_5_9_9_9 | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT | RGB9_E5_EXT
 | IMG_UNSIGNED_INT_10F_11F_11F | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT | R11F_G11F_B10F_EXT
 | IMG_UNSIGNED_INT_24_8 | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT | DEPTH24_STENCIL8_EXT
IMG_COMPRESSED_LUMINANCE_LATC1 | ALL DATA TYPES | COMPRESSED_LUMINANCE_LATC1_EXT |
IMG_COMPRESSED_LUMINANCE_ALPHA_LATC2 | ALL DATA TYPES | COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT |
IMG_COMPRESSED_RED_RGTC1 | ALL DATA TYPES | COMPRESSED_RED_RGTC1_EXT |
IMG_COMPRESSED_RG_RGTC2 | ALL DATA TYPES | COMPRESSED_RED_GREEN_RGTC2_EXT |
IMG_COMPRESSED_RGB_DXT1 | ALL DATA TYPES | COMPRESSED_RGB_S3TC_DXT1_EXT |
IMG_COMPRESSED_RGBA_DXT1 | ALL DATA TYPES | COMPRESSED_RGBA_S3TC_DXT1_EXT |
IMG_COMPRESSED_RGBA_DXT3 | ALL DATA TYPES | COMPRESSED_RGBA_S3TC_DXT3_EXT |
IMG_COMPRESSED_RGBA_DXT5 | ALL DATA TYPES | COMPRESSED_RGBA_S3TC_DXT5_EXT |
IMG_COMPRESSED_SRGB_DXT1 | ALL DATA TYPES | COMPRESSED_SRGB_S3TC_DXT1_EXT |
IMG_COMPRESSED_SRGBA_DXT1 | ALL DATA TYPES | COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT |
IMG_COMPRESSED_SRGBA_DXT3 | ALL DATA TYPES | COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT |
IMG_COMPRESSED_SRGBA_DXT5 | ALL DATA TYPES | COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT |

Back to Fundamental Concepts

Generated on Tue Jan 15 10:28:47 2008 for NVSGSDK by NVIDIA


Writing a Loader/Saver Plug-In

This section presents information common to the development of a Scene Loader or Saver Plug-In. It discusses the sample files, the plug-in directory search mechanism, and the standard DLL functions.

Loader and Saver plug-ins are implemented as dynamic link libraries (DLLs) - also called "Shared Objects" or .so's under Linux. This document uses the term "DLL" to refer to either Shared Objects or Dynamic Link Libraries.

DLLs are object code libraries that let multiple programs share code, data, and resources. Dynamic linking allows an executable module to include only the information needed at run time to locate the executable code for a DLL function. This type of linking differs from the more familiar static linking, which requires a copy of a library function's executable code in the executable module of each application using it.

The development tool for creating DLLs is Microsoft Visual C++, and GCC for creating Shared Objects under Linux. For a description of how to create a new plug-in see Creating a New Plug-in Project.

In order to distinguish an NVSG Loader/Saver from regular DLLs and SOs the file extensions of Loaders/Savers has been changed to .nxm. This also provides advantages when dynamically searching for NVSG plug-in objects.

Required Plug-In Entry Points

There are two DLL entry points that a plug-in must export. These two 'must have' entry points are:

  • bool queryPlugInterfaceType( const nvutil::UPITID& pitid, vector<nvutil::UPIID>& piids )
  • bool getPlugInterface( const nvutil::UPIID& piid, nvutil::PlugIn *& plug )

Then, depending on the type of plug in, one of the following must be exported:

  • SceneHandle * load( const std::string & filename, const std::vector<std::string> & searchPaths, ViewStateHandle *& viewState )
  • bool save( SceneHandle * scene, ViewStateHandle * viewState, const string & filename )

Implementation of the Plug-In Entry Points

This section briefly points out, in general terms, how the entry points can be implemented.

Implementation of queryPlugInterfaceType

The following sample code shows a possible implementation of a Plug-In for both loading and saving .NBF files:

// NBFLoaderSaver.cpp

#include "nvsg/PlugInterfaceID.h" // definition of UPITID_VERSION,
                                  // UPITID_SCENE_LOADER, and
                                  // UPITID_SCENE_SAVER

// unique plug-in types
const UPITID PITID_SCENE_LOADER(UPITID_SCENE_LOADER, UPITID_VERSION);
const UPITID PITID_SCENE_SAVER(UPITID_SCENE_SAVER, UPITID_VERSION);

bool queryPlugInterfaceType(const UPITID& pitid, vector<UPIID>& piids)
{
  piids.clear();
  if ( pitid==PITID_SCENE_LOADER )
  {
    piids.push_back(UPIID(".NBF", PITID_SCENE_LOADER));
  }
  else if ( pitid==PITID_SCENE_SAVER )
  {
    piids.push_back(UPIID(".NBF", PITID_SCENE_LOADER));
  }
  return !piids.empty();
}

Implementation of getPlugInterface

The following sample code shows a possible implementation of a Plug-In for both loading and saving .NBF files:

bool getPlugInterface(const UPIID& piid, PlugIn *& pi)
{
  const UPIID PIID_NBF_SCENE_LOADER = UPIID(".NBF", PITID_SCENE_LOADER));
  const UPIID PIID_NBF_SCENE_SAVER  = UPIID(".NBF", PITID_SCENE_SAVER));

  if ( piid==PIID_NBF_SCENE_LOADER )
  {
    return !!(pi=new NBFLoader());
  }
  else if ( piid==PIID_NBF_SCENE_SAVER )
  {
    return !!(pi=new NBFSaver());
  }
  return false;
}

Loader's load() method

All loaders must also implement the load() method. The following is an example of the guts of this method. See elsewhere for examples of how to create hierarchy and state to add to the toplevel group node.

SceneHandle *
XYZLoader::load(  const std::string& filename,
                  const std::vector<std::string> &searchPaths,
                  ViewStateHandle *& viewState )
{
  NVSG_TRACE();

  //
  // filename is the file to open
  // searchPaths will contain a set of system search paths that your loader
  //             should examine when loading the main file or subfiles.
  // viewstate will contain information on the view, and may be used to
  //           add cameras and other things to the scene.
  //

  XYZFile * xyz;
  // create toplevel group
  RCObject_AutoPtr<GroupHandle> hGroup(CreateHandle( GroupHandle ));

  if( (xyz = xyzFormatOpenFile( filename, searchPaths )) )
  {
    WritableObject< Group > group( hGroup.get() );

    group->setName( filename );

    // parse/build scene with group as the base
    xyz->buildScene( group );

    delete xyz;
  }
  else
  {
    NVSG_TRACE_OUT_F(( "Unable to load file.." ));
    return 0;
  }

  // now create toplevel scene
  RCObject_AutoPtr<SceneHandle> hScene( CreateHandle( SceneHandle ));

  // add group as scene's toplevel
  {
    WritableObject< Scene > scene( hScene.get() );
    scene->setRootNode( hGroup.get() );
  }

  // return it
  return hScene.release();
}

Saver's save() method

All savers must also implement the save() method. The following is an example of the guts of this method. See elsewhere for examples of how to traverse a scene and extract geometry and hierarchy of value.

bool XYZSaver::save(SceneHandle *scene, ViewStateHandle *viewState, const string& filename)
{
  NVSG_TRACE();

  // NOTE: for saving purposes, we need to traverse the scene unculled!
  bool success = false;
  RCObject_AutoPtr<ViewStateHandle> vwState;
  if ( viewState )
  { // copying a ViewState clears the cull tree!
    vwState.reset(viewState->clone());
    NVSG_ASSERT(!ReadableObject<ViewState>(vwState.get())->getCullTree());
  }

  //
  // use your custom traverser to parse and save the scene
  //
  m_traverser->setViewState(vwState.get());
  m_traverser->preCalculateFileSize(scene);
  m_traverser->setFileName( filename );
  m_traverser->apply(scene);

  return( m_traverser->getSuccess() );
}

Back to Advanced

Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


NVSG COLLADA/FX File Format Loader

  • Hierarchy and Scene Elements
  • Geometry
  • Animations
  • Skinning Support in NVSG
  • Materials and Effects
  • Transparency
  • FX Composer
  • Environment Variables:
  • Unsupported Items
  • Credits

This is a loader for the Khronos Group's COLLADA and COLLADA FX XML file format. The loader currently supports version 1.4.1 of the COLLADA file format.

Khronos states that COLLADA is an "interchange" file format, not necessarily a final rendering format. Even so, NVSG attempts to render the file correctly, in high fidelity, with decent performance. Once loaded into NVSG, much of the original COLLADA representation is lost, except as noted below.

Most COLLADA geometry and hierarchy nodes are supported, and build the expected NVSG scene graph. The following sections outline how a COLLADA file is converted into an NVSG scene.

Hierarchy and Scene Elements

  • NODE nodes either create a named NVSG Group or an NVSG Transform as a parent, depending on whether transformations are found in the children of the node.

  • ROTATE, TRANSLATE, MATRIX, SCALE, LOOKAT are all supported and concatenated together into a composite matrix for the Transform node. Matrices are not concatenated if they are referenced in an animation, as described later. SKEW matrices are not yet supported.

  • SKIN, JOINT, SKELETON are all supported. See the section on skinning for more information.

  • CAMERA nodes are supported, both orthographic and perspective. However, COLLADA’s cameras are part of the scene hierarchy, and NVSG’s cameras are separate entities. This means that the transformation nodes above the camera are concatenated and used to position the camera before being added to the nvsg::Scene.

  • LIGHT nodes are supported (AMBIENT, DIRECTIONAL, POINT, SPOT). It is unclear from the specification as to whether light sources are supposed to only affect the children of the node that contains them or the entire scene, but the consensus seems to be that they are to affect the entire scene. NVSG adds all light sources to the top level of the scene so that they affect all geometry. If a scene contains an ambient light source, it is loaded as the scene's "ambient color." If you believe this is incorrect, please let us know.

Geometry

The loader runs a series of conditioners over the file when it is initially loaded. These conditioners convert all polygonal geometry types (TriStrip, TriFan, Polygon, PolyList, etc) into Triangles. This simplifies the loader and allows better combination and optimization on the final scene.

Lines are supported; and linestrips are supported by being conditioned into lines at load time.

This release contains support for skinning, but does not yet contain support for morph geometry. See the section on skinning for more information.

Animations

Animations are supported if connected to any of the supported transformation nodes described earlier, thus creating and feeding an nvsg::AnimatedTransform node, being interpolated linearly. Animations connected to JOINTs in a SKELETON are also supported. Other types of animations and interpolations are not currently supported.

COLLADA assumes that the animation system will use TIME as an input to feed the progression of animations, whereas NVSG’s ViewerVR application uses a frame-based approach. So the loader assumes a frame rate of 60 fps when creating the animation data structures for proper display in ViewerVR. These assumptions can be changed programmatically by the application if they are not appropriate.

Skinning Support in NVSG

All SKIN, JOINT and SKELETON nodes should be supported in this release. NVSG's skinning system has been greatly enhanced to support the somewhat complex notion of skinning and animations in COLLADA. Multiple disjoint SKELETON and JOINT nodes are supported for each skinned geometry. Due to some ambiguities in the documentation and the lack of a large base of skinned models to test with, it may be that not all skinned models will render correctly. Please help us improve NVSG and send any models you feel are not being interpreted correctly to nvsghelp@nvidia.com.

NVSG supports skinning using the CPU or the GPU (on G80 or better hardware). See the docs in NVSG on skinning for more information.

Materials and Effects

All textures and materials+effects are cached as they are loaded so that only one copy of each resides in memory at once.

  • profile_COMMON NVSG fully supports the common profile of COLLADA. This means that AMBIENT, DIFFUSE, SPECULAR, EMISSIVE, TRANSPARENT and REFLECTIVE lighting components are all combined appropriately, and can either be a texture or a color. All lighting models (BLINN, PHONG, CONSTANT, LAMBERT) are supported as well, with BLINN and PHONG being treated the same – both using a reflection vector rather than the half angle vector.

To facilitate this, the loader dynamically builds a CgFX shader for each material+effect combination. The shaders can be configured to perform lighting and shading per-fragment or per-vertex through the use of environment variables. The default is per-fragment lighting for maximum quality.

Based on the COLLADA reference, NVSG uses the following lighting computation:

// accumulate lighting intensities for the surface into
// [ambient|diffuse|specular]Light

// sample textures or assign colors to materials: emissive, ambient, diffuse
// specular, reflective, transparent

diffuseMaterial = lerp( diffuseMaterial, reflectiveMaterial, reflectivity );

if( ALPHA_ONE mode )
  float alpha = transparentMaterial.a * transparency;
else if( RGB_ZERO mode )
  float alpha = luminance( transparentMaterial.rgb ) * transparency;

float3 result = sceneAmbient * ambientMaterial +
                emissiveMaterial +
                ambientMaterial * ambientLight +
                diffuseMaterial * diffuseLight +
                specularMaterial * specularLight;

return float4( result, alpha );

if( ALPHA_ONE mode )
  BlendingEnable = true;
  BlendFunc = int2( SrcAlpha, OneMinusSrcAlpha );
else if( RGB_ZERO mode )
  BlendingEnable = true;
  BlendFunc = int2( OneMinusSrcAlpha, SrcAlpha );

  • profile_CG NVSG fully supports “COLLADA FX” through the CG profile. Techniques, passes, GL State, and Cg code are all translated into a CgFX with all "newparam" variables exposed as tweakables in the final CgFX.

  • profile_GLSL Not currently supported
  • profile_GLES Not currently supported.

Transparency

A quick note about transparency: It seems that there was (and still is) confusion between DCC tools and exporters regarding transparency. If using ALPHA_ONE, transparency=1.0 is OPAQUE; if using RGB_ZERO, transparency=0.0 is OPAQUE. There are some environment variables that can help with fixing this for files that get it wrong. There are some hacks in the loader to set these values for various tools (XSI, SketchUp). Bottom line is this: if you load a file and all or some of the geometry is invisible (transparent) suspect the transparency value needs to be subtracted from one. If you believe we have this wrong please let us know.

Also, as shown above, we do not fully support the RGB_ZERO transparency mode, as we do not have a good way to set the blend color on a per fragment basis.

FX Composer

Models exported from FX Composer that have been converted to COLLADA FX should work. Here is a procedure for exporting a usable file from FX Composer:

  • Create a new project.
  • Choose "Add Sphere"
  • In the center window choose tab "Shader Library"
  • Drag and Drop the "Relief Mapping" shader onto the sphere.
  • In left pane, switch bottom tabs to "Assets"
  • In the Assets tree window, to go Effects->relief_mapping->relief_mapping.cgfx
  • Right click on relief_mapping.cgfx and choose "Convert to COLLADA FX" (you MUST convert the effect)
  • Choose File->Save Document1 as
  • Save as a collada file
  • Load this file into ViewerVR.
  • Open Materials dialog and play with all the tweakables and techniques.
  • Enjoy!

Environment Variables:

NVSG_DAE_WORKAROUNDS: This variable may be set to a number of “KEY=VALUE” pairs separated by colons. The values understood are:

  • LIGHTING=[FRAGMENT:VERTEX]: This flag sets the lighting mode used by the shader builder for profile_COMMON effects. The default is to generate a shader to perform per-fragment lighting/shading. Setting LIGHTING=VERTEX (or any value other than FRAGMENT) will create shaders performing vertex lighting/shading.
  • OPTIMIZE = [TRUE|FALSE]: Setting this flag to TRUE (the default) will cause the shader builder to optimize away lighting components that will not contribute to the final lighting equation. If you suspect a bug in the shader builder you may want to set this flag and see if the visual result is correct.
  • IGNORE_TRANSPARENCY: If set, will cause the shader builder to ignore any transparency given in the common profile. This may be necessary if your DCC tool writes out incorrect transparency statements (such as earlier versions of XSI).
  • ONE_MINUS_TRANSPARENCY: If set, will cause the shader builder to subtract the given transparency from 1 (eg: 1 – transparency). There is an amount of unfortunate confusion with some DCC tools (Google SketchUp, and tools using earlier versions of FCollada, for instance) causing them to output the wrong transparency values.

Unsupported Items

Several of the items in the top level are unsupported: is decoded but will not attempt to rotate the model - typically the application will decide what the UP vector is based on its own camera settings; is decoded but does not currently attempt to scale the model.

geometry is not supported.

matrices are not supported.

are not supported.

FX Composer's fields that allow direct of CgFX files are not currently supported. Support for this may be added in the next version. The workaround is to simply convert them to COLLADA/FX in FX Composer before exporting for NVSG.

Credits

This loader uses the “COLLADA DOM” to parse the COLLADA file format, and also uses portions of the “COLLADA FX” library to parse effects containing shaders. These libraries are available from www.khronos.org.
Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


NVSG MultiGen OpenFlight(tm) File Format Loader

  • Node Attributes
  • OpenFlight Records
  • Face Attributes
  • Texturing
  • Shaders
  • Environment Variables:
  • Credits

This is a loader for Multigen OpenFlight file format. Version 14.x thru 16.2 files should parse correctly - other versions are not guaranteed to work. Most OpenFlight nodes are supported, and build the expected NVSG scene graph. The following is a description of the records and attributes that are supported in version 4.0 beta.

Node Attributes

  • Matrix Attributes attached to any node cause an NVSG Transform node to be inserted in the hierarchy ahead of the node itself.
  • Replication Attributes are obeyed and operate as expected.
  • Comment Attributes are applied as "Annotations" to each node type, and can be queried once the model is loaded.
  • NVSG Nodes are named from the OpenFlight record.

OpenFlight Records

  • HEADER: If the header flags contain the setting for "RGB_COLOR" mode, then the database will be expected to be in RGB color. This means that vertices with colors are expected to contain RGB colors rather than paletted colors. Children of the header are parsed to build the scene. See the workarounds section for potential workarounds for this node.

  • EXTERNAL REFERENCES: External references cause external model files to be read from disk and inserted into the hierarchy at the point they were encountered. References to ExtRefs are cached such that they are never loaded twice. Cached external references are cloned if referenced a second time. Note that NVSG does not currently support using any of the palettes in the parent file, nor is there support for FILE:node referencing.

  • INSTANCING: Instance definitions are cached and when instance references are encountered the parent geometry is cloned to create the child.

  • LIGHT SOURCES: All light source types are supported. Light sources that do not have the flags "Enabled" and "Export to Realtime" set are NOT imported. NVSG supports hierarchical light sources like OpenFlight (light sources only cast light on nodes below them in the hierarchy.) If a light has the "Global" flag set, it is simply inserted at the topmost node in the hierarchy. NVSG does not currently support adding annotations to Light sources, so comments will be ignored.

  • LIGHT POINTS, INDEXED LIGHT POINTS/SYSTEMS: Light points and light point systems are naively supported. This means that they are parsed as antialiased points, their color is set, and their point size is set to 5.

  • MESH: Meshes are currently not supported. Support may be added in the future.

  • LODs: Level of Detail nodes are fully supported and attempt to construct an optimized single LOD node in NVSG where possible. All sibling LOD records that are found containing approximately the same center and matching LOD ranges are combined together under a single NVSG LOD. Empty group nodes may be inserted into the hierarchy to correct for differences between OpenFlight and NVSG LODs. If the LOD is found to have an "infinite" center value, the LOD center is computed from the child geometry's bounding sphere.

  • SWITCH: OpenFlight switch masks are fully supported and were added to NVSG's Switch class. They should operate as expected.

  • DOFs: Degree of Freedom nodes are created using a pair of transforms. One to transform the local coordinate system to its given position, and the second to allow runtime modification. The second transform is named from the OpenFlight DOF. This should work as expected.

  • GROUP: Group nodes create NVSG Groups. They can be optimized away at load time if they contain only 1 child. Groups are not removed if the "Preserve at RunTime" flag is set, they are animations, they contain more than one child, or their parent was a switch or an animated group. If the Group is an animation, then an NVSG FlipbookAnimation is created instead of a group. LoopDuration and LastFrameDuration are supported, as is the custom comment field "vt_loop_duration = [duration]". The loader currently makes the assumption that the visual system will run at 60 frames per second when creating the timings for each frame. If no durations are given, then the loader assumes that you want to advance 1 animation frame each simulation frame.

  • OBJECT: OpenFlight objects are typically removed and their associated geometry is added to their parent. An NVSG Geode is created for each object if the "Preserve at Runtime" flag is set, or the object is a child of a Switch or Animated Group.

  • FACE: Face records are typically collected into a group that has been sorted by state. NVSG does not contain a simple "face" primitive so attempting to find faces by name at runtime will almost certainly fail. Face comments are also ignored. Faces with the Axial Rotate or Point Rotate create the proper NVSG Billboard node for this face, and faces that contain a transform are placed by themselves below an NVSG Transform node. Faces are automatically tessellated and triangulated, and even most convex faces are handled appropriately. Degenerate faces are removed. Lit faces without normals will have face normals generated for them. See "Face Attributes" later.

  • SUBFACE: Subfaces are handled by adding a small amount of polygon offset to resolve the Zbuffer appropriately.

Face Attributes

  • Colors: Face Primary Color from the color palette or as an RGB color. Alternate Color is ignored.
  • Materials: Full material palette is supported, along with material names.
  • Render State:
  • Type [SOLID|WIREFRAME|CLOSEDWIREFRAME] supported
  • Shade: -- FLAT: Face color, not subject to lighting. -- LIT: Use face color * material and vertex normals. -- GOURAUD: Vertex Colors, not subject to lighting. -- LIT GOURAUD: Apply vertex color * material at each vertex, and use vertex normals.
  • Line Style: Supported when the primitive is wireframe.
  • Transparency: Supported.
  • Two Sided: Supported by adding a no-culling flag in NVSG.
  • Textured Polygon White: Supported as expected, by ignoring the face color if textured.
  • Hidden Polygon: Supported - poly removed at load time.
  • Mapping: The texture "Mapping" palette entry is only checked to see if it is of type "Environment Mapping." If so this texture is applied as an environment map to the polygon using texture coordinate generation. MultiGen provides no documentation on how this is to be performed, so we guessed at what we thought they meant.

If the face has the FIXED_WITH_ALPHA flag set, and contains transparency, or the material contains transparency a "blended" transparency mode is used. If the FIXED_WITH_ALPHA flag is set and the texture contains transparency, an "alphafunc" style transparency is used. See "Environment Variables" later for a way to change this behavior.

Texturing

Base, Detail, and Layers 1-7 are supported. Texture layers 1-7 may have an Effect and Effect Data specified. Textures are cached in a local texture palette by their pattern index, and are only loaded once. In addition, textures with the same path name are also only loaded once. Textures are applied using the Texture Environment, Min/Mag Filter, and Wrap Method stored in the Attr file. If no attr file is present the defaults are MODULATE, Trilinear Mip, Bilinear, and Repeat, respectively.

  • Detail Textures: Detail textures are typically assigned to texture unit 1. They are applied using Modulate and Scale 2x texture environment mode. In order to apply scaling, the Detail Texture setting must be checked in the Texture Attributes dialog, and the "m" and "n" values will be multiplied by the base texture U, V mapping to determine the detail texture texcoords.

  • Layers 1-7: Other texture layers will be applied as expected to the geometry using the settings from the attr file or the defaults given above.

  • Bump Maps: If the texture 'effect' is set to bump map then the texture is applied as a bump map using a normalization cube map. If 'Effect Data' is set to a nonzero value, then tangent and binormal vectors are computed and placed in texcoords starting at the texture unit specified in 'Effect Data.' This is really only useful for shaders, which are described later.

Shaders

The standard shader environment as presented by Creator is supported in NVSG. The uniform variables as described in the creator documentation are supported, and turned into tweakables, ready for your application to modify them at runtime (meaning that NVSG does not continually update eyePosition, simulationTime, frameNumber, etc - this is up to the application.) NVSG currently only supports CgFX shaders. This means that ONLY Cg shaders are supported, and the shaders given in the OpenFlight file must be converted into a CgFX representation by the loader. While most situations are handled appropriately, there is one caveat to this process: members of attribute structures must use the same names between vertex and fragment shaders as the structs need to be combined into a single structure for the CgFX. For example:

VertexShader.cg:

struct vertToFrag
{
  float4 pos : POSITION;
  float4 texcoord: TEXCOORD0;
};

[...]

FragmentShader.cg

struct vertToFrag
{
  float4 pos : POSITION;
  float4 texCoord: TEXCOORD0;
};

[...]

Will end up generating an invalid CgFX because one of the structures will be eliminated and the case will be wrong for "texcoord" in one or the other shader stage. We mention this because at least one example in the Creator distribution does exactly this, and it is impossible for us to check and correct this for now.

A second, and preferred, method to apply a shader to the scene is to use a CgFX file. While Creator's dropdown for "Type" appears to support CgFX, it will not allow you to select it. So, to add a CgFX shader to the shader palette simply select "Cg" as the type, and enter the name of the CgFX file (with extension .cgfx) in the vertex shader entry, and leave the fragment shader entry blank. Our runtime will notice that you have specified a CgFX shader and will load it appropriately.

Environment Variables:

TXTPATH: Is the path to your textures and externally referenced .flt files. It is added to the list of external paths which may have already been specified through function calls in NVSG. Note that directories must be separated by semicolons ';' since MultiGen Creator inserts the drive letter with a colon in the path list. From bash this would be 'export TXTPATH="/root/tex;/root/myfiles/tex"'. Note the double quotes are necessary because bash considers the semicolon as a command separator.

NVSG_FLT_WORKAROUNDS: This variable may be set to a number of KEY=VALUE pairs separated by colons. The values understood are:

  • TRANSPARENCY_FROM_TEXTUREALPHA: Regardless of any face flags, only check the texture type to determine if transparency should be added to this polygon. The Performer and OSG loaders erroneously behave this way.
  • LIGHTING_MODE = [FLAT|GOURAUD|LIT|LIT_GOURAUD]: Force lighting mode to be that specified for all faces.
  • BLENDED_TRANSPARENCY: Always use blending and never alpha transparency for faces requiring transparency.
  • CHILDLESS_HEADER: Some OpenFlight files were erroneously written such that there is no "push" after the header, thus making the header childless. The loader attempts to traverse children of the header and will create an empty scene because it can not find any children. Performer and (possibly?) OSG will incorrectly parse these files ignoring this fact. Setting this value allows NVSG to find the other nodes as well.

Credits

This loader uses Fltlib to parse the OpenFlight file format. Fltlib is a MultiGen OpenFlight file format loader library written by Michael Morrison. It is available as an open source project at fltlib.sourceforge.net.

MultiGen, OpenFlight, and Flight Format are registered trademarks of MultiGen-Paradigm Inc.

Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


FLTLoader.h Source File

FLTLoader.h

00001
00002 // Copyright NVIDIA Corporation 2002-2005
00003 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00004 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00005 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00006 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00007 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00008 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00009 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00010 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00011 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00012 // POSSIBILITY OF SUCH DAMAGES
00013
00014 //
00015 // FLTLoader.h
00016 //
00017
00018 #ifndef _LOADFLT_H_
00019 #define _LOADFLT_H_
00020
00021 #if ! defined( DOXYGEN_IGNORE )
00022
00023 #include <string>
00024 #include <vector>
00025 #include <map>
00026 #include <list>
00027 #include <flt.h>
00028
00029 #include <nvsg/nvsgapi.h>
00030 #include <nvsg/nvsg.h>
00031 #include <nvsg/Scene.h>
00032 #include <nvsg/PlugInterface.h>
00033 #include <nvutil/Trace.h>
00034 #include <nvmath/Vecnt.h>
00035 #include <flt.h>
00036 #include "FLTTextureAttribute.h"
00037 #include "TaiManager.h"
00038
00039 namespace nvsg
00040 {
00041   class Group;
00042   class GeoNode;
00043   class SceneLoader;
00044   class Scene;
00045   class ViewState;
00046   class TextureAttributeItem;
00047   class Material;
00048   class CgFx;
00049 }
00050
00051 class StackedAtlasManager;
00052
00053 #define INVOKE_CALLBACK(cb) if( callback() ) callback()->cb
00054
00055 class FLTLoader : public nvsg::SceneLoader
00056 {
00057 public:
00058   FLTLoader();
00059
00060   void deleteThis( void );
00061
00062   nvsg::SceneHandle * load( const std::string& filename,
00063                             const std::vector<std::string> &searchPaths,
00064                             nvsg::ViewStateHandle *& viewState );
00065
00066 protected:
00067   virtual ~FLTLoader(void);
00068
00069 private:
00070   void buildScene( nvsg::Group *, FltNode *, FltFile *,
00071                     nvmath::Vec3f *, int, bool = true );
00072
00073   enum LookupEnum
00074   {
00075     LOOKUP_DEFAULT,
00076     LOOKUP_DETAIL,
00077     LOOKUP_NORMALMAP
00078   };
00079
00080   // textures
00081   struct TextureEntry
00082   {
00083     // the texture return
00084     nvsg::TextureAttributeItemHandle * hTai;
00085
00086     // 3rd texture coord - if using stacked atlas
00087     int layer;
00088
00089     // these are set if the entry came from a texture atlas
00090     float  uscale;
00091     float  utrans;
00092     float  vscale;
00093     float  vtrans;
00094   };
00095
00096   nvsg::TextureImageHandle * lookupTexture( FltFile *, const std::string & );
00097   bool lookupTexture( TextureEntry & result, FltFile * flt,
00098                       uint16 indx, int16 tmIndx = -1,
00099                       LookupEnum detail = LOOKUP_DEFAULT );
00100
00101   nvsg::TextureAttributeItemHandle * createNormalizationCubeMap(
00102                                                     unsigned int dimension );
00103
00104   // materials
00105   nvsg::MaterialHandle * lookupMaterial( FltFile * flt, uint16 indx,
00106                                           nvmath::Vec3f &color, float trans);
00107
00108   // shaders
00109   nvsg::CgFxHandle * lookupShader( FltFile * flt, uint32 index );
00110   nvsg::CgFxHandle * createCgFxFromFile( FltFile * flt,
00111                                          const std::string & file,
00112                                          std::string & errorReturn,
00113                                          bool & failOnTextureLoadInOut );
00114   // instances
00115   bool createInstance( FltFile * flt, FltNode * root );
00116   nvsg::GroupHandle * lookupInstance( FltFile * flt, uint16 inst );
00117
00118   // extrefs (stored by file name)
00119   bool createExtRef( const std::string & file, nvsg::GroupHandle * grp );
00120   nvsg::GroupHandle * lookupExtRef( const std::string & file );
00121
00122   typedef unsigned long long int mapEntryType;
00123   inline mapEntryType cvtToMapEntry( FltFile * flt, uint16 indx,
00124                                                     uint16 add = 0 )
00125   {
00126     mapEntryType ull;
00127
00128     ull = ((((mapEntryType)fltGetFileID( flt ))<<32)&0xffffffff00000000ull) |
00129               ((indx<<16)&0xffff0000 | (add&0xffff));
00130
00131     return ull;
00132   }
00133
00134   enum ShaderProgramType
00135   {
00136     FLT_VERTEX_SHADER,
00137     FLT_FRAGMENT_SHADER
00138   };
00139
00140   bool buildCgFxFromCg( FltFile * flt,
00141                    const std::string & vertexShader,
00142                    const std::string & vertexEntry,
00143                    const std::string & fragmentShader,
00144                    const std::string & fragmentEntry,
00145                    const std::string & vprofile, const std::string & fprofile,
00146                    std::string & result );
00147
00148   // colors
00149   enum ColorLookupEnum
00150   {
00151     COLOR_NOCOLOR,
00152     COLOR_NOTAVAILABLE,
00153     COLOR_OK
00154   };
00155
00156   ColorLookupEnum
00157         getFaceColor( FltFile * flt, FltFace * face, nvmath::Vec4f & result );
00158   ColorLookupEnum
00159         getVertexColor( FltFile * flt, FltVertex * v, nvmath::Vec4f & result );
00160
00161   uint32 nextFileID( void ) { return m_fileIDs++; }
00162
00163   void buildObject( nvsg::Group * parent, FltNode * node, FltFile * flt,
00164                     nvmath::Vec3f *, int );
00165   void buildFace( nvsg::GeoNode * parent, FltNode * node, FltFile * flt,
00166                     nvmath::Vec3f *, bool isSubFace = false );
00167   inline bool collect( FltNode * node );
00168   void collectDescend( nvsg::GeoNode * , FltNode * , FltFile *,
00169                           nvmath::Vec3f *);
00170   void collectGeometry( nvsg::Group * , FltNode * , FltFile *,
00171                           nvmath::Vec3f *);
00172   void optimizeGeometry( nvsg::GeoNodeHandle * geode );
00173
00174   //
00175   // current workarounds:
00176   //
00177   // CHILDLESS_HEADER - parse all siblings of header node if no children
00178   // LIGHTING_MODE=[FLAT|LIT|GOURAUD|LIT_GOURAUD] - force a lighting mode for
00179   //                                                all polygons.
00180   //
00181   void setWorkaroundMode( const std::string & mode );
00182   bool getWorkaround( const std::string & e,
00183                       std::string * result = 0 );
00184
00185   bool faceNormal( nvmath::Vec3f &, FltVertex ** vlist, unsigned int numVerts );
00186
00187   std::map<mapEntryType,
00188       std::pair<FLTTextureAttribute,nvsg::TextureAttributeItemHandle*> >
00189                                                               m_textureCache;
00190   std::map<std::string, std::string> m_workarounds;
00191   std::map<mapEntryType, nvsg::CgFxHandle*> m_shaderCache;
00192   std::vector< std::string > m_texturesNotFound;
00193   std::vector< std::string > m_shadersNotFound;
00194   std::vector< std::string > m_searchPaths;
00195   std::list<nvsg::MaterialHandle*> m_materialCache;
00196   std::map<mapEntryType,nvsg::GroupHandle*> m_instanceNodes;
00197   std::map<std::string, nvsg::GroupHandle*> m_extRefs;
00198   nvutil::RCObject_AutoPtr< nvsg::TextureAttributeItemHandle >
00199                                                       m_normalizationCubeMap;
00200   bool removeDegenerates( std::vector<unsigned int> & indexList,
00201                           std::vector<nvmath::Vec3f> & verts );
00202
00203   void addAnnotation( nvsg::Node * nNode, FltNode * fNode );
00204
00205   TaiManager * getTaiManager() { return m_taiManager; }
00206   StackedAtlasManager * getStackedAtlasManager()
00207     { return m_stackedAtlasManager; }
00208
00209   nvsg::TextureAttributeItemHandle *
00210                 loadAtlasTexture( FltFile *, const std::string & );
00211   std::map<std::string, nvsg::TextureAttributeItemHandle*> m_atlasCache;
00212   std::map<std::string, nvsg::TextureImageHandle *> m_textureNameCache;
00213
00214   unsigned int m_numTextures;
00215   unsigned int m_numMaterials;
00216   nvsg::Group * m_topLevel;
00217
00218   bool m_rgbColorMode;
00219   bool m_buildMipmapsAtLoadTime;
00220   bool m_useStackedAtlasManager;
00221
00222   uint32 m_fileIDs;
00223
00224   TaiManager * m_taiManager;
00225   StackedAtlasManager * m_stackedAtlasManager;
00226 };
00227
00228 #endif // ! defined( DOXYGEN_IGNORE )
00229
00230 #endif /* _LOADFLT_H_ */
00231
00232
00233
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


FLTTextureAttribute.h Source File

FLTTextureAttribute.h

00001
00002 // Copyright NVIDIA Corporation 2002-2005
00003 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00004 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00005 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00006 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00007 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00008 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00009 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00010 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00011 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00012 // POSSIBILITY OF SUCH DAMAGES
00013
00014 //
00015 // FLTTextureAttribute.h
00016 //
00017 //
00018
00019 #ifndef _FLTTextureAttribute_H_
00020 #define _FLTTextureAttribute_H_
00021
00022 #if ! defined( DOXYGEN_IGNORE )
00023
00024 #include <flt.h>
00025
00026 //
00027 // Basic struct to hold additional information about the texture map.
00028 // Just detail texture stuff for now.
00029 //
00030 struct FLTTextureAttribute
00031 {
00032   uint16 detailRepeatM;
00033   uint16 detailRepeatN;
00034 };
00035
00036 #endif /* DOXYGEN_IGNORE */
00037
00038 #endif /* _FLTTextureAttribute_H_ */
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


Working with cube map textures

Introduction

A cube map texture is a collection of six square images put onto six faces of an imaginary cube. Mostly, cube map textures are used to display reflection of surroundings on objects, e.g., reflection of surrounding environment from a water bubble. The underlying idea is that, you can "capture" a 360 degree view of your surroundings by standing in one place and taking six photographs each at an orthogonal 90 degree view from the others.
This article describes different methods of how to generate cube map TextureImage from existing texture files, and how to apply the cube map TextureImage to achieve the desired effect known as 'environment mapping'.

Generation of the TextureImage representing the cube map

There are existing file formats, like Microsoft's DDS format, that can have a cube map already encoded. The ILTexLoader plug-in that comes with the NVSG SDK is capable to directly load such a file to a cube map TextureImage. This obviously is the simplest method of generating a cube map TextureImage from a file.

 RCObject_AutoPtr<TextureImageHandle>gTextureHdl(TextureImage::createFromFile("nvlobby_cube_mipmap.dds", path));
 try
{
   if(gTextureHdl.get())
   {
     ReadableObject<TextureImage> texImg(gTextureHdl.get());
     if(!texImg->isCubeMap())
     {
        // not a cube map, pop an error message and throw an exception that would destroy the readable object
        throw(0);
      }
   }
   else
   {
      // error in creating textureImage from image file, report error and reset the pointer to handle to TextureImage as
      // NULL
       printErrorMessage();
       gTextureHdl.reset(NULL);
   }
}
 catch(int)
 {
   // if get here, this means the loaded image is not a cube map. Reset the pointer to handle to TextureImage as NULL
     gTextureHdl.reset(NULL);
 }

Another method is to construct a cube map TextureImage from six different square textures, each representing a different side of the final cube map. In order to get the right mapping of the single cube sides, it is essential to add the single images to the TextureImage object in a certain order. Naming the different sides of the cube by Positive_X (right side), Negative_X (left side), Positive_Y (top side), Negative_Y (bottom side), Positive_Z (front side), and Negative_Z (back side), the images need to be added to the TextureImage in the below order.

enum {
  Positive_X = 0,
  Negative_X,
  Positive_Y,
  Negative_Y,
  Positive_Z,
  Negative_Z
};

This can be achieved by first instantiating the 'master' TextureImage from the texture representing the Positive_X side of the cube.

vector<string> files(Negative_Z+1); // size to hold six filenames
files[0] = "right.jpg";
files[1] = "left.jpg";
files[2] = "top.jpg";
files[3] = "bottom.jpg";
files[4] = "front.jpg";
files[5] = "back.jpg";

vector<string> searchPathes(".");
// add more appropriate search pathes ...
// searchPathes.push_back(...);

// instantiate the cube map TextureImage, initializing it with the Positive_X image
  RCObject_AutoPtr<TextureImageHandle> hCubeMap( TextureImage::createFromFile(files[Positive_X], searchPathes) );

After that all the remaining sides can be added as follows:

if ( hCubeMap.get() )
{
  WritableObject<TextureImage> cubeMap(hCubeMap.get());
  size_t idx = 0;   // represents the index of an image in cube map
  //you might need to take reflection on X/Y axes to get desired effect
  cubeMap->mirrorX(idx);
  for ( unsigned int i=Negative_X; i<=Negative_Z; ++i )
  {
    RCObject_AutoPtr<TextureImageHandle> hImg(TextureImage::createFromFile(files[i], searchPathes));
    if ( hImg.get() )
    {
          ReadableObject<TextureImage> img(hImg.get());
          idx = cubeMap->createImage( img->getWidth(),
                                img->getHeight(),
                                img->getDepth(),
                                img->getOverlapSize(),
                                img->getFormat(),
                                img->getType()
                                img->getPixels() );
         if(idx == 2 || idx == 3)
           cubeMap->mirrorY(idx);
         else
           cubeMap->mirrorX(idx);

   }
   else
   {
      // break the loop in case of there is problem in loading with any of the texture files
      break;
    }
  }
}

  //Check whether all six images were loaded correctly, if not, report an error

A cube map TextureImage can also be constructed from a single 2D image specifying a 'vertical cross' format. A 2D image representing a 'verical cross' format must have a with-to-height ratio of 3 by 4. Though, this requirement is not sufficient for a 2D image to really specifying a cube map!

After the TextureImage was instantiated from such an image, it is considered as a 2D TextureImage, and requires a conversion to a cube map TextureImage. This is best achieved by means of the TextureImage::convert2DToCubeMap member function.

RCObject_AutoPtr<TextureImageHandle>hCubeMap(TextureImage::createFromFile("crosscube.hdr", searchPath));
try
{
  if(hCubeMap.get())
  {
    WritableObject<TextureImage> cubeMap(hCubeMap.get());

   //check whether the image is in 'vertical cross' format two dimensional image
    if(cubeMap->is2D() && VERTICAL_CROSS_FORMAT(cubeMap->getWidth(),cubeMap->getHeight()))
    {
      cubeMap->mirrorY(0);   //  take the reflection in Y to get the desired effect
      cubeMap->convert2DToCubeMap();
      NVSG_ASSERT(cubeMap->isCubeMap());
    }
    else
    {
      // Image not convertible to cube map. Show an error message and throw an exception to get rid of write-lock
      // on TextureImage so that it can be reset to NULL in catch block
      throw(0);   //throw any integer here so that it can be caught by catch block
    }
  }
  else
  {
    // texture loading problem. Show an error message and reset the TextureImageHandle pointer to NULL
    gTextureHdl.reset(NULL);
  }
}
catch(int)
{
  //image not convertible to cube map
  gTextureHdl.reset(NULL);
}

Applying the cube map for environment mapping

To apply a texture image to a certain geometry, it needs to be assigned to either a TextureAttributeItem bound to a TextureAttribute, or to a sampler in a certain CgFx effect. This article focuses on the first method. A TextureAttributeItem represents a certain texture state. That is, it combines the texture environment, the texture parameters, and of course the TextureImage to define a particular texture state.

RCObject_AutoPtr<TextureAttributeItemHandle> hTexItem(CreateHandle(TextureAttributeItemHandle));
{
  WritableObject<TextureAttributeItem> texItem(hTexItem.get());
  texItem->setTextureImage(hCubeMap.get());
  [...]
  // avoid artefacts at the cutting edges of the cube map
  texItem->setWrapMode(TWCA_S, TWM_CLAMP);
  texItem->setWrapMode(TWCA_T, TWM_CLAMP);
  texItem->setWrapMode(TWCA_R, TWM_CLAMP);
  [...]

In order to obtain an environment mapping effect, we activate an appropriate texture coordinate generation. If a cubemap is applied to a geometry using a TextureAttribute, cube map texturing will be enabled during rendering. In this case the (s, t, r) texture coordinates are treated as a direction vector (x, y, z) emanating from the center of a cube. In order to simulate the reflected image of an 'environment' on a surface, you should enable texture coordinate generation for these coordinates with the texture coordinate generation mode set to TGM_REFLECTION_MAP.

    [...]
    texItem->setTexGenMode(nvsg::TCA_S, TGM_REFLECTION_MAP);
    texItem->setTexGenMode(nvsg::TCA_T, TGM_REFLECTION_MAP);
    texItem->setTexGenMode(nvsg::TCA_R, TGM_REFLECTION_MAP);

    [...]
  }

With NVSG, a texture state is applied to a certain geometry by means of a StateSet. A StateSet can contain a number of StateAttributes like Material, BlendAttribute, TextureAttribute, etc.. All StateAttributes but a CgFx attribute in a StateSet will be applied in the order they are added to the owning StateSet.

To apply a texture state specified by a TextureAttributeItem, the TextureAttributeItem needs to be bound to a TextureAttribute.

RCObject_AutoPtr<TextureAttributeHandle> hTexAttrib(CreateHandle(TextureAttributeHandle));
{
  // bind the item to texture unit 0
  WritableObject<TextureAttribute> texAttrib(hTexAttrib.get());
  texAttrib->bindTextureAttributeItem(hTexItem.get(), 0);
}

After the TextureAttribute has been specified as shown above, it can be assigned to a surface by means of a StateSet.

RCObject_AutoPtr<TrianglesHandle> hSurface(CreateHandle(TrianglesHandle));

// setup the surface; not shown here
[...]

// instantiate a StateSet to hold the TextureAttribute
RCObject_AutoPtr<StateSetHandle> hState(CreateHandle(StateSetHandle));
{
  WritableObject<StateSet> state(hState.get());
  state->addAttribute(hTexAttrib.get());
}

// finally define the GeoNode to assign the state to the surface
RCObject_AutoPtr<GeoNodeHandle> hGNode(CreateHandle(GeoNodeHandle));
{
  WritableObject<GeoNode> gnode(hGNode.get());
  gnode->addGeometry(hSurface.get(), hState.get());
}

Additional notes on cube map textures

Cube map textures can also be used in sky boxes. A skybox is a large cube that contains texture maps representing imagery of the environment (sky / clouds, mountains, etc) at a nearly-infinite distance away. Some applications use the same texture map in their sky box that they use as an environment map on their dynamic models. This adds coherency to the scene, as the clouds in the sky can also be seen reflected in the dynamic models.

A tutorial on sky boxes and how to use them in your software is available here: http://skymatter.thegamecreators.com/?f=tutorial. That site also contains many skybox texture maps.

To use the cube map texture in a 'sky box', texture coordinate generation mode should be set to OBJECT_LINEAR. This texture should then be applied to the faces of the sky box.

[…]
RCObject_AutoPtr<TextureAttributeItemHandle> hTexItem(CreateHandle(TextureAttributeItemHandle));
{
    WritableObject<TextureAttributeItem> texItem(hTexItem.get());
    texItem->setTextureImage(hCubeMap.get());

    nvmath::Vec4f plane[3];
    plane[0] = nvmath::Vec4f(1,0,0,0);
    plane[1] = nvmath::Vec4f(0,1,0,0);
    plane[2] = nvmath::Vec4f(0,0,1,0);

    //specify the plane to be used with linear texture-coordinate generation
    texItem->setTexGenLinearPlane(nvsg::TCA_S,nvsg::TGLP_OBJECT_AND_EYE,plane[0]);
    texItem->setTexGenLinearPlane(nvsg::TCA_T,nvsg::TGLP_OBJECT_AND_EYE,plane[1]);
    texItem->setTexGenLinearPlane(nvsg::TCA_R,nvsg::TGLP_OBJECT_AND_EYE,plane[2]);

    //set the texture coordinate generation mode
    texItem->setTexGenMode(nvsg::TCA_S, nvsg::TGM_OBJECT_LINEAR);
    texItem->setTexGenMode(nvsg::TCA_T, nvsg::TGM_OBJECT_LINEAR);
    texItem->setTexGenMode(nvsg::TCA_R, nvsg::TGM_OBJECT_LINEAR);

    // avoid the artefacts at cutting edges
    texItem->setWrapMode(nvsg::TWCA_S, nvsg::TWM_CLAMP);
    texItem->setWrapMode(nvsg::TWCA_T, nvsg::TWM_CLAMP);
    texItem->setWrapMode(nvsg::TWCA_R, nvsg::TWM_CLAMP);
Generated on Tue Jan 15 10:28:48 2008 for NVSGSDK by NVIDIA


Graphical Class Hierarchy

NVSGSDK Graphical Class Hierarchy

Go to the textual class hierarchy

Generated on Tue Jan 15 10:29:57 2008 for NVSGSDK by NVIDIA


Assert.h Source File

Assert.h

00001 #pragma once
00002
00003 #include "nvsggnudefs.h" // GNU compiler specific defines
00004 #include "nvsg/nvsgapi.h"  // storage-class defines
00005
00006 namespace nvutil
00007 {
00008   extern NVSG_API void AssertionFailed(const char* assertion, const char* file, unsigned int line, const char * function);
00009 } // namespace nvutil
00010
00011 #if !defined(NDEBUG) && !defined(NVSG_HYBRID)
00012 // assert macro
00013 #if defined(LINUX)
00014 #define NVSG_ASSERT(exp) \
00015   if (exp){ \
00016   } else { \
00017     nvutil::AssertionFailed(#exp, __FILE__, __LINE__, __func__); \
00018   }
00019 #else
00020 #include <assert.h>
00021 #define NVSG_ASSERT assert
00022 #endif
00023
00024 // verify the expression f succeeds
00025 #define NVSG_VERIFY(f) NVSG_ASSERT((f))
00026
00027 // NOTE: GNU compilers < 3.3.0 have serious problems with meta programing
00028 // techniques that we use e.g. to implement our compile-time assert
00029 #if defined(__GNUC__) && GCC_VERSION < 30300
00030
00031 #define NVSG_CTASSERT(exp)
00032 #define NVSG_CTASSERT_BYTESIZE(type,size)
00033 #define NVSG_CTASSERT_BYTESIZEi(type,size,ln)
00034 #define NVSG_CTASSERT_BYTESIZEii(type,size,ln)
00035 #define NVSG_CTASSERT_MODULO_BYTESIZE(type,size)
00036 #define NVSG_CTASSERT_MODULO_BYTESIZEi(type,size,ln)
00037 #define NVSG_CTASSERT_MODULO_BYTESIZEii(type,size,ln)
00038
00039 #else
00040
00041 // compile time assert
00042 template <bool> class CompileTimeAssert;
00043 template<> class CompileTimeAssert<true> {};
00044 #define NVSG_CTASSERT(exp) sizeof(CompileTimeAssert<(exp)!=0>)
00045
00046 #define NVSG_CTASSERT_BYTESIZE(type,size) NVSG_CTASSERT_BYTESIZEi(type,size, __LINE__)
00047 #define NVSG_CTASSERT_BYTESIZEi(type,size,ln) NVSG_CTASSERT_BYTESIZEii(type,size,ln)
00048 #define NVSG_CTASSERT_BYTESIZEii(type,size,ln) \
00049   static CompileTimeAssert<sizeof(type)==size> error_at_line_##ln##__##type##_has_unexpected_size
00050
00051 #define NVSG_CTASSERT_MODULO_BYTESIZE(type,size) NVSG_CTASSERT_MODULO_BYTESIZEi(type,size, __LINE__)
00052 #define NVSG_CTASSERT_MODULO_BYTESIZEi(type,size,ln) NVSG_CTASSERT_MODULO_BYTESIZEii(type,size,ln)
00053 #define NVSG_CTASSERT_MODULO_BYTESIZEii(type,size,ln) \
00054   static CompileTimeAssert<sizeof(type)%size==0> error_at_line_##ln##__##type##_has_unexpected_size
00055
00056 #endif
00057
00058 #else // non-debug configuration
00059
00060 #define NVSG_ASSERT(exp) static_cast<void>(0)
00061 #define NVSG_VERIFY(f)  (static_cast<void>(f))
00062 #define NVSG_CTASSERT(exp)
00063 #define NVSG_CTASSERT_BYTESIZE(type,size)
00064 #define NVSG_CTASSERT_BYTESIZEi(type,size,ln)
00065 #define NVSG_CTASSERT_BYTESIZEii(type,size,ln)
00066 #define NVSG_CTASSERT_MODULO_BYTESIZE(type,size)
00067 #define NVSG_CTASSERT_MODULO_BYTESIZEi(type,size,ln)
00068 #define NVSG_CTASSERT_MODULO_BYTESIZEii(type,size,ln)
00069 #endif
00070
00071 #if defined(NVSG_PRIVATE)
00072 # define NVSG_PRIVATE_ASSERT(exp)   NVSG_ASSERT(exp)
00073 #else
00074 # define NVSG_PRIVATE_ASSERT(exp)   static_cast<void>(0)
00075 #endif
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


BaseRenderElement.h Source File

BaseRenderElement.h

00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 namespace nvtraverser
00015 {
00020   class BaseRenderElement
00021   {
00022     public:
00029       void addRef();
00030
00035       void removeRef();
00036
00037 #if !defined(NDEBUG)
00038
00041       unsigned int getRefCnt() const;
00042 #endif
00043
00044     protected:
00050       BaseRenderElement();
00051
00058       BaseRenderElement( const BaseRenderElement & rhs );
00059
00064       virtual ~BaseRenderElement();
00065
00066     private:
00067       unsigned int m_refCnt;
00068   };
00069
00070
00071   inline BaseRenderElement::BaseRenderElement()
00072     : m_refCnt(0)
00073   {
00074   }
00075
00076   inline BaseRenderElement::BaseRenderElement( const BaseRenderElement & rhs )
00077     : m_refCnt(0)
00078   {
00079   }
00080
00081   inline BaseRenderElement::~BaseRenderElement()
00082   {
00083   }
00084
00085   inline void BaseRenderElement::addRef()
00086   {
00087     m_refCnt++;
00088   }
00089
00090   inline void BaseRenderElement::removeRef()
00091   {
00092     if ( --m_refCnt == 0 )
00093     {
00094       // note: this object was created in a pool using placement new, that is -
00095       // we must not call the delete operator here but explicitely call the destructor
00096       this->~BaseRenderElement();
00097     }
00098   }
00099
00100 #if !defined(NDEBUG)
00101   inline unsigned int BaseRenderElement::getRefCnt() const
00102   {
00103     return( m_refCnt );
00104   }
00105 #endif
00106 }
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


CallBackServer.h Source File

CallBackServer.h

00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011 #pragma once
00012 #include "nvsg/CoreTypes.h"
00013
00014 #include <map>
00015 #include <set>
00016
00017 namespace nvsg
00018 {
00019   // forward declaration
00020   class ChangeCallback;
00021
00031   class CallbackServer
00032   {
00033   public:
00036     NVSG_API CallbackServer();
00037
00040     NVSG_API ~CallbackServer();
00041
00049     NVSG_API void addCallback( ObjectHandle * subjectHandle, ChangeCallback* cb );
00050
00058     NVSG_API void removeCallback( ObjectHandle * subjectHandle, ChangeCallback* cb );
00059
00068     NVSG_API void changed( ObjectHandle * subjectHandle, const void* userData = NULL ) const;
00069
00070   private:
00071     std::map< ObjectHandle*, std::set<ChangeCallback*> > m_objectsToChangeCallbacks; // map of ObjectHandles
00072                                                                                      // to a set of their associated CallBacks
00073
00074     // convenient type defines
00075     typedef std::map< ObjectHandle*, std::set<ChangeCallback*> >::iterator I;
00076     typedef std::map< ObjectHandle*, std::set<ChangeCallback*> >::const_iterator CI;
00077   };
00078
00080   typedef nvutil::Singleton<CallbackServer> CBS;
00081 }
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


CgDecomposer.h Source File

CgDecomposer.h

00001
00002 #ifndef _CG_DECOMPOSER_H_
00003 #define _CG_DECOMPOSER_H_
00004
00005 #include <string>
00006 #include <vector>
00007
00008 class CgDecomposer
00009 {
00010 public:
00011   struct Method
00012   {
00013     std::string name;
00014     std::string retType;
00015     std::string retSemantic;
00016     std::vector< std::string > arguments;
00017     std::string body;
00018     std::string profile;
00019     int identifier;
00020   };
00021
00022   struct Struct
00023   {
00024     std::string name;
00025     std::string body;
00026     int identifier;
00027   };
00028
00029   enum
00030   {
00031     PARSE_EOF,
00032     PARSE_NOERROR
00033   };
00034
00035   // shader types
00036   enum
00037   {
00038     GENERIC  = 1,
00039     VERTEX   = 2,
00040     FRAGMENT = 3,
00041     GEOMETRY = 4
00042   };
00043
00044   CgDecomposer()
00045   {
00046   }
00047
00048   ~CgDecomposer()
00049   {
00050   }
00051
00052   // parse a Cg file and add composition
00053   bool parseFile( const std::string & file, bool & valid, int identifier );
00054   // parse a Cg buffer and add composition
00055   bool parseBuffer( const char * buffer, int identifier );
00056
00057   // helper method to decompose a string argument
00058   bool parseArg( std::string arg, std::vector<std::string> & tokens );
00059   bool parseFullArg( std::string arg, std::vector<std::string> & tokens );
00060
00061   const std::vector< Method > & getMethods() const { return m_methods; }
00062   const std::vector< Struct > & getStructs() const { return m_structs; }
00063
00064   // find, and allow to modify
00065   Method * findMethod( const std::string & name, int identifier = -1 );
00066   Struct * findStruct( const std::string & name, int identifier = -1 );
00067
00068   // add namespace profile to methods with this identifier
00069   void addProfileNamespace( int identifier, const std::string & name );
00070
00071   // rebuild and output shader
00072   bool buildShader( std::string & result, const std::string & vsEntry,
00073                                           const std::string & fsEntry );
00074
00075   // could be useful as public
00076   void addMethod( Method & method ) { m_methods.push_back( method ); }
00077   void addStruct( Struct & _struct ) { m_structs.push_back( _struct ); }
00078
00079   // eat leading white
00080   inline void chomp( std::string & str )
00081   {
00082     while( str[0] == '\t' || str[0] == ' ' )
00083     {
00084       str.erase(str.begin());
00085     }
00086   }
00087
00088   inline bool isanyof( char needle, const char * haystack )
00089   {
00090     while( *haystack )
00091     {
00092       if( needle == *haystack++ )
00093       {
00094         return true;
00095       }
00096     }
00097
00098     return false;
00099   }
00100
00101 private:
00102   //
00103   // Parse until token given, skipping comment fields.
00104   //
00105   bool parseUntil( const char * stopchars, const char * sepchars,
00106               char & stopChar,
00107               std::vector< std::string > & tokens,
00108               int & err );
00109
00110   //
00111   // Parse body {} enclosed objects.  Expects to be entered just after the
00112   // first opening '{'.
00113   //
00114   bool parseBody( std::string & body, int & err );
00115
00116   enum ParserState
00117   {
00118     STATE_OUTER,          // outside any struct/method
00119     STATE_STRUCT,         // inside struct
00120     STATE_METHOD_ARGS,  // function args
00121     STATE_METHOD_BODY,  // function body
00122   };
00123
00124   ParserState m_state;
00125   const char * m_curPos;
00126   const char * m_buffer;
00127   int             m_identifier;
00128
00129   std::vector< Method > m_methods;
00130   std::vector< Struct > m_structs;
00131 };
00132
00133 #endif /* _CG_DECOMPOSER_H_ */
Generated on Tue Jan 15 10:27:23 2008 for NVSGSDK by NVIDIA


CgFxLoader.h Source File

CgFxLoader.h

Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by   NVIDIA


Alphabetical index

NVSGSDK Class Index

A | B | C | D | E | F | G | H | I | K | L | M | N | O | P | Q | R | S | T | U | V | W

A
GLTraverser (nvtraverser) NBFFramedIndexAnimation plane_t StateVariant (nvsg)
addReference (nvutil) GLUploadTraverser (nvtraverser) NBFFramedTrafoAnimation Planent (nvmath) str_t
Allocator (nvutil) GLWinRenderArea (nvui) NBFFramedVertexAttributeAnimation PlugIn (nvutil) StrippedPrimitiveSet (nvsg)
AlphaTestAttribute (nvsg) GPUSkinningProcessor (nvtraverser) NBFGeoNode PlugInCallback (nvutil) StrippingTraverser (nvtraverser)
AnalyzeResult (nvtraverser) Group (nvsg) NBFGroup PlugInCallback::DegenerateGeometryInfo (nvutil) StrTokenizer (nvutil)
AnalyzeTraverser (nvtraverser)
H
NBFHeader PlugInCallback::EmptyTokenInfo (nvutil) Switch (nvsg)
AnimatedTransform (nvsg) Handle (nvutil) NBFIndependentPrimitiveSet PlugInCallback::FileAccessFailedInfo (nvutil) switchMask_t
AnimatedVertexAttributeSet (nvsg) Handle< T, Handle< U, V > > (nvutil) NBFIndexAnimation PlugInCallback::FileMappingFailedInfo (nvutil) SWMRSync (nvutil)
Animation (nvsg) Handle< T, NullType > (nvutil) NBFInterpolatedAnimation PlugInCallback::IncompatibleFileInfo (nvutil)
T
AnimationManipulator (nvui) HighlightBox (nvsg) NBFInterpolatedTrafoAnimation PlugInCallback::IncompatibleValueInfo (nvutil) texBinding_t
AppTraverser (nvtraverser) HighlightEdges (nvsg) NBFInterpolatedVertexAttributeAnimation PlugInCallback::InvalidFileInfo (nvutil) texCoordSet_t
B
HighlightElement (nvtraverser) NBFLightingAttribute PlugInCallback::InvalidValueInfo (nvutil) texImage_t
BalanceTraverser (nvtraverser) HighlightObject (nvsg) NBFLightSource PlugInCallback::UndefinedTokenInfo (nvutil) TextureAttribute (nvsg)
BaseRenderElement (nvtraverser)
I
NBFLineAttribute PlugInCallback::UnexpectedTokenInfo (nvutil) TextureAttributeItem (nvsg)
BellFilter (nvsg) IAllocator (nvutil) NBFLoader PlugInCallback::UnknownTokenInfo (nvutil) TextureAttributeItemData (nvsg)
Billboard (nvsg) IdentityResult (nvtraverser) NBFLOD PlugInCallback::UnsupportedTokenInfo (nvutil) TextureImage (nvsg)
Bit (nvutil) IdentityToGroupTraverser (nvtraverser) NBFMaterial PlugInServer (nvutil) TextureLoader (nvsg)
BlendAttribute (nvsg) ILTexLoader NBFMeshedPrimitiveSet PLYLoader TextureSaver (nvsg)
Bone (nvsg) ILTexSaver NBFNode PointAttribute (nvsg) Trace (nvutil)
bone_t Image (nvsg) NBFObject PointLight (nvsg) traceConsoleDebugOutput (nvutil)
BoxFilter (nvsg) Incarnation (nvutil) NBFParallelCamera Points (nvsg) traceConsoleOutput (nvutil)
Boxnt (nvmath) IndependentPrimitiveSet (nvsg) NBFPerspectiveCamera PrimitiveAttribute (nvsg) traceDebugOutput (nvutil)
BSplineFilter (nvsg) IndexMesh (nvsg) NBFPointAttribute PrimitiveSet (nvsg) traceFileConsoleOutput (nvutil)
C
indexSet_t NBFPointLight ProblemInfo (nvutil) traceFileDebugOutput (nvutil)
CallbackServer (nvsg) Intersection (nvtraverser) NBFPrimitiveSet
Q
traceFileOutput (nvutil)
Camera (nvsg)
K
NBFSaver QuadMeshes (nvsg) TraceFunctor (nvutil)
CgFx (nvsg) KeyFramedAnimation (nvsg) NBFSaveTraverser Quads (nvsg) Trackball (nvutil)
CgFxContext (nvsg) KeyInput (nvui) NBFScene QuadStrips (nvsg) TrackballCameraManipulator (nvui)
CgFxEffect (nvsg) keyVariant_t NBFSkin Quatt (nvmath) TrackballTransformManipulator (nvui)
ChangeCallback (nvsg)
L
NBFSkinnedTriangles
R
Trafo (nvmath)
Chunk (nvutil) Lanczos3Filter (nvsg) NBFSpotLight RayIntersectTraverser (nvtraverser) trafo_t
ClipPlanesElement (nvtraverser) LightingAttribute (nvsg) NBFStateAttribute RCIPtr (nvutil) Transform (nvsg)
CombinableResult (nvtraverser) LightsElement (nvtraverser) NBFStatePass RCObject (nvutil) TransformElement (nvtraverser)
CombineTraverser (nvtraverser) LightSource (nvsg) NBFStateSet RCObject_AutoPtr (nvutil) TransformManipulator (nvui)
CPUSkinningProcessor (nvtraverser) LinearInterpolatedAnimation (nvsg) NBFStateVariant RCPtr (nvutil) TransformStack (nvutil)
CullData (nvsg) LineAttribute (nvsg) NBFStrippedPrimitiveSet RCVector (nvutil) Traverser (nvtraverser)
CullTraverser (nvtraverser) Lines (nvsg) NBFSwitch ReadMapping (nvutil) TriangleFilter (nvsg)
D
LineStrips (nvsg) NBFTextureAttribute RedundantLODRangesResult (nvtraverser) Triangles (nvsg)
DALData (nvsg) LOD (nvsg) NBFTextureAttributeItem RegVal (nvutil) TriangulateTraverser (nvtraverser)
DALDataCreator (nvsg) Log (nvutil) NBFTrafoAnimation removeReference (nvutil) TriFans (nvsg)
DALHost (nvsg)
M
NBFTransform RenderArea (nvui) TriStrips (nvsg)
DenormalizedNormalsResult (nvtraverser) Manipulator (nvui) NBFUnlitColorAttribute RenderElement (nvtraverser) tweak_t
DepthAttribute (nvsg) Map (nvsg) NBFVertexAttributeAnimation RenderElementCompareBackToFront (nvtraverser) Type2EnumType (nvsg)
DestrippingTraverser (nvtraverser) MapArray (nvsg) NBFVertexAttributeSet RenderElementCompareFrontToBack (nvtraverser)
U
DirectedLight (nvsg) MapElement (nvsg) NBFViewState RenderElementCompareStateAttributes (nvtraverser) UnifyTraverser (nvtraverser)
Drawable (nvsg) MapList (nvsg) NBFVolumeNode RenderTraverser (nvtraverser) UnlitColorAttribute (nvsg)
E
MapMatrix (nvsg) Node (nvsg)
S
UPIID (nvutil)
EliminateTraverser (nvtraverser) MapObject (nvsg) NodeHintsCullTraverser (nvtraverser) sampler_t UPITID (nvutil)
EmptyResult (nvtraverser) Material (nvsg) NormalizeTraverser (nvtraverser) ScaleFilter (nvsg)
V
EquivalenceResult (nvtraverser) Matnnt (nvmath) NullNormalsResult (nvtraverser) Scene (nvsg) Validated (nvutil)
ExclusiveModelViewTraverser (nvtraverser) MemFunTbl (nvutil) NVBLoader SceneLoader (nvsg) VariantIterator (nvsg)
ExclusiveTraverser (nvtraverser) MeshedPrimitiveSet (nvsg) NVBLoadTraverser SceneSaver (nvsg) Vecnt (nvmath)
ExtractGeometryTraverser meshSet_t NVNVB SearchTraverser (nvtraverser) vertexAttrib_t
F
MissingResult (nvtraverser) NVSGException (nvsg) Shape (nvsg) VertexAttribute (nvsg)
Face (nvsg) MouseInput (nvui) NVSGLight SharedModelViewTraverser (nvtraverser) VertexAttributeSet (nvsg)
FaceAttribute (nvsg)
N
NVSGLoader SharedTraverser (nvtraverser) VertexUnifyTraverser (nvtraverser)
FileMapping (nvutil) NBFAlphaTestAttribute NVSGMaterial ShortStrippedResult (nvtraverser) ViewState (nvsg)
FixedAllocator (nvutil) NBFAnimatedTransform NVSGSaver SingleChildResult (nvtraverser) VNVector (nvsg)
FlightCameraManipulator (nvui) NBFAnimatedVertexAttributeSet NVSGSaveTraverser Singleton (nvutil) VolLoader
FlipbookAnimation (nvsg) NBFAnimation NVSGScene Skin (nvsg) VolLoader::FileInfo
FramedAnimation (nvsg) NBFBillboard NVSGTexImageFmt (nvgl) skin_t VolSaver
FrustumCullTraverser (nvtraverser) NBFBlendAttribute
O
SkinnedTriangles (nvsg) VolumeBrick (nvsg)
G
NBFCamera Object (nvsg) SkinnedTriangles::Skin (nvsg) VolumeNode (nvsg)
geometrySet_t NBFCgFx OBJSaver SmoothTraverser (nvtraverser) VolumeTexture (nvsg)
GeoNode (nvsg) NBFDepthAttribute OptimizeTraverser (nvtraverser) Spherent (nvmath)
W
GLContext (nvgl) NBFDirectedLight OwnedObject (nvsg) SpotLight (nvsg) WalkCameraManipulator (nvui)
GLFunctions (nvgl) NBFDrawable
P
sstr_t WriteMapping (nvutil)
GLMFCRAWnd (nvui) NBFFaceAttribute ParallelCamera (nvsg) StateAttribute (nvsg) WRLLoader
GLObjects (nvgl) NBFFlipbookAnimation Path (nvsg) StatePass (nvsg) WRLLoadTraverser
GLTexImageFmt (nvgl) NBFFramedAnimation PerspectiveCamera (nvsg) StateSet (nvsg)

A | B | C | D | E | F | G | H | I | K | L | M | N | O | P | Q | R | S | T | U | V | W

Generated on Tue Jan 15 10:28:34 2008 for NVSGSDK by NVIDIA


ClipPlanesElement.h Source File

ClipPlanesElement.h

00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvtraverser/BaseRenderElement.h"
00015 #include "nvtraverser/RenderElementPool.h"
00016 #include "nvutil/RCObject.h"
00017 #include "nvsg/Group.h"
00018 #include "nvmath/Matnnt.h"
00019 #include <vector>
00020
00021 namespace nvtraverser
00022 {
00027   class ClipPlanesElement : public BaseRenderElement
00028   {
00029     public:
00033       NVSG_API ClipPlanesElement();
00034
00044       NVSG_API ClipPlanesElement( nvsg::GroupHandle * group, const nvmath::Mat44f & modelToWorld
00045                                 , const ClipPlanesElement &rhs );
00046
00053       NVSG_API const nvmath::Plane3f & getClipPlane( unsigned int index ) const;
00054
00059       NVSG_API nvsg::GroupHandle * getGroup() const;
00060
00068       NVSG_API const nvmath::Mat44f & getModelToWorld( unsigned int index ) const;
00069
00075       NVSG_API unsigned int getNumberOfClipPlanes() const;
00076
00077     private:
00078       nvsg::GroupHandle            * m_group;
00079       std::vector<nvmath::Plane3f>   m_clipPlanes;
00080       std::vector<nvmath::Mat44f>    m_modelToWorld;
00081   };
00082
00083   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00084   // non-member functions
00085   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00090   inline ClipPlanesElement * createClipPlanesElement( RenderElementPool * pool )
00091   {
00092     return( constructRenderElement<ClipPlanesElement>( pool ) );
00093   }
00094
00103   inline ClipPlanesElement * createClipPlanesElement( RenderElementPool * pool
00104                                                     , nvsg::GroupHandle * group
00105                                                     , const nvmath::Mat44f & modelToWorld
00106                                                     , const ClipPlanesElement & rhs )
00107   {
00108     return( constructRenderElement<ClipPlanesElement,nvsg::GroupHandle *, const nvmath::Mat44f &
00109                                   , const ClipPlanesElement &>( pool, group, modelToWorld, rhs ) );
00110   }
00111
00112   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00113   // inlines
00114   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00115   inline ClipPlanesElement::ClipPlanesElement()
00116     : m_group(NULL)
00117   {
00118   }
00119
00120   inline ClipPlanesElement::ClipPlanesElement( nvsg::GroupHandle * group
00121                                              , const nvmath::Mat44f & modelToWorld
00122                                              , const ClipPlanesElement &rhs )
00123     : BaseRenderElement(rhs)
00124     , m_clipPlanes(rhs.m_clipPlanes)
00125     , m_modelToWorld(rhs.m_modelToWorld)
00126     , m_group(group)
00127   {
00128     NVSG_ASSERT(m_group);
00129     nvutil::ReadableObject<nvsg::Group> g(m_group);
00130     for ( unsigned int i=0 ; i<g->getNumberOfClipPlanes() ; i++ )
00131     {
00132       if ( g->isClipPlaneActive(i) )
00133       {
00134         m_clipPlanes.push_back( g->getClipPlane(i) );
00135         m_modelToWorld.push_back( modelToWorld );
00136       }
00137     }
00138   }
00139
00140   inline const nvmath::Plane3f & ClipPlanesElement::getClipPlane( unsigned int index ) const
00141   {
00142     NVSG_ASSERT( index < m_clipPlanes.size() );
00143     return( m_clipPlanes[index] );
00144   }
00145
00146   inline nvsg::GroupHandle * ClipPlanesElement::getGroup() const
00147   {
00148     return( m_group );
00149   }
00150
00151   inline const nvmath::Mat44f & ClipPlanesElement::getModelToWorld( unsigned int index ) const
00152   {
00153     NVSG_ASSERT( index < m_modelToWorld.size() );
00154     return( m_modelToWorld[index] );
00155   }
00156
00157   inline unsigned int ClipPlanesElement::getNumberOfClipPlanes() const
00158   {
00159     NVSG_ASSERT( m_clipPlanes.size() <= UINT_MAX );
00160     return( static_cast<unsigned int>(m_clipPlanes.size()) );
00161   }
00162 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


CombineTraverser.h Source File

CombineTraverser.h

00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013 #pragma warning( disable : 4503 )   // decorated name length exceeded, name was truncated
00014
00015 #include <list>
00016 #include "nvsgcommon.h"
00017 #include "nvtraverser/OptimizeTraverser.h"
00018
00019 namespace nvtraverser
00020 {
00027   class CombineTraverser : public OptimizeTraverser
00028   {
00029     public:
00030       enum
00031       {
00032         CT_GEONODE          = BIT0,
00033         CT_LOD              = BIT1,
00034         CT_LOD_RANGES       = BIT2,
00035         CT_PRIMITIVE_SET    = BIT3,
00036         CT_TRANSFORM        = BIT4,
00037         CT_ALL_TARGETS_MASK = ( CT_GEONODE | CT_LOD | CT_LOD_RANGES | CT_PRIMITIVE_SET | CT_TRANSFORM )
00038       } CombineTarget;
00039
00040     public:
00042       NVSG_API CombineTraverser( void );
00043
00046       NVSG_API unsigned int getCombineTargets() const;
00047
00050       NVSG_API void setCombineTargets( unsigned int mask );
00051
00052     protected:
00054       NVSG_API virtual ~CombineTraverser( void );
00055
00057       NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransform *p );
00058
00060       NVSG_API virtual void handleBillboard( nvsg::Billboard * p );
00061
00063       NVSG_API virtual void handleGeoNode( nvsg::GeoNode * p );
00064
00066       NVSG_API virtual void handleGroup( nvsg::Group * p );
00067
00069       NVSG_API virtual void handleLines( nvsg::Lines * p );
00070
00072       NVSG_API virtual void handleLineStrips( nvsg::LineStrips * p );
00073
00075       NVSG_API virtual void handleLOD( nvsg::LOD * p );
00076
00078       NVSG_API virtual void handlePoints( nvsg::Points * p );
00079
00081       NVSG_API virtual void handleQuadMeshes( nvsg::QuadMeshes * p );
00082
00084       NVSG_API virtual void handleQuads( nvsg::Quads * p );
00085
00087       NVSG_API virtual void handleQuadStrips( nvsg::QuadStrips * p );
00088
00090       NVSG_API virtual void handleTransform( nvsg::Transform * p );
00091
00093       NVSG_API virtual void handleTriangles( nvsg::Triangles * p );
00094
00096       NVSG_API virtual void handleTriFans( nvsg::TriFans * p );
00097
00099       NVSG_API virtual void handleTriStrips( nvsg::TriStrips * p );
00100
00102       NVSG_API virtual bool preTraverseDrawables(const nvsg::GeoNode* gnode, unsigned int geomIndex);
00103
00104
00105     private:
00106       void combineGeoNodes( nvsg::Group *p );
00107       void combineLODs( nvsg::Group *p );
00108       void combineLODRanges( nvsg::LOD *p );
00109       void combineTransforms( nvsg::Group *p );
00110
00111       // for PrimitiveSet combining:
00112       void combine( nvsg::PrimitiveSet *p0, const nvsg::PrimitiveSet *p1 );
00113       void combine( nvsg::IndependentPrimitiveSetHandle *p0, nvsg::IndependentPrimitiveSetHandle *p1 );
00114       void combine( nvsg::MeshedPrimitiveSetHandle *p0, nvsg::MeshedPrimitiveSetHandle *p1 );
00115       void combine( nvsg::StrippedPrimitiveSetHandle *p0, nvsg::StrippedPrimitiveSetHandle *p1 );
00116       void combine( nvsg::VertexAttributeSetHandle * vash0, nvsg::VertexAttributeSetHandle * vash1 );
00117       void combine( nvsg::AnimatedVertexAttributeSetHandle * avash0, nvsg::AnimatedVertexAttributeSetHandle * avash1 );
00118       void combine( nvsg::FramedVertexAttributeAnimationHandle * fvaah0, nvsg::FramedVertexAttributeAnimationHandle * fvaah1 );
00119       void combine( nvsg::LinearInterpolatedVertexAttributeAnimationHandle * livaah0, nvsg::LinearInterpolatedVertexAttributeAnimationHandle * livaah1 );
00120       void combine( nvsg::SkinHandle * sh0, nvsg::SkinHandle * sh1 );
00121       template<typename TH>
00122       void combineDrawables( nvsg::GeoNode *p, std::map<nvsg::StateSetHandle*,std::vector<std::vector<TH*> > > &mvvT );
00123       void reduceVertexAttributeSet( nvsg::IndependentPrimitiveSetHandle * p );
00124       void reduceVertexAttributeSet( nvsg::MeshedPrimitiveSetHandle * p );
00125       void reduceVertexAttributeSet( nvsg::StrippedPrimitiveSetHandle * p );
00126       nvsg::VertexAttributeSetHandle * reduceVertexAttributeSet( const nvsg::VertexAttributeSet *p, std::map<unsigned int, unsigned int> &indexMap );
00127       template<typename TH>
00128       void storeDrawable( TH *p, std::map<nvsg::StateSetHandle *, std::vector<std::vector<TH*> > > &mvvT );
00129       nvsg::IndependentPrimitiveSetHandle * simpleCombine( nvsg::IndependentPrimitiveSetHandle * p0
00130                                                          , nvsg::IndependentPrimitiveSetHandle * p1 );
00131       nvsg::MeshedPrimitiveSetHandle * simpleCombine( nvsg::MeshedPrimitiveSetHandle * p0
00132                                                     , nvsg::MeshedPrimitiveSetHandle * p1 );
00133       nvsg::StrippedPrimitiveSetHandle * simpleCombine( nvsg::StrippedPrimitiveSetHandle * p0
00134                                                       , nvsg::StrippedPrimitiveSetHandle * p1 );
00135
00136     private:
00137       unsigned int m_combineTargets;
00138
00139       // for PrimitiveSet combining
00140       nvsg::StateSetHandle                                                                    * m_currentStateSet;
00141       //  For each primitive type, hold a map from the current StateSet to a vector of vector of primitives.
00142       //  The Primitives in the second level vector are compatible to each of them.
00143       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::LinesHandle *> > >         m_lines;
00144       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::LineStripsHandle *> > >    m_lineStrips;
00145       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::PointsHandle *> > >        m_points;
00146       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::QuadMeshesHandle *> > >    m_quadMeshes;
00147       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::QuadsHandle *> > >         m_quads;
00148       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::QuadStripsHandle *> > >    m_quadStrips;
00149       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::TrianglesHandle *> > >     m_triangles;
00150       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::TriFansHandle *> > >       m_triFans;
00151       std::map<nvsg::StateSetHandle *, std::vector<std::vector<nvsg::TriStripsHandle *> > >     m_triStrips;
00152   };
00153
00154   inline unsigned int CombineTraverser::getCombineTargets() const
00155   {
00156     return( m_combineTargets );
00157   }
00158
00159   inline void CombineTraverser::setCombineTargets( unsigned int mask )
00160   {
00161     m_combineTargets = mask;
00162   }
00163 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


Conditioners.h Source File

Conditioners.h

00001
00002 #ifndef _CONDITIONERS_H_
00003 #define _CONDITIONERS_H_
00004
00005 class DAE;
00006
00007 extern bool RunConditioners(DAE *dae);
00008
00009 #endif /* _CONDITIONERS_H_ */
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


Console.h Source File

Console.h

00001
00002 #ifndef _CONSOLE_H_
00003 #define _CONSOLE_H_
00004
00005 #define NO_DEBUG_LOG
00006
00007 #if (!defined(NO_DEBUG_LOG)) && ( defined( WIN32 ) || defined ( _WIN32 ) )
00008
00009 #include <windows.h>
00010 #include <string.h>
00011 #include <stdio.h>
00012 #include <stdarg.h>
00013 #include <ctype.h>
00014
00015 inline void LogMsg(const char *format, ...)
00016 {
00017   char  buf[4096], *p = buf;
00018   va_list args;
00019
00020   va_start(args, format);
00021   p += _vsnprintf(p, sizeof buf - 1, format, args);
00022   va_end(args);
00023
00024 //  while ( p > buf  &&  isspace(p[-1]) )
00025 //    *--p = '\0';
00026
00027   *p++ = '\r';
00028   *p++ = '\n';
00029   *p   = '\0';
00030
00031   OutputDebugString(buf);
00032 }
00033
00034 #else // ! WIN32
00035
00036 #define LogMsg
00037
00038 #endif
00039
00040
00041 #endif // _CONSOLE_H_
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


Conversion.h Source File

Conversion.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 namespace nvutil
00015 {
00016
00017 template<typename T, typename U>
00018 class Conversion
00019 {
00020   typedef char Small;
00021   class Big { char dummy[2]; };
00022   static Small test(U);
00023   static Big test(...);
00024   static T makeT();
00025 public:
00026   enum { exists = sizeof(test(makeT()))==sizeof(Small),
00027          sameType = 0 };
00028 };
00029
00030 template<typename T>
00031 class Conversion<T, T>
00032 {
00033 public:
00034   enum { exists = 1,
00035          sameType = 1 };
00036 };
00037
00038 #define SUPERSUBCLASS(T,U) \
00039   nvutil::Conversion<const U*, const T*>::exists && \
00040   !nvutil::Conversion<const T*, const void*>::sameType
00041
00042 } // nvutil
00043
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


CoreTypes.h Source File

CoreTypes.h

00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvutil/Handle.h" // Handle<T> definition
00015
00016 // required declaration
00017 namespace nvmath
00018 {
00019   class Trafo;
00020 }
00021
00022 namespace nvsg
00023 {
00024 // Object types
00025 class Object;
00026   // cameras ...
00027   class Camera;
00028     class ParallelCamera;
00029     class PerspectiveCamera;
00030   // nodes ...
00031   class Node;
00032     // ... groups
00033     class Group;
00034       class Billboard;
00035       class FlipbookAnimation;
00036       class LOD;
00037       class Transform;
00038         class AnimatedTransform;
00039       class Switch;
00040     // ... lights
00041     class LightSource;
00042       class DirectedLight;
00043       class PointLight;
00044       class SpotLight;
00045     // ... geometry
00046     class GeoNode;
00047     // ... volume
00048     class VolumeNode;
00049   class VolumeBrick;
00050
00051   // drawables
00052   class Drawable;
00053     // ... primitive sets
00054     class PrimitiveSet;
00055       // ... independent
00056       class IndependentPrimitiveSet;
00057         class Quads;
00058         class Triangles;
00059           class SkinnedTriangles;
00060         class Lines;
00061         class Points;
00062       // ... meshed
00063       class MeshedPrimitiveSet;
00064         class QuadMeshes;
00065       // ... stripped
00066       class StrippedPrimitiveSet;
00067         class QuadStrips;
00068         class TriFans;
00069         class TriStrips;
00070         class LineStrips;
00071     // ... shapes
00072     class Shape;
00073
00074   // vertex attributes
00075   class Skin;
00076   class VertexAttributeSet;
00077     class AnimatedVertexAttributeSet;
00078
00079   // states
00080   class StateAttribute;
00081     class AlphaTestAttribute;
00082     class BlendAttribute;
00083     class CgFx;
00084     class CgFxEffect;
00085     class DepthAttribute;
00086     class Material;
00087     class LightingAttribute;
00088     class PrimitiveAttribute;
00089       class FaceAttribute;
00090       class LineAttribute;
00091       class PointAttribute;
00092     class TextureAttribute;
00093     class TextureAttributeItem;
00094     class UnlitColorAttribute;
00095   class StateSet;
00096   class StateVariant;
00097   class StatePass;
00098
00099   // animations
00100   class AnimationBase;
00101   template<typename T> class Animation;
00102     template<typename T> class FramedAnimation;
00103     template<typename T> class KeyFramedAnimation;
00104       template<typename T> class LinearInterpolatedAnimation;
00105
00106   // highlight objects
00107   class HighlightObject;
00108     class HighlightBox;
00109     class HighlightEdges;
00110
00111   // maps
00112   class Map;
00113     class Bitmap;
00114   class MapObject;
00115     class MapArray;
00116     class MapElement;
00117     class MapMatrix;
00118   class MapList;
00119
00120
00121
00122 // additionally required declarations
00123 class DALHost;
00124 class CullData;
00125 typedef std::vector<unsigned int> IndexSet;
00126 class IndexMesh;
00127 class Scene;
00128 class TextureImage;
00129 class ViewState;
00130 class VolumeTexture;
00131 class VertexAttribute;
00132
00133 // Handle types
00134 typedef nvutil::Handle<Object> ObjectHandle;
00135 typedef nvutil::Handle<Camera, ObjectHandle> CameraHandle;
00136 typedef nvutil::Handle<ParallelCamera, CameraHandle> ParallelCameraHandle;
00137 typedef nvutil::Handle<PerspectiveCamera, CameraHandle> PerspectiveCameraHandle;
00138 typedef nvutil::Handle<Node,ObjectHandle> NodeHandle;
00139 typedef nvutil::Handle<Group,NodeHandle> GroupHandle;
00140 typedef nvutil::Handle<Billboard,GroupHandle> BillboardHandle;
00141 typedef nvutil::Handle<FlipbookAnimation,GroupHandle> FlipbookAnimationHandle;
00142 typedef nvutil::Handle<LOD,GroupHandle> LODHandle;
00143 typedef nvutil::Handle<Transform,GroupHandle> TransformHandle;
00144 typedef nvutil::Handle<AnimatedTransform,TransformHandle> AnimatedTransformHandle;
00145 typedef nvutil::Handle<Switch,GroupHandle> SwitchHandle;
00146 typedef nvutil::Handle<LightSource,ObjectHandle> LightSourceHandle;
00147 typedef nvutil::Handle<DirectedLight,LightSourceHandle> DirectedLightHandle;
00148 typedef nvutil::Handle<PointLight,LightSourceHandle> PointLightHandle;
00149 typedef nvutil::Handle<SpotLight,LightSourceHandle> SpotLightHandle;
00150 typedef nvutil::Handle<GeoNode,NodeHandle> GeoNodeHandle;
00151 typedef nvutil::Handle<Drawable,ObjectHandle> DrawableHandle;
00152 typedef nvutil::Handle<PrimitiveSet,DrawableHandle> PrimitiveSetHandle;
00153 typedef nvutil::Handle<IndependentPrimitiveSet,PrimitiveSetHandle> IndependentPrimitiveSetHandle;
00154 typedef nvutil::Handle<Quads,IndependentPrimitiveSetHandle> QuadsHandle;
00155 typedef nvutil::Handle<Triangles,IndependentPrimitiveSetHandle> TrianglesHandle;
00156 typedef nvutil::Handle<SkinnedTriangles,TrianglesHandle> SkinnedTrianglesHandle;
00157 typedef nvutil::Handle<Lines,IndependentPrimitiveSetHandle> LinesHandle;
00158 typedef nvutil::Handle<Points,IndependentPrimitiveSetHandle> PointsHandle;
00159 typedef nvutil::Handle<MeshedPrimitiveSet,PrimitiveSetHandle> MeshedPrimitiveSetHandle;
00160 typedef nvutil::Handle<QuadMeshes,MeshedPrimitiveSetHandle> QuadMeshesHandle;
00161 typedef nvutil::Handle<StrippedPrimitiveSet,PrimitiveSetHandle> StrippedPrimitiveSetHandle;
00162 typedef nvutil::Handle<QuadStrips,StrippedPrimitiveSetHandle> QuadStripsHandle;
00163 typedef nvutil::Handle<TriFans,StrippedPrimitiveSetHandle> TriFansHandle;
00164 typedef nvutil::Handle<TriStrips,StrippedPrimitiveSetHandle> TriStripsHandle;
00165 typedef nvutil::Handle<LineStrips,StrippedPrimitiveSetHandle> LineStripsHandle;
00166 typedef nvutil::Handle<Shape,DrawableHandle> ShapeHandle;
00167 typedef nvutil::Handle<VertexAttributeSet,ObjectHandle> VertexAttributeSetHandle;
00168 typedef nvutil::Handle<AnimatedVertexAttributeSet,VertexAttributeSetHandle> AnimatedVertexAttributeSetHandle;
00169 typedef nvutil::Handle<Skin,ObjectHandle> SkinHandle;
00170 typedef nvutil::Handle<StateAttribute,ObjectHandle> StateAttributeHandle;
00171 typedef nvutil::Handle<CgFx,StateAttributeHandle> CgFxHandle;
00172 typedef nvutil::Handle<CgFxEffect> CgFxEffectHandle;
00173 typedef nvutil::Handle<Material,StateAttributeHandle> MaterialHandle;
00174 typedef nvutil::Handle<TextureAttribute,StateAttributeHandle> TextureAttributeHandle;
00175 typedef nvutil::Handle<TextureAttributeItem,ObjectHandle> TextureAttributeItemHandle;
00176 typedef nvutil::Handle<BlendAttribute,StateAttributeHandle> BlendAttributeHandle;
00177 typedef nvutil::Handle<AlphaTestAttribute,StateAttributeHandle> AlphaTestAttributeHandle;
00178 typedef nvutil::Handle<DepthAttribute,StateAttributeHandle> DepthAttributeHandle;
00179 typedef nvutil::Handle<UnlitColorAttribute,StateAttributeHandle> UnlitColorAttributeHandle;
00180 typedef nvutil::Handle<PrimitiveAttribute,StateAttributeHandle> PrimitiveAttributeHandle;
00181 typedef nvutil::Handle<FaceAttribute,PrimitiveAttributeHandle> FaceAttributeHandle;
00182 typedef nvutil::Handle<LightingAttribute,StateAttributeHandle> LightingAttributeHandle;
00183 typedef nvutil::Handle<LineAttribute,PrimitiveAttributeHandle> LineAttributeHandle;
00184 typedef nvutil::Handle<PointAttribute,PrimitiveAttributeHandle> PointAttributeHandle;
00185 typedef nvutil::Handle<StateSet,ObjectHandle> StateSetHandle;
00186 typedef nvutil::Handle<StateVariant,ObjectHandle> StateVariantHandle;
00187 typedef nvutil::Handle<StatePass,ObjectHandle> StatePassHandle;
00188 typedef nvutil::Handle<AnimationBase,ObjectHandle> AnimationBaseHandle;
00189 typedef nvutil::Handle<Animation<VertexAttribute>, AnimationBaseHandle> VertexAttributeAnimationHandle;
00190 typedef nvutil::Handle<FramedAnimation<VertexAttribute>, VertexAttributeAnimationHandle> FramedVertexAttributeAnimationHandle;
00191 typedef nvutil::Handle<KeyFramedAnimation<VertexAttribute>, VertexAttributeAnimationHandle> KeyFramedVertexAttributeAnimationHandle;
00192 typedef nvutil::Handle<LinearInterpolatedAnimation<VertexAttribute>, KeyFramedVertexAttributeAnimationHandle> LinearInterpolatedVertexAttributeAnimationHandle;
00193 typedef nvutil::Handle<Animation<nvmath::Trafo>, AnimationBaseHandle> TrafoAnimationHandle;
00194 typedef nvutil::Handle<FramedAnimation<nvmath::Trafo>, TrafoAnimationHandle> FramedTrafoAnimationHandle;
00195 typedef nvutil::Handle<KeyFramedAnimation<nvmath::Trafo>, TrafoAnimationHandle> KeyFramedTrafoAnimationHandle;
00196 typedef nvutil::Handle<LinearInterpolatedAnimation<nvmath::Trafo>, KeyFramedTrafoAnimationHandle> LinearInterpolatedTrafoAnimationHandle;
00197 typedef nvutil::Handle<Animation<unsigned int>, AnimationBaseHandle> IndexAnimationHandle;
00198 typedef nvutil::Handle<FramedAnimation<unsigned int>, IndexAnimationHandle> FramedIndexAnimationHandle;
00199 typedef nvutil::Handle<HighlightObject, ObjectHandle> HighlightObjectHandle;
00200 typedef nvutil::Handle<HighlightBox, HighlightObjectHandle> HighlightBoxHandle;
00201 typedef nvutil::Handle<HighlightEdges, HighlightObjectHandle> HighlightEdgesHandle;
00202 typedef nvutil::Handle<MapObject, ObjectHandle> MapObjectHandle;
00203 typedef nvutil::Handle<MapArray, MapObjectHandle> MapArrayHandle;
00204 typedef nvutil::Handle<MapElement, MapObjectHandle> MapElementHandle;
00205 typedef nvutil::Handle<MapMatrix, MapObjectHandle> MapMatrixHandle;
00206 typedef nvutil::Handle<MapList, ObjectHandle> MapListHandle;
00207 typedef nvutil::Handle<TextureImage> TextureImageHandle;
00208 typedef nvutil::Handle<VolumeTexture,TextureImageHandle> VolumeTextureHandle;
00209 typedef nvutil::Handle<Scene> SceneHandle;
00210 typedef nvutil::Handle<ViewState> ViewStateHandle;
00211 typedef nvutil::Handle<VolumeNode,NodeHandle> VolumeNodeHandle;
00212 typedef nvutil::Handle<VolumeBrick,ObjectHandle> VolumeBrickHandle;
00213 typedef nvutil::Handle<DALHost> DALHostHandle;
00214 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


CubeMapViewer.h Source File

CubeMapViewer.h

00001 #pragma once
00002
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


DAELoader.h Source File

DAELoader.h

00001
00002 // Copyright NVIDIA Corporation 2002-2005
00003 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00004 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00005 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00006 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00007 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00008 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00009 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00010 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00011 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00012 // POSSIBILITY OF SUCH DAMAGES
00013
00014 //
00015 // DAELoader.h
00016 //
00017
00018 #ifndef _LOADDAE_H_
00019 #define _LOADDAE_H_
00020
00021 #if ! defined( DOXYGEN_IGNORE )
00022
00023 #include <stdarg.h>
00024 #include <string>
00025 #include <vector>
00026 #include <list>
00027 #include <map>
00028
00029 #include <nvmath/Matnnt.h>
00030 #include <nvsg/nvsgapi.h>
00031 #include <nvsg/nvsg.h>
00032 #include <nvsg/Scene.h>
00033 #include <nvsg/PlugInterface.h>
00034 #include <nvsg/Skin.h>
00035 #include <nvsg/VertexAttributeSet.h>
00036 #include <nvutil/Trace.h>
00037 #include <nvutil/Handle.h>
00038 #include "ErrorHandler.h"
00039 #include "ShaderBuilder.h"
00040
00041 #include "dom/domCOLLADA.h"
00042 #include "dom/domElements.h"
00043
00044 namespace nvsg
00045 {
00046   class SceneLoader;
00047   class Scene;
00048   class ViewState;
00049   class Group;
00050   class Transform;
00051   class AnimatedTransform;
00052   class GeoNode;
00053   class Drawable;
00054   class Material;
00055   class StateAttribute;
00056   class StateSet;
00057   class LightSource;
00058   class CgFx;
00059   class TextureImage;
00060 }
00061
00062 class DAE;
00063 class domAsset;
00064 class domPolylist;
00065 class domTriangles;
00066 class domVisual_scene;
00067 class domInstance_geometry;
00068 class domInstance_controller;
00069 class domSkin;
00070 class domGeometry;
00071 class domSource;
00072 class domNode;
00073 class domBind_material;
00074 class domMaterial;
00075 class domEffect;
00076 class domProfile_COMMON;
00077 class domCommon_color_or_texture_type;
00078 class domCommon_float_or_param_type;
00079 class domCommon_color_or_texture_type_complexType;
00080 class domCommon_transparent_type;
00081 class domLight;
00082 class domCamera;
00083 class daeElement;
00084
00085 class cfxMaterial;
00086 class cfxEffect;
00087
00088 #define INVOKE_CALLBACK(cb) if( callback() ) callback()->cb
00089 #define safeNodeName( n ) ( (n)->getName()?(n)->getName():(n)->getID()?(n)->getID():"unnamed" )
00090 #define safeStringValue( n ) ( (n)?(n):"" )
00091
00092 #define NVMAX_ATTRIBUTES nvsg::VertexAttributeSet::NVSG_VERTEX_ATTRIB_COUNT
00093
00094 class ShaderState
00095 {
00096 public:
00097   ShaderState() {
00098                  lightingType = CONSTANT;
00099                  fragmentLighting = false;
00100                  componentMask=0;
00101                 }
00102   ~ShaderState() {}
00103   std::string effectName;
00104   LightingType lightingType;
00105   bool fragmentLighting;
00106   int componentMask;
00107   std::vector< Component > components;
00108 };
00109
00110 class AnimationData
00111 {
00112 public:
00113
00114   // data type for animations
00115   enum ADataType
00116   {
00117     DTYPE_FLOAT,
00118     DTYPE_INT,
00119     DTYPE_NAME,
00120     DTYPE_BOOL,
00121     DTYPE_IDREF
00122   };
00123
00124   enum AnimationSemantic
00125   {
00126     ANIM_SEMANTIC_IN_TANGENT,
00127     ANIM_SEMANTIC_OUT_TANGENT,
00128     ANIM_SEMANTIC_INTERPOLATION,
00129     ANIM_SEMANTIC_INPUT,
00130     ANIM_SEMANTIC_OUTPUT
00131   };
00132
00133   enum AnimationInterpolator
00134   {
00135     ANIM_INTERP_LINEAR,
00136     ANIM_INTERP_BEZIER,
00137     ANIM_INTERP_CARDINAL,
00138     ANIM_INTERP_HERMITE,
00139     ANIM_INTERP_BSPLINE,
00140     ANIM_INTERP_STEP
00141   };
00142
00143   struct AnimInfo
00144   {
00145     ADataType type;
00146     unsigned int stride;
00147     AnimationSemantic semantic;
00148     void * data;
00149
00150     // returns everything as float
00151     unsigned int getCount();
00152     float getValue( unsigned int offset );
00153   };
00154
00155   AnimationData() {}
00156   ~AnimationData() {}
00157   void setType( const std::string & type ) { m_type = type; }
00158   std::string & getType() { return m_type; }
00159
00160   bool getAnimInfo( AnimationSemantic semantic, AnimInfo & info )
00161   {
00162     std::map< AnimationSemantic, AnimInfo >::iterator iter =
00163                                                 m_info.find( semantic );
00164
00165     if( iter == m_info.end() )
00166     {
00167       return false;
00168     }
00169
00170     info = (*iter).second;
00171     return true;
00172   }
00173
00174   void addAnimInfo( AnimInfo & info )
00175   {
00176     m_info[ info.semantic ] = info;
00177   }
00178
00179   void setInterpolator( AnimationInterpolator ai )
00180   {
00181     m_interpolator = ai;
00182   }
00183
00184   AnimationInterpolator getInterpolator( void )
00185   {
00186     return m_interpolator;
00187   }
00188
00189   void setElement( std::string & element ) { m_element = element; }
00190   std::string & getElement() { return m_element; }
00191
00192 private:
00193   std::string m_type;
00194   std::string m_element;
00195   std::map< AnimationSemantic, AnimInfo > m_info;
00196   AnimationInterpolator m_interpolator;
00197 };
00198
00199 class DAELoader : public nvsg::SceneLoader
00200 {
00201 public:
00202   DAELoader();
00203
00204   void deleteThis( void );
00205
00206   nvsg::SceneHandle * load( const std::string& filename,
00207                             const std::vector<std::string> &searchPaths,
00208                             nvsg::ViewStateHandle *& viewState );
00209
00210   // these simply use the error handler
00211   void warn( const char * format, ... )
00212   {
00213     char buffer[16384];
00214     va_list valist;
00215
00216     va_start( valist, format );
00217     vsnprintf( buffer, 16384, format, valist );
00218     va_end( valist );
00219
00220     if( m_errorHandler )
00221     {
00222       m_errorHandler->handleWarning( buffer );
00223     }
00224   }
00225
00226   void error( const char * format, ... )
00227   {
00228     char buffer[16384];
00229     va_list valist;
00230
00231     va_start( valist, format );
00232     vsnprintf( buffer, 16384, format, valist );
00233     va_end( valist );
00234
00235     if( m_errorHandler )
00236     {
00237       m_errorHandler->handleError( buffer );
00238     }
00239   }
00240
00241 protected:
00242
00243   // hierarchy
00244   unsigned int getSourceDataInfo( domSource * source, unsigned int guess,
00245             std::vector< std::pair< std::string, std::string > > & data );
00246
00247   // animations
00248   bool buildAnimationLibrary( void );
00249
00250   // materials
00251   nvsg::StateSetHandle * buildMaterial(domBind_material *, const std::string& );
00252   nvsg::StateSetHandle * buildMaterial(domMaterial *);
00253   bool parseMaterial( domMaterial *mat, ShaderState & );
00254   bool parseEffect( domEffect *effect, ShaderState & );
00255   bool parseProfileCOMMON( domProfile_COMMON *pc, ShaderState & );
00256   bool processColorOrTextureType( domCommon_color_or_texture_type *cot,
00257                                         int channel,
00258                                         domCommon_float_or_param_type *fop,
00259                                         Component & );
00260   bool processTexture( domCommon_color_or_texture_type_complexType *,
00261                         Component & );
00262
00263   nvsg::TextureAttributeItemHandle *
00264                     processTransparentType( domCommon_transparent_type *ctt );
00265
00266   // elements
00267   nvsg::LightSourceHandle * parseLight( domLight *dlight,
00268                                         nvmath::Vec3f * position,
00269                                         nvmath::Vec3f * direction );
00270   nvsg::CameraHandle * parseCamera( domCamera *dc );
00271
00272   virtual ~DAELoader(void);
00273
00274   // shaders
00275   nvsg::CgFxHandle * createCgFxFromFile( const std::string & file,
00276                                    std::vector< std::string > & searchPaths,
00277                                    std::string & errorReturn,
00278                                    bool & failOnTextureLoadInOut );
00279
00280   nvsg::CgFxHandle * createCgFxFromLump( const std::string & lump,
00281                                    std::vector< std::string > & searchPaths,
00282                                    std::string & errorReturn,
00283                                    bool & failOnTextureLoadInOut );
00284   nvsg::TextureImageHandle * lookupTexture( const std::string & file,
00285                                      std::vector< std::string > & searchPaths );
00286
00287   //
00288   // current workarounds:
00289   //
00290   void setWorkaroundMode( const std::string & mode );
00291   bool getWorkaround( const std::string & e, std::string * result = 0 );
00292   void addWorkaround( const std::string & key, const std::string & value )
00293   {
00294     warn("DAE Workaround: '%s' = '%s'\n", key.c_str(), value.c_str() );
00295     m_workarounds[ key ] = value;
00296   }
00297
00298   bool loadFX( void );
00299   bool buildFXMaterial( const std::string & sid, std::string & output );
00300
00301   AnimationData * getAnimation( daeElement * el )
00302   {
00303     std::map< daeElement *, AnimationData * >::iterator aiter =
00304                                                     m_animations.find( el );
00305     if( aiter == m_animations.end() )
00306     {
00307       return 0;
00308     }
00309     else
00310     {
00311       return (*aiter).second;
00312     }
00313   }
00314
00315   void addAnimation( daeElement * el, AnimationData * data )
00316   {
00317     m_animations[ el ] = data;
00318   }
00319
00320   private:
00321     //void                buildLibraryAnimations( domLibrary_animations_Array & animations );
00322     //void                buildLibraryAnimationsClip( domLibrary_animation_clips_Array & animations );
00323     //void                buildLibraryCameras( domLibrary_cameras_Array & animations );
00324     //void                buildLibraryControllers( domLibrary_controllers_Array & animations );
00325     //void                buildLibraryEffects( domLibrary_effects_Array & animations );
00326     //void                buildLibraryForceFields( domLibrary_force_fields_Array & animations );
00327     //void                buildLibraryGeometries( domLibrary_geometries_Array & animations );
00328     //void                buildLibraryImages( domLibrary_images_Array & animations );
00329     //void                buildLibraryLights( domLibrary_lights_Array & animations );
00330     //void                buildLibraryMaterials( domLibrary_materials_Array & animations );
00331     //void                buildLibraryNodes( domLibrary_nodes_Array & animations );
00332     //void                buildLibraryPhysicsMaterials( domLibrary_physics_materials_Array & animations );
00333     //void                buildLibraryPhysicsModels( domLibrary_physics_models_Array & animations );
00334     //void                buildLibraryPhysicsScenes( domLibrary_physics_scenes_Array & animations );
00335     //void                buildLibraryVisualScenes( domLibrary_visual_scenes_Array & animations );
00336     void                getSkinningInformation( domTriangles_Array & triangles
00337                                               , const std::vector<nvsg::PrimitiveSetHandle*> & primitiveSets
00338                                               , std::vector<std::vector<unsigned int> > & nvsgToDAEVertexIndices
00339                                               , std::vector<std::vector<nvsg::Skin::SkinningType> > & skinningTypes );
00340     void                interpretBindShapeMatrix( domSkin::domBind_shape_matrix * bindShapeMatrix
00341                                                 , nvsg::SkinHandle * skin );
00342     nvsg::SceneHandle * interpretCOLLADA( domCOLLADA * collada );
00343     void                interpretCOLLADAAsset( domAsset * asset );
00344     //void                interpretCOLLADAExtras( domExtra_Array & extras );
00345     nvsg::GeoNodeHandle * interpretController( domController * controller
00346                                              , domBind_material * bindMaterial
00347                                              , unsigned int & numberOfJoints
00348                                              , std::vector<domNode*> & skeletonNodes );
00349     //void                interpretControllerAsset( domAsset * asset );
00350     //void                interpretControllerExtras( domExtra_Array & extras );
00351     //void                interpretConvexMesh( domConvex_mesh * convexMesh );
00352     //void                interpretEvaluateScenes( domEvaluate_scene_Array & evaluateScenes );
00353     void                  interpretGeometry( domGeometry * geometry
00354                                            , domBind_material * bindMaterial
00355                                            , std::vector<nvsg::PrimitiveSetHandle*> & primitiveSets
00356                                            , std::vector<nvsg::StateSetHandle*> & stateSets );
00357     //void                interpretGeometryAsset( domAsset * asset );
00358     //void                interpretGeometryExtras( domExtra_Array & extras );
00359     //void                interpretInstanceControllerExtras( domExtra_Array & extras );
00360     //void                interpretInstanceGeometryExtras( domExtra_Array & extras );
00361     void                interpretJoints( domSkin::domJoints * joints, nvsg::SkinHandle * skin
00362                                        , std::vector<domNode*> & skeletonNodes );
00363     //void                interpretJointsExtras( domExtra_Array & extras );
00364     void                interpretJointsInputs( domInputLocal_Array & inputs
00365                                              , nvsg::SkinHandle * skin
00366                                              , std::vector<domNode*> & skeletonNodes );
00367     void                interpretLinestrips( domLinestrips_Array & lines );
00368     void                interpretLines( domLines_Array & lines
00369                                       , domBind_material * bindMaterial
00370                                       , std::vector<nvsg::PrimitiveSetHandle*> & primitiveSets
00371                                       , std::vector<nvsg::StateSetHandle*> & stateSets );
00372     nvsg::StateSetHandle * interpretMaterial( domBind_material * bindMaterial
00373                                             , daeElement * triangles
00374                                             , xsNCName materialName );
00375     void                  interpretMesh( domMesh * mesh
00376                                        , domBind_material * bindMaterial
00377                                        , std::vector<nvsg::PrimitiveSetHandle*> & primitiveSets
00378                                        , std::vector<nvsg::StateSetHandle*> & stateSets );
00379     //void                interpretMeshExtras( domExtra_Array & extras );
00380     //void                interpretMeshSources( domSource_Array & sources );
00381     //void                interpretMorph( domMorph * morph );
00382     nvsg::GroupHandle * interpretNode( domNode * node );
00383     //void                interpretNodeAsset( domAsset * asset );
00384     //void                interpretNodeExtras( domExtra_Array & extras );
00385     void                interpretNodes( domNode_Array & nodes, nvsg::Group * parent );
00386     void                interpretPolygons( domPolygons_Array & polygons );
00387     void                interpretPolylists( domPolylist_Array & polylists );
00388     nvsg::VertexAttributeSetHandle * interpretPrimitive( domP * primitive
00389                                                        , unsigned int primCount
00390                                                        , unsigned int vertsPerPrim
00391                                                        , unsigned int numElements
00392                                                        , domFloat_array ** attributeArrays
00393                                                        , unsigned int * attributeOffsets
00394                                                        , unsigned int * attributeDimensions );
00395     nvsg::SceneHandle * interpretScene( domCOLLADA::domScene * scene );
00396     //void                interpretSceneExtras( domExtra_Array & extras );
00397     //void                interpretSceneInstanceExtras( domExtra_Array & extras );
00398     nvsg::GeoNodeHandle * interpretSkin( domSkin * skin
00399                                        , domBind_material * bindMaterial
00400                                        , unsigned int & numberOfJoints
00401                                        , std::vector<domNode*> & skeletonNodes );
00402     //void                interpretSkinExtras( domExtra_Array & extras );
00403     //void                interpretSkeletons( domInstance_controller::domSkeleton_Array & skeletons
00404     //                                      , unsigned int numberOfJoints );
00405 #if !defined(NDEBUG)
00406     void                interpretSkinSources( domSource_Array & sources );
00407 #endif
00408     void                interpretSourceJOINT( domSource * source
00409                                             , std::vector<domNode*> & skeletonNodes
00410                                             , std::vector<domNode*> & joints );
00411     //void                interpretSpline( domSpline * spline );
00412     bool                interpretTransformElements( domNode * node, std::vector<nvsg::TransformHandle*> & transforms );
00413     void                interpretTriangles( domTriangles_Array & triangles
00414                                           , domBind_material * bindMaterial
00415                                           , std::vector<nvsg::PrimitiveSetHandle*> & primitiveSets
00416                                           , std::vector<nvsg::StateSetHandle*> & stateSets );
00417     //void                interpretTrianglesExtras( domExtra_Array & extras );
00418     void                interpretPrimitiveElementInputs(
00419                                               domInputLocalOffset_Array & inputs
00420                                                 , domFloat_array ** attributeArray
00421                                                 , unsigned int * attributeOffset
00422                                                 , unsigned int * attributeDimension
00423                                                 , unsigned int & numElements
00424                                                 , nvsg::Skin::SkinningType * skinningType );
00425     void                interpretTrifans( domTrifans_Array & trifans );
00426     void                interpretTristrips( domTristrips_Array & tristrips );
00427     void                interpretVertexWeights( domSkin::domVertex_weights * vertexWeights
00428                                               , nvsg::SkinHandle * skinHdl
00429                                               , std::vector<nvsg::PrimitiveSetHandle*> & primitiveSets
00430                                               , std::vector<std::vector<std::pair<unsigned int, float> > > & jointWeightPairs );
00431     //void                interpretVertices( domVertices * vertices );
00432     nvsg::SceneHandle * interpretVisualScene( domVisual_scene * visualScene );
00433     void                interpretVisualSceneAsset( domAsset * asset );
00434     //void                interpretVisualSceneExtras( domExtra_Array & extras );
00435     void                instantiateCameras( domInstance_camera_Array & instanceCameras, const nvsg::Group * parent );
00436     void                instantiateControllers( domInstance_controller_Array & instanceControllers, nvsg::Group * parent );
00437     void                instantiateGeometry( domInstance_geometry * instanceGeometry, nvsg::Group * parent );
00438     void                instantiateGeometries( domInstance_geometry_Array & instanceGeometries, nvsg::Group * parent );
00439     void                instantiateLights( domInstance_light_Array & instanceLights, const nvsg::Group * parent );
00440     void                instantiateNodes( domInstance_node_Array & instanceNodes, nvsg::Group * parent );
00441     //void                instantiatePhysicsScenes( domInstanceWithExtra_Array & sceneInstances );
00442     //void                interpretVertexWeightsExtras( domExtra_Array & extras );
00443     unsigned int        interpretVertexWeightsInputs( domInputLocalOffset_Array & inputs
00444                                                     , unsigned int & indexOffset
00445                                                     , unsigned int & weightOffset
00446                                                     , domListOfFloats & weights );
00447     nvsg::SceneHandle * instantiateVisualScene( domInstanceWithExtra * sceneInstance );
00448
00449 private:
00450   std::map<std::string, std::string> m_workarounds;
00451
00452   DAE * m_dae;
00453   int m_upAxis;
00454   float m_unitScale;
00455   ErrorHandler * m_errorHandler;
00456   domEffect * m_currentEffect;
00457   nvsg::GroupHandle * m_topLevel;
00458   nvsg::SceneHandle * m_scene;
00459
00460   std::map< std::string,  nvsg::GeoNodeHandle * > m_geometryCache;
00461   std::map< domMaterial*, nvsg::StateSetHandle* > m_materialCache;
00462   std::map< std::string,  nvsg::TextureImageHandle * >  m_textureCache;
00463
00464   std::map< daeElement *, AnimationData * > m_animations;
00465
00466   std::map< std::string, cfxMaterial * > m_fxMaterials;
00467   std::map< std::string, cfxEffect * > m_fxEffects;
00468
00469   std::vector< std::string > m_searchPath;
00470   nvsg::ViewStateHandle * m_viewState;
00471   bool m_ignoreTransparency;
00472
00473   std::map<domNode*,nvsg::TransformHandle*> m_jointTransformMap;
00474   std::map<domNode*,nvsg::GroupHandle*>     m_nodeGroupMap;
00475   std::map<nvsg::SkinHandle*,std::pair<std::vector<nvmath::Mat44f>,std::vector<domNode*> > > m_skinToJointsMap;
00476
00477 #if !defined(NDEBUG)
00478   domSource * m_attributeSource[NVMAX_ATTRIBUTES];
00479 #endif
00480 };
00481
00482 #endif // ! defined( DOXYGEN_IGNORE )
00483
00484 #endif /* _LOADDAE_H_ */
00485
00486
00487
00488
00489
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


ErrorHandler.h Source File

ErrorHandler.h

00001
00002 // Copyright NVIDIA Corporation 2002-2005
00003 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00004 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00005 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00006 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00007 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00008 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00009 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00010 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00011 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00012 // POSSIBILITY OF SUCH DAMAGES
00013
00014 //
00015 // ErrorHandler.h
00016 //
00017
00018 #ifndef _ERROR_HANDLER_H_
00019 #define _ERROR_HANDLER_H_
00020
00021 #include "dae/daeTypes.h"
00022 #include "dae/daeErrorHandler.h"
00023 #include "nvutil/PlugInCallback.h"
00024
00025 class ErrorHandler : public daeErrorHandler
00026 {
00027 public:
00028   ErrorHandler( nvutil::PlugInCallback * picb );
00029   virtual ~ErrorHandler();
00030
00031   void handleError( daeString msg );
00032   void handleWarning( daeString msg );
00033
00034 private:
00035   nvutil::PlugInCallback * m_callback;
00036 };
00037
00038 #endif /* _ERROR_HANDLER_H_ */
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


FBO.h Source File

FBO.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvgl/nvgl.h"
00015 #include "nvutil/RCObject.h"
00016
00017 //  it's not necessary to document these helper classes !
00018 #if ! defined( DOXYGEN_IGNORE )
00019
00020 namespace nvgl
00021 {
00022   class FBOTexture : public nvutil::RCObject
00023   {
00024     friend class FBOFrameBuffer;
00025
00026     public:
00027       FBOTexture( GLint internalFormat );
00028       GLuint  getTextureID() const;
00029
00030     protected:
00031       void    resize( GLsizei width, GLsizei height );
00032       virtual ~FBOTexture();
00033
00034     private:
00035       GLint   m_internalFormat;
00036       GLuint  m_textureID;
00037       GLenum  m_format;
00038       GLenum  m_type;
00039   };
00040
00041   inline GLuint FBOTexture::getTextureID() const
00042   {
00043     return( m_textureID );
00044   }
00045
00046
00047   class FBOFrameBuffer
00048   {
00049     public:
00050       FBOFrameBuffer( FBOTexture * colorBuffer, FBOTexture * depthBuffer );
00051       ~FBOFrameBuffer();
00052
00053       GLsizei getWidth() const;
00054       GLsizei getHeight() const;
00055       GLuint  getFramebufferID() const;
00056       GLuint  getColorBufferID() const;
00057       GLuint  getDepthBufferID() const;
00058
00059       void    resize( GLsizei width, GLsizei height );
00060
00061     private:
00062       GLsizei       m_width;
00063       GLsizei       m_height;
00064       GLuint        m_frameBufferID;
00065       FBOTexture  * m_colorBuffer;
00066       FBOTexture  * m_depthBuffer;
00067   };
00068
00069   inline GLsizei FBOFrameBuffer::getWidth() const
00070   {
00071     return( m_width );
00072   }
00073
00074   inline GLsizei FBOFrameBuffer::getHeight() const
00075   {
00076     return( m_height );
00077   }
00078
00079   inline GLuint FBOFrameBuffer::getFramebufferID() const
00080   {
00081     return( m_frameBufferID );
00082   }
00083
00084   inline GLuint FBOFrameBuffer::getColorBufferID() const
00085   {
00086     NVSG_ASSERT( m_colorBuffer );
00087     return( m_colorBuffer->getTextureID() );
00088   }
00089
00090   inline GLuint FBOFrameBuffer::getDepthBufferID() const
00091   {
00092     NVSG_ASSERT( m_depthBuffer );
00093     return( m_depthBuffer->getTextureID() );
00094   }
00095
00096 #endif  //  DOXYGEN_IGNORE
00097 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


GLCgGLStateCallbacks.h Source File

GLCgGLStateCallbacks.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsg/nvsgapi.h"
00015 #include "Cg/cg.h"
00016 #include "nvsg/CgFx.h"
00017
00018 namespace nvgl
00019 {
00020 #if !defined(DOXYGEN_IGNORE)
00021
00023
00025 NVSG_API void GLCgGLRegisterStateCallbacks(CGcontext context);
00026
00028
00031 NVSG_API void GLCgGLBindEffect( nvsg::CgFxEffect * effect );
00032
00034
00036 NVSG_API nvsg::CgFxEffect * GLCgGLGetEffect();
00037
00039
00042 NVSG_API void GLCgGLBindPass( nvsg::CgFxPass pass );
00043
00045
00047 NVSG_API nvsg::CgFxPass GLCgGLGetPass();
00048
00050
00053 NVSG_API void GLCgGLBindProgram( nvsg::CgFxProgram program );
00054
00056
00058 NVSG_API nvsg::CgFxProgram GLCgGLGetProgram();
00059
00061
00065 NVSG_API void GLCgGLApplyProgramSamplers();
00066
00067 #endif
00068 }
Generated on Tue Jan 15 10:27:24 2008 for NVSGSDK by NVIDIA


GLEvalVertexAttrib.h Source File

GLEvalVertexAttrib.h

00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvgl/nvgl.h"
00015
00016 namespace nvsg
00017 {
00018 class VertexAttributeSet;
00019 }
00020
00021 namespace nvgl
00022 {
00023
00024 struct GLArrayBufferCache;
00025
00026 template <GLuint attrIndex>
00027 struct GLEvalVertexAttrib
00028 {
00029   enum {
00030     cshift = attrIndex,
00031     gshift = attrIndex+16,
00032     cmask = 1 << cshift,
00033     gmask = 1 << gshift,
00034     mask = cmask | gmask
00035   };
00036
00037   static void disable();
00038   static void enableGeneric(GLint size, GLenum type, GLboolean normalize, GLsizei stride, const GLvoid * ptr);
00039   static void enableConventional(GLint size, GLenum type, GLsizei stride, const GLvoid * ptr);
00040
00041   static NVSG_API void eval(const nvsg::VertexAttributeSet * vset);
00042   static NVSG_API void eval(const nvsg::VertexAttributeSet * vset, const GLArrayBufferCache * cache);
00043 };
00044
00045 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


GLWinRenderAreaUtil.h Source File

GLWinRenderAreaUtil.h

00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011 #pragma once
00012
00013 #if defined(_WIN32) // win32 only
00014
00015 #include "nvsgcommon.h"
00016
00017 namespace nvutil
00018 {
00019   class ProblemLog;
00020 }
00021
00022 namespace nvui
00023 {
00083   NVSG_API int determinePixelFormat(UINT features, UINT cMultiSampleBuffers, nvutil::ProblemLog& problemLog);
00084
00100   NVSG_API void testPixelFormat(HDC hdc, int pixelFormat, UINT& features, nvutil::ProblemLog& problemLog);
00101 } // end of namespace nvui
00102
00103 #endif // _WIN32
00104
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


glxtypes.h Source File

glxtypes.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00020 // these types are not defined in linux gl headers
00021 typedef const char * (GLAPIENTRYP PFNGLXQUERYEXTENSIONSSTRINGPROC) (Display *dpy, int screen );
00022
00023 typedef GLXContext   (GLAPIENTRYP PFNGLXCREATECONTEXT) (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
00024 typedef void         (GLAPIENTRYP PFNGLXDESTROYCONTEXT) (Display *dpy, GLXContext ctx);
00025 typedef GLXContext   (GLAPIENTRYP PFNGLXGETCURRENTCONTEXT) (void);
00026 typedef Bool         (GLAPIENTRYP PFNGLXMAKECONTEXTCURRENTPROC) (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
00027 typedef GLXDrawable  (GLAPIENTRYP PFNGLXGETCURRENTREADDRAWABLEPROC) (void);
00028
00029 typedef GLXPbuffer   (GLAPIENTRYP PFNGLXCREATEGLXPBUFFERSGIXPROC) (Display *dpy, GLXFBConfig config,
00030                                                                    unsigned int width,
00031                                                                    unsigned int height,
00032                                                                    const int *attrib_list);
00033 typedef void         (GLAPIENTRYP PFNGLXDESTROYGLXPBUFFERSGIXPROC) (Display *dpy, GLXPbuffer pbuf);
00034 typedef void         (GLAPIENTRYP PFNGLXQUERYGLXPBUFFERSGIXPROC) (Display *dpy, GLXPbuffer pbuf,
00035                                                                   int attribute, unsigned int *value);
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Graph Legend

This page explains how to interpret the graphs that are generated by doxygen.

Consider the following example:

/*! Invisible class because of truncation */
class Invisible { };

/*! Truncated class, inheritance relation is hidden */
class Truncated : public Invisible { };

/* Class not documented with doxygen comments */
class Undocumented { };

/*! Class that is inherited using public inheritance */
class PublicBase : public Truncated { };

/*! A template class */
template<class T> class Templ { };

/*! Class that is inherited using protected inheritance */
class ProtectedBase { };

/*! Class that is inherited using private inheritance */
class PrivateBase { };

/*! Class that is used by the Inherited class */
class Used { };

/*! Super class that inherits a number of other classes */
class Inherited : public PublicBase,
                  protected ProtectedBase,
                  private PrivateBase,
                  public Undocumented
                  public Templ<int>
{
  private:
    Used *m_usedClass;
};
If the MAX_DOT_GRAPH_HEIGHT tag in the configuration file is set to 240 this will result in the following graph:

The boxes in the above graph have the following meaning:

  • A filled black box represents the struct or class for which the graph is generated.
  • A box with a black border denotes a documented struct or class.
  • A box with a grey border denotes an undocumented struct or class.
  • A box with a red border denotes a documented struct or class forwhich not all inheritance/containment relations are shown. A graph is truncated if it does not fit within the specified boundaries.
The arrows have the following meaning:
  • A dark blue arrow is used to visualize a public inheritance relation between two classes.
  • A dark green arrow is used for protected inheritance.
  • A dark red arrow is used for private inheritance.
  • A purple dashed arrow is used if a class is contained or used by another class. The arrow is labeled with the variable(s) through which the pointed class or struct is accessible.
  • A yellow dashed arrow denotes a relation between a template instance and the template class it was instantiated from. The arrow is labeled with the template parameters of the instance.
Generated on Tue Jan 15 10:29:50 2008 for NVSGSDK by NVIDIA


HighLightElement.h Source File

HighLightElement.h

00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013 #include "nvtraverser/BaseRenderElement.h"
00014 #include "nvtraverser/ClipPlanesElement.h"
00015 #include "nvtraverser/TransformElement.h"
00016 #include "nvutil/RCObject.h"
00017 #include <algorithm>
00018
00019 namespace nvtraverser
00020 {
00025   class HighlightElement : public BaseRenderElement
00026   {
00027     public:
00033       NVSG_API HighlightElement( ClipPlanesElement * cpe, TransformElement * te );
00034
00039       NVSG_API ~HighlightElement();
00040
00045       NVSG_API void addHighlightObject( nvsg::PrimitiveSetHandle * psh );
00046
00050       NVSG_API ClipPlanesElement * getClipPlanes();
00051
00059       NVSG_API nvsg::PrimitiveSetHandle * getHighlightObject( unsigned int index );
00060
00064       NVSG_API unsigned int getNumberOfHighlightObjects();
00065
00069       NVSG_API TransformElement * getTransform();
00070
00071     private:
00072       std::vector<nvsg::PrimitiveSetHandle*>    m_highlightObjects;
00073       ClipPlanesElement                       * m_clipPlanes;
00074       TransformElement                        * m_transform;
00075   };
00076
00077   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00078   // non-member functions
00079   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00086   inline HighlightElement * createHighlightElement( RenderElementPool * pool, ClipPlanesElement * cpe
00087                                                   , TransformElement* te)
00088   {
00089     NVSG_TRACE();
00090     return constructRenderElement<HighlightElement, ClipPlanesElement*, TransformElement*>(pool, cpe, te );
00091   }
00092
00093
00094   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00095   // inlines
00096   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00097   inline HighlightElement::HighlightElement( ClipPlanesElement * cpe, TransformElement * te )
00098     : m_clipPlanes(cpe)
00099     , m_transform(te)
00100   {
00101     NVSG_TRACE();
00102     NVSG_ASSERT(m_clipPlanes && m_transform);
00103     m_clipPlanes->addRef();
00104     m_transform->addRef();
00105   }
00106
00107   inline HighlightElement::~HighlightElement()
00108   {
00109     NVSG_TRACE();
00110     NVSG_ASSERT(m_clipPlanes && m_transform);
00111     m_clipPlanes->removeRef();
00112     m_transform->removeRef();
00113     std::for_each(m_highlightObjects.begin(),m_highlightObjects.end(), nvutil::removeReference());
00114   }
00115
00116   inline void HighlightElement::addHighlightObject( nvsg::PrimitiveSetHandle * psh )
00117   {
00118     NVSG_TRACE();
00119     NVSG_ASSERT( psh );
00120     psh->addRef();
00121     m_highlightObjects.push_back(psh);
00122   }
00123
00124   inline ClipPlanesElement * HighlightElement::getClipPlanes()
00125   {
00126     NVSG_TRACE();
00127     return( m_clipPlanes );
00128   }
00129
00130   inline nvsg::PrimitiveSetHandle * HighlightElement::getHighlightObject( unsigned int index )
00131   {
00132     NVSG_TRACE();
00133     NVSG_ASSERT( index < m_highlightObjects.size() );
00134     return( m_highlightObjects[index] );
00135   }
00136
00137   inline unsigned int HighlightElement::getNumberOfHighlightObjects()
00138   {
00139     NVSG_TRACE();
00140     NVSG_ASSERT( m_highlightObjects.size() <= UINT_MAX );
00141     return( static_cast<unsigned int>(m_highlightObjects.size()) );
00142   }
00143
00144   inline TransformElement * HighlightElement::getTransform()
00145   {
00146     NVSG_TRACE();
00147     return( m_transform );
00148   }
00149 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


ILTexLoader.h Source File

ILTexLoader.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsg/PlugInterface.h"
00015 #include "nvsg/PlugInterfaceID.h"
00016
00017 namespace nvsg
00018 {
00019   class TextureImage;
00020 }
00021
00022 // storage-class defines
00023 #if defined(_WIN32)
00024 # ifdef ILTEXLOADER_EXPORTS
00025 #  define ILTEXLOADER_API __declspec(dllexport)
00026 # else
00027 #  define ILTEXLOADER_API __declspec(dllimport)
00028 # endif
00029 #else
00030 #  define ILTEXLOADER_API
00031 #endif
00032
00033 // exports required for a scene loader plug-in
00034 #if defined(LINUX)
00035 extern "C"
00036 {
00037 #endif
00038   ILTEXLOADER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00039   ILTEXLOADER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00040 #if defined(LINUX)
00041 }
00042 #endif
00043
00044
00046 class ILTexLoader : public nvsg::TextureLoader
00047 {
00048   public:
00049     ILTexLoader();
00050
00051     friend bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00052
00054
00055     void deleteThis( void );
00056
00057   protected:
00059
00063     virtual ~ILTexLoader();
00064
00076     bool onLoad( const std::string & filename
00077                , nvsg::TextureImage * texImg
00078                , const std::vector<std::string> & searchPaths );
00079
00080   protected:
00084     static ILTexLoader* m_instance;
00085     static unsigned int m_refCount;
00086 };
00087
00088 inline void ILTexLoader::deleteThis()
00089 {
00090   if( (--m_refCount)==0 )
00091   {
00092     delete this;
00093   }
00094 }
00095
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


ILTexSaver.h Source File

ILTexSaver.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsg/PlugInterface.h"
00015 #include "nvsg/PlugInterfaceID.h"
00016 #include "nvsg/TextureImage.h"
00017
00018 // storage-class defines
00019 #if defined(_WIN32)
00020 # ifdef ILTEXSAVER_EXPORTS
00021 #  define ILTEXSAVER_API __declspec(dllexport)
00022 # else
00023 #  define ILTEXSAVER_API __declspec(dllimport)
00024 # endif
00025 #else
00026 #  define ILTEXSAVER_API
00027 #endif
00028
00029 // exports required for a scene loader plug-in
00030 #if defined(LINUX)
00031 extern "C"
00032 {
00033 #endif
00034   ILTEXSAVER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00035   ILTEXSAVER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00036 #if defined(LINUX)
00037 }
00038 #endif
00039
00040
00042 class ILTexSaver : public nvsg::TextureSaver
00043 {
00044 public:
00045     ILTexSaver();
00046
00047     friend bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00048
00049     void deleteThis( void );
00050
00051     bool save(nvsg::TextureImageHandle * image
00052       , const std::string& fileName);
00053
00054 protected:
00055     virtual ~ILTexSaver();
00056 private:
00057     static ILTexSaver* m_instance;
00058     static unsigned int m_refCount;
00059 };
00060
00061 inline void ILTexSaver::deleteThis()
00062 {
00063   if( (--m_refCount)==0 )
00064   {
00065     delete this;
00066   }
00067 }
00068
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


Incarnation.h Source File

Incarnation.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsgcommon.h"
00015
00016 namespace nvutil {
00017
00019
00022 class Incarnation
00023 {
00024 public:
00026
00027   NVSG_API Incarnation();
00028
00030
00032   NVSG_API bool operator==(const Incarnation& rhs) const;
00033
00035
00037   NVSG_API bool operator!=(const Incarnation& rhs) const;
00038
00040
00042   NVSG_API Incarnation& operator++(); // prefix ++
00043
00045
00048   NVSG_API const Incarnation operator++(int); // postfix ++
00049
00051   NVSG_API Incarnation operator+( int i ) const;
00052
00053 private:
00054   NVSG_API explicit Incarnation(int incarnation);
00055
00056 private:
00057   int m_incarnation;
00058 };
00059
00060 inline bool Incarnation::operator==(const Incarnation& rhs) const
00061 {
00062   return m_incarnation==rhs.m_incarnation;
00063 }
00064
00065 inline bool Incarnation::operator!=(const Incarnation& rhs) const
00066 {
00067   return m_incarnation!=rhs.m_incarnation;
00068 }
00069
00070 inline Incarnation& Incarnation::operator++()
00071 {
00072   ++m_incarnation;
00073   return *this;
00074 }
00075
00076 inline const Incarnation Incarnation::operator++(int)
00077 {
00078   return Incarnation(m_incarnation++);
00079 }
00080
00081 inline Incarnation Incarnation::operator+( int i ) const
00082 {
00083   return( Incarnation( m_incarnation + i ) );
00084 }
00085
00086 } // namespace nvutil
00087
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


KeyInput.h Source File

KeyInput.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsgcommon.h"
00015
00016 namespace nvui
00017 {
00039   class KeyInput
00040   {
00041   public:
00045     NVSG_API KeyInput(void);
00047     NVSG_API virtual ~KeyInput(void);
00048
00066     UINT getKeyState( void ) const;
00067
00070      void resetKeyState( void );
00071
00079     NVSG_API void keyDown( UINT key );
00080
00088     NVSG_API void keyUp( UINT key );
00089
00095     NVSG_API KeyInput & operator= ( const KeyInput &rhs );
00096
00103     NVSG_API bool operator==( const KeyInput &rhs ) const;
00104
00110     NVSG_API bool operator!=( const KeyInput &rhs ) const;
00111
00112   protected:
00113     UINT m_keyState;
00114   };
00115
00116   inline UINT KeyInput::getKeyState( void ) const
00117   {
00118     NVSG_TRACE();
00119     return( m_keyState );
00120   }
00121
00122   inline void KeyInput::resetKeyState( void )
00123   {
00124     NVSG_TRACE();
00125     m_keyState = 0;
00126   }
00127 } //namespace nvui
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


LightsElement.h Source File

LightsElement.h

00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include <algorithm> // transform, for_each
00015 #include <iterator> // back_inserter
00016 #include "nvmath/Matnnt.h"
00017 #include "nvsg/Group.h"
00018 #include "nvsg/LightSource.h"
00019 #include "nvtraverser/BaseRenderElement.h"
00020
00021 namespace nvtraverser
00022 {
00028   class LightsElement : public BaseRenderElement
00029   {
00030     public:
00034       NVSG_API LightsElement();
00035
00042       NVSG_API LightsElement( nvsg::GroupHandle * group, const LightsElement &rhs );
00043
00047       NVSG_API ~LightsElement();
00048
00056       NVSG_API void addLight( nvsg::LightSourceHandle * lsh, const nvmath::Mat44f & modelToWorld
00057                             , const nvmath::Mat44f & worldToModel );
00058
00064       NVSG_API nvsg::GroupHandle * getGroup() const;
00065
00072       NVSG_API nvsg::LightSourceHandle * getLight( unsigned int i ) const;
00073
00080       NVSG_API const nvmath::Mat44f & getModelToWorld( unsigned int i ) const;
00081
00085       NVSG_API unsigned int getNumberOfLights() const;
00086
00093       NVSG_API const nvmath::Mat44f & getWorldToModel( unsigned int i ) const;
00094
00095     private:
00096       //  private copy constructor to prevent accidental usage
00097       LightsElement(const LightsElement &rhs);
00098
00099     private:
00100       nvsg::GroupHandle *                   m_group;
00101       std::vector<nvsg::LightSourceHandle*> m_lights;
00102       std::vector<nvmath::Mat44f>           m_modelToWorlds;
00103       std::vector<nvmath::Mat44f>           m_worldToModels;
00104   };
00105
00106
00107   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00108   // non-member functions
00109   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00114   inline LightsElement * createLightsElement( RenderElementPool* pool )
00115   {
00116     return constructRenderElement<LightsElement>(pool);
00117   }
00118
00125   inline LightsElement * createLightsElement( RenderElementPool* pool, nvsg::GroupHandle* group
00126                                             , const LightsElement& rhs)
00127   {
00128     return constructRenderElement<LightsElement, nvsg::GroupHandle*, const LightsElement&>(pool, group, rhs);
00129   }
00130
00131
00132   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00133   // inlines
00134   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00135   inline LightsElement::LightsElement()
00136     : m_group(NULL)
00137   {
00138   }
00139
00140   inline LightsElement::LightsElement( nvsg::GroupHandle * group, const LightsElement &rhs )
00141     : m_group(group)
00142     , m_modelToWorlds(rhs.m_modelToWorlds) // copy matrices
00143     , m_worldToModels(rhs.m_worldToModels) // copy matrices
00144   {
00145     NVSG_ASSERT( m_group );
00146     m_group->addRef();
00147
00148     // copy lights from rhs and add reference for each
00149     std::transform( rhs.m_lights.begin(), rhs.m_lights.end(), std::back_inserter(m_lights)
00150                   , nvutil::addReference() );
00151   }
00152
00153   inline LightsElement::~LightsElement()
00154   {
00155     if ( m_group )
00156     {
00157       m_group->removeRef();
00158     }
00159     std::for_each( m_lights.begin(), m_lights.end(), nvutil::removeReference() );
00160   }
00161
00162   inline void LightsElement::addLight( nvsg::LightSourceHandle * lsh, const nvmath::Mat44f & modelToWorld
00163                               , const nvmath::Mat44f & worldToModel )
00164   {
00165     NVSG_ASSERT( lsh );
00166     lsh->addRef();
00167     m_lights.push_back( lsh );
00168     m_modelToWorlds.push_back( modelToWorld );
00169     m_worldToModels.push_back( worldToModel );
00170   }
00171
00172   inline nvsg::GroupHandle * LightsElement::getGroup() const
00173   {
00174     return( m_group );
00175   }
00176
00177   inline nvsg::LightSourceHandle * LightsElement::getLight( unsigned int i ) const
00178   {
00179     NVSG_ASSERT( i < m_lights.size() );
00180     return( m_lights[i] );
00181   }
00182
00183   inline const nvmath::Mat44f & LightsElement::getModelToWorld( unsigned int i ) const
00184   {
00185     NVSG_ASSERT( i < m_modelToWorlds.size() );
00186     return( m_modelToWorlds[i] );
00187   }
00188
00189   inline unsigned int LightsElement::getNumberOfLights() const
00190   {
00191     NVSG_ASSERT( m_lights.size() <= UINT_MAX );
00192     return( static_cast<unsigned int>(m_lights.size()) );
00193   }
00194
00195   inline const nvmath::Mat44f & LightsElement::getWorldToModel( unsigned int i ) const
00196   {
00197     NVSG_ASSERT( i < m_worldToModels.size() );
00198     return( m_worldToModels[i] );
00199   }
00200
00201 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


LinuxTypes.h Source File

LinuxTypes.h

00001 // Copyright NVIDIA Corporation 2002-2004
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include <stdlib.h>
00015
00016 #include <complex>
00017 // Normally we should not be exposing names/namespaces in headers, but
00018 // we need a common abs() function that is overloaded for int/float/double.
00019 // On Windows a template function is exposed in the global namespace.
00020 // By including <complex>, the same functionality becomes available on Linux.
00021 // Whether overloaded functions or a template sprcialization is used depends on
00022 // the gcc configuration. (Macros are queried in <complex> header file).
00023 using ::std::abs;
00024
00025 typedef unsigned int UINT;
00026
00027
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


stdafx.h Source File

stdafx.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 // stdafx.h : include file for standard system include files,
00013 // or project specific include files that are used frequently, but
00014 // are changed infrequently
00015 //
00016
00017 #pragma once
00018
00019
00020 #if defined(_WIN32)
00021
00022 #define WIN32_LEAN_AND_MEAN   // Exclude rarely-used stuff from Windows headers
00023 // Windows Header Files:
00024 #include <windows.h>
00025
00026 #endif
00027
00028 #include <typeinfo>
00029
00030 #include "nvsg/nvsgapi.h" // NVSG storage-class defines
00031 #include "nvsg/NVSGVersion.h" // NVSG version info
00032
00033 #include "nvutil/Assert.h"
00034 #include "nvutil/Trace.h"
00035 #include "nvutil/Tools.h"
00036
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


stdafx.h Source File

stdafx.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 // stdafx.h : include file for standard system include files,
00013 // or project specific include files that are used frequently, but
00014 // are changed infrequently
00015 //
00016
00017 #pragma once
00018
00019 #if defined(_WIN32)
00020
00021 #define WIN32_LEAN_AND_MEAN   // Exclude rarely-used stuff from Windows headers
00022 // Windows Header Files:
00023 #include <windows.h>
00024
00025 #endif
00026
00027 #include <typeinfo>
00028
00029 #include "nvsg/nvsgapi.h" // NVSG storage-class defines
00030 #include "nvsg/NVSGVersion.h" // NVSG version info
00031
00032 #include "nvutil/Assert.h"
00033 #include "nvutil/Trace.h"
00034 #include "nvutil/Tools.h"
00035
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


MemFunTbl.h Source File

MemFunTbl.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsgcommon.h"
00015
00016 #include <vector>
00017
00018 namespace nvutil
00019 {
00020
00022 template<typename T>
00023 class MemFunTbl
00024 {
00025   typedef void (T::*PMFN) ();
00026 public:
00027   explicit MemFunTbl(size_t size);
00028   PMFN operator[](size_t i) const;
00029   template <typename U>
00030   void addEntry(size_t i, U pmfn);
00031   bool testEntry(size_t i) const;
00032 private:
00033   std::vector<PMFN> m_ftbl;
00034 };
00035
00036 // inline implementations can go here
00037
00038 template<typename T>
00039 inline MemFunTbl<T>::MemFunTbl(size_t size)
00040 { // table entries to avoid frequent allocations at addEntry
00041   m_ftbl.resize(size, NULL);
00042 }
00043
00044 template<typename T>
00045 inline bool MemFunTbl<T>::testEntry(size_t i) const
00046 { // test if entry at i is a valid entry
00047   return (i < m_ftbl.size()) && !!m_ftbl[i];
00048 }
00049
00050 template<typename T>
00051 inline typename MemFunTbl<T>::PMFN MemFunTbl<T>::operator[](size_t i) const
00052 { // read-only access to function pointer stored at index i
00053   NVSG_ASSERT(testEntry(i)); // undefined behavior for invalid entries
00054   return m_ftbl[i];
00055 }
00056
00057 template<typename T>
00058 template<typename U>
00059 inline void MemFunTbl<T>::addEntry(size_t i, U pmfn)
00060 { // register function pointer
00061   if ( m_ftbl.size() <= i )
00062   { // add 32 table entries
00063     m_ftbl.resize(i+0x20, NULL);
00064   }
00065   m_ftbl[i]=*(PMFN*)&pmfn;
00066 }
00067
00068 } // end of namespace nvutil scope
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


MouseInput.h Source File

MouseInput.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsgcommon.h"
00015
00016 namespace nvui
00017 {
00042   class MouseInput
00043   {
00044   public:
00048     NVSG_API MouseInput();
00049
00051     NVSG_API virtual ~MouseInput();
00052
00056     void resetButtonState();
00057
00061     void resetPositions();
00062
00080     UINT getButtonState() const;
00081
00093     NVSG_API void mouseButtonDown( UINT btn, int x, int y );
00094
00105     NVSG_API void mouseButtonUp( UINT btn, int x, int y );
00106
00113     NVSG_API void mouseMotion( int x, int y );
00114
00122     NVSG_API void motionHandled();
00123
00124
00132     NVSG_API int getLastX() const;
00133
00141     NVSG_API int getLastY() const;
00142
00148     NVSG_API int getCurrentX() const;
00149
00155     NVSG_API int getCurrentY() const;
00156
00162     NVSG_API int getStartX() const;
00163
00169     NVSG_API int getStartY() const;
00170
00176     NVSG_API MouseInput & operator= ( const MouseInput &rhs );
00177
00184     NVSG_API bool operator==( const MouseInput &rhs ) const;
00185
00192     NVSG_API bool operator!=( const MouseInput &rhs ) const;
00193
00194   protected:
00195     UINT m_buttonState;
00196
00197     int m_currentX;
00198     int m_currentY;
00199
00200     int m_lastX;
00201     int m_lastY;
00202
00203     int m_startX;
00204     int m_startY;
00205   };
00206
00207   inline int MouseInput::getLastX() const
00208   {
00209     NVSG_TRACE();
00210     return m_lastX;
00211   }
00212
00213   inline int MouseInput::getLastY() const
00214   {
00215     NVSG_TRACE();
00216     return m_lastY;
00217   }
00218
00219   inline int MouseInput::getCurrentX() const
00220   {
00221     NVSG_TRACE();
00222     return m_currentX;
00223   }
00224
00225   inline int MouseInput::getCurrentY() const
00226   {
00227     NVSG_TRACE();
00228     return m_currentY;
00229   }
00230
00231   inline int MouseInput::getStartX() const
00232   {
00233     NVSG_TRACE();
00234     return m_startX;
00235   }
00236
00237   inline int MouseInput::getStartY() const
00238   {
00239     NVSG_TRACE();
00240     return m_startY;
00241   }
00242
00243   inline void MouseInput::resetPositions()
00244   {
00245     m_lastX = m_lastY = m_currentX = m_currentY = m_startX = m_startY = 0;
00246   }
00247
00248   inline void MouseInput::resetButtonState()
00249   {
00250     NVSG_TRACE();
00251     m_buttonState = 0;
00252   }
00253
00254   inline UINT MouseInput::getButtonState() const
00255   {
00256     NVSG_TRACE();
00257     return( m_buttonState );
00258   }
00259 } //namespace nvui
00260
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


NBFLoader.h Source File

NBFLoader.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsg/PlugInterface.h"
00015 #include "nvsg/NBF.h" // nbf structs
00016 #include "nvutil/FileMapping.h"
00017 #include "nvutil/RCObject.h"  // RCObject_AutoPtr
00018
00019 #include <map>
00020 #include <vector>
00021 #include <string>
00022
00023 // storage-class defines
00024 #if defined(_WIN32)
00025 # ifdef NBFLOADER_EXPORTS
00026 #  define NBFLOADER_API __declspec(dllexport)
00027 # else
00028 #  define NBFLOADER_API __declspec(dllimport)
00029 # endif
00030 #else
00031 #  define NBFLOADER_API
00032 #endif
00033
00034 #if defined(LINUX)
00035 void lib_init() __attribute__ ((constructor));   // will be called before dlopen() returns
00036 #endif
00037
00038 // exports required for a scene loader plug-in
00039 #if defined(LINUX)
00040 extern "C"
00041 {
00042 #endif
00043 NBFLOADER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00044 NBFLOADER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00045 #if defined(LINUX)
00046 }
00047 #endif
00048
00049 // forward declaration
00050 namespace nvsg
00051 {
00052   class AlphaTestAttribute;
00053   class AnimatedTransform;
00054   class Billboard;
00055   class BlendAttribute;
00056   class Camera;
00057   class CgFx;
00058   class DirectedLight;
00059   class Drawable;
00060   class FaceAttribute;
00061   class FlipbookAnimation;
00062   class GeoNode;
00063   class Group;
00064   class LightingAttribute;
00065   class LightSource;
00066   class Lines;
00067   class LOD;
00068   class Material;
00069   class Node;
00070   class ParallelCamera;
00071   class PerspectiveCamera;
00072   class PointAttribute;
00073   class PointLight;
00074   class Points;
00075   class QuadMeshes;
00076   class Quads;
00077   class QuadStrips;
00078   class SkinnedTriangles;
00079   class SpotLight;
00080   class StateAttribute;
00081   class StateSet;
00082   class TextureAttribute;
00083   class TextureAttributeItem;
00084   class TextureImage;
00085   class Transform;
00086   class Triangles;
00087   class TriStrips;
00088   class Switch;
00089   class Scene;
00090   class UnlitColorAttribute;
00091   class ViewState;
00092   template<typename T> class FramedAnimation;
00093   template<typename T> class KeyFramedAnimation;
00094 }
00095
00096 struct NBFGroup_nbf_12;
00097 struct NBFGroup_nbf_11;
00098 struct NBFLightSource_nbf_12;
00099
00101 class NBFLoader : public nvsg::SceneLoader
00102 {
00103 public:
00104   NBFLoader();
00105
00107
00108   void deleteThis( void );
00109
00111
00115   nvsg::SceneHandle * load(
00116     const std::string& filename
00117   , const std::vector<std::string> &searchPaths
00118   , nvsg::ViewStateHandle *& viewState
00120   );
00121
00122 protected:
00124   virtual  ~NBFLoader(void);
00125
00127
00138   virtual nvsg::ObjectHandle * loadCustomObject(
00139     uint_t objectCode
00140   , uint_t offset
00141   );
00142
00144
00146   ubyte_t * mapOffset(
00147     uint_t offset
00148     , unsigned int numBytes
00149     );
00150
00152
00153   void unmapOffset(
00154     ubyte_t * offsetPtr
00155     );
00156
00157 private:
00158
00160
00162   template<typename T>
00163   class Offset_AutoPtr
00164   {
00165     public:
00167
00169       Offset_AutoPtr( nvutil::ReadMapping * fm, const nvutil::PlugInCallback * pic, uint_t offset
00170                     , unsigned int count=1 );
00171
00173       ~Offset_AutoPtr();
00174
00176       T* operator->() const;
00177
00179       T& operator*() const;
00180
00182       operator const T*() const;
00183
00185
00187       void reset( uint_t offset, unsigned int count=1 );
00188
00189     private:
00190       T * m_ptr;
00191       const nvutil::PlugInCallback  * m_pic;
00192       nvutil::ReadMapping           * m_fm;
00193   };
00194
00195
00196   nvutil::ReadMapping * m_fm;
00197
00198   // assign an object to an offset
00199   void mapObject(uint_t offset, nvsg::ObjectHandle * object);
00200
00201   // animations
00202   nvsg::FlipbookAnimationHandle * loadFlipbookAnimatin(uint_t offset);
00203   nvsg::IndexAnimationHandle * loadIndexAnimation(uint_t offset);
00204   nvsg::TrafoAnimationHandle * loadTrafoAnimation(uint_t offset);
00205   // ... framed
00206   nvsg::FramedTrafoAnimationHandle * loadFramedTrafoAnimation(uint_t offset);
00207   nvsg::FramedTrafoAnimationHandle * loadFramedTrafoAnimation_nbf_3c(uint_t offset);
00208   nvsg::FramedTrafoAnimationHandle * loadFramedTrafoAnimation_nbf_f(uint_t offset);
00209   nvsg::FramedVertexAttributeAnimationHandle * loadFramedVertexAttributeAnimation(uint_t offset);
00210   nvsg::FramedVertexAttributeAnimationHandle * loadFramedVertexAttributeAnimation_nbf_3c(uint_t offset);
00211   nvsg::FramedIndexAnimationHandle * loadFramedIndexAnimation(uint_t offset);
00212   nvsg::FramedIndexAnimationHandle * loadFramedIndexAnimation_nbf_3c(uint_t offset);
00213   // ... interpolated
00214   nvsg::KeyFramedTrafoAnimationHandle * loadKeyFramedTrafoAnimation(uint_t offset);
00215   nvsg::KeyFramedTrafoAnimationHandle * loadKeyFramedTrafoAnimation_nbf_3c(uint_t offset);
00216   nvsg::KeyFramedTrafoAnimationHandle * loadKeyFramedTrafoAnimation_nbf_f(uint_t offset);
00217   nvsg::KeyFramedVertexAttributeAnimationHandle * loadKeyFramedVertexAttributeAnimation(uint_t offset);
00218   nvsg::KeyFramedVertexAttributeAnimationHandle * loadKeyFramedVertexAttributeAnimation_nbf_3c(uint_t offset);
00219   // cameras
00220   nvsg::CameraHandle * loadCamera(uint_t offset);
00221   nvsg::ParallelCameraHandle * loadParallelCamera(uint_t offset);
00222   nvsg::PerspectiveCameraHandle * loadPerspectiveCamera(uint_t offset);
00223   // drawables
00224   nvsg::DrawableHandle * loadDrawable(uint_t offset);
00225   nvsg::TrianglesHandle * loadSkinnedTriangles(uint_t offset);
00226   template<typename Type, typename HandleType> HandleType * loadAnimatedIndependents_nbf_3a( uint_t offset );
00227   template<typename Type, typename HandleType> HandleType * loadIndependents( uint_t offset );
00228   template<typename Type, typename HandleType> HandleType * loadMeshes(uint_t offset);
00229   template<typename Type, typename HandleType> HandleType * loadStrips(uint_t offset);
00230   // scene
00231   nvsg::SceneHandle * loadScene(uint_t offset);
00232   nvsg::SceneHandle * loadScene_nbf_b(uint_t offset);
00233   nvsg::SceneHandle * loadScene_nbf_31(uint_t offset);
00234   nvsg::SceneHandle * loadScene_nbf_37(uint_t offset);
00235   // nodes
00236   nvsg::NodeHandle * loadNode(uint_t offset);
00237   nvsg::ObjectHandle * loadNode_nbf_12(uint_t offset);
00238   nvsg::GeoNodeHandle * loadGeoNode(uint_t offset);
00239   nvsg::VolumeNodeHandle * loadVolumeNode(uint_t offset);
00240   nvsg::VolumeNodeHandle * loadVolumeNode_nbf_21_32(uint_t offset);
00241   nvsg::GroupHandle * loadGroup(uint_t offset);
00242   nvsg::GroupHandle * loadGroup_nbf_12(uint_t offset);
00243   nvsg::GroupHandle * loadGroup_nbf_11(uint_t offset);
00244   nvsg::BillboardHandle * loadBillboard(uint_t offset);
00245   nvsg::BillboardHandle * loadBillboard_nbf_12(uint_t offset);
00246   nvsg::BillboardHandle * loadBillboard_nbf_11(uint_t offset);
00247   nvsg::FlipbookAnimationHandle * loadFlipbookAnimation(uint_t offset);
00248   nvsg::TransformHandle * loadTransform(uint_t offset);
00249   nvsg::TransformHandle * loadTransform_nbf_12(uint_t offset);
00250   nvsg::TransformHandle * loadTransform_nbf_11(uint_t offset);
00251   nvsg::TransformHandle * loadTransform_nbf_f(uint_t offset);
00252   nvsg::AnimatedTransformHandle * loadAnimatedTransform(uint_t offset);
00253   nvsg::AnimatedTransformHandle * loadAnimatedTransform_nbf_12(uint_t offset);
00254   nvsg::AnimatedTransformHandle * loadAnimatedTransform_nbf_11(uint_t offset);
00255   nvsg::AnimatedTransformHandle * loadAnimatedTransform_nbf_f(uint_t offset);
00256   nvsg::LODHandle * loadLOD(uint_t offset);
00257   nvsg::LODHandle * loadLOD_nbf_12(uint_t offset);
00258   nvsg::LODHandle * loadLOD_nbf_11(uint_t offset);
00259   nvsg::SwitchHandle * loadSwitch(uint_t offset);
00260   nvsg::SwitchHandle * loadSwitch_nbf_30(uint_t offset);
00261   nvsg::SwitchHandle * loadSwitch_nbf_12(uint_t offset);
00262   nvsg::SwitchHandle * loadSwitch_nbf_11(uint_t offset);
00263   nvsg::LightSourceHandle * loadLightSource(uint_t offset);
00264   nvsg::LightSourceHandle * loadLightSource_nbf_12(uint_t offset);
00265   nvsg::DirectedLightHandle * loadDirectedLight(uint_t offset);
00266   nvsg::DirectedLightHandle * loadDirectedLight_nbf_12(uint_t offset);
00267   nvsg::PointLightHandle * loadPointLight(uint_t offset);
00268   nvsg::PointLightHandle * loadPointLight_nbf_12(uint_t offset);
00269   nvsg::SpotLightHandle * loadSpotLight(uint_t offset);
00270   nvsg::SpotLightHandle * loadSpotLight_nbf_12(uint_t offset);
00271   // state attribs
00272   nvsg::StateAttributeHandle * loadStateAttribute(uint_t offset);
00273   nvsg::AlphaTestAttributeHandle * loadAlphaTestAttribute(uint_t offset);
00274   nvsg::BlendAttributeHandle * loadBlendAttribute(uint_t offset);
00275   nvsg::CgFxHandle * loadCgFx(uint_t offset);
00276   nvsg::DepthAttributeHandle * loadDepthAttribute(uint_t offset);
00277   // ...
00278   nvsg::FaceAttributeHandle * loadFaceAttribute(uint_t offset);
00279   nvsg::FaceAttributeHandle * loadFaceAttribute_nbf_b(uint_t offset);
00280   nvsg::LightingAttributeHandle * loadLightingAttribute(uint_t offset);
00281   nvsg::LineAttributeHandle * loadLineAttribute(uint_t offset);
00282   nvsg::MaterialHandle * loadMaterial(uint_t offset);
00283   nvsg::MaterialHandle * loadMaterial_nbf_a(uint_t offset);
00284   nvsg::PointAttributeHandle * loadPointAttribute(uint_t offset);
00285   nvsg::TextureAttributeHandle * loadTextureAttribute(uint_t offset);
00286   nvsg::TextureAttributeItemHandle * loadTextureAttributeItem(uint_t offset);
00287   nvsg::TextureAttributeItemHandle * loadTextureAttributeItem_nbf_36(uint_t offset);
00288   nvsg::TextureAttributeItemHandle * loadTextureAttributeItem_nbf_20(uint_t offset);
00289   nvsg::TextureAttributeItemHandle * loadTextureAttributeItem_nbf_12(uint_t offset);
00290   nvsg::TextureAttributeItemHandle * loadTextureAttributeItem_nbf_f(uint_t offset);
00291   nvsg::TextureAttributeItemHandle * loadTextureAttributeItem_nbf_e(uint_t offset);
00292   nvsg::UnlitColorAttributeHandle * loadUnlitColorAttribute(uint_t offset);
00293
00294   nvsg::TextureImageHandle * loadTextureImage(uint_t offset, std::string& file);
00295
00296   // state set
00297   nvsg::StateSetHandle * loadStateSet(uint_t offset);
00298   nvsg::StateSetHandle * loadStateSet_nbf_10(uint_t offset);
00299   nvsg::StateVariantHandle * loadStateVariant(uint_t offset);
00300   nvsg::StatePassHandle * loadStatePass(uint_t offset);
00301   // view state
00302   nvsg::ViewStateHandle *loadViewState_nbf_39(uint_t offset);
00303   nvsg::ViewStateHandle * loadViewState(uint_t offset);
00304
00305   // vertex attribute set
00306   nvsg::VertexAttributeSetHandle * loadVertexAttributeSet( uint_t vasOffset);
00307   nvsg::VertexAttributeSetHandle * loadVertexAttributeSet_nbf_3a( uint_t vasOffset);
00308   nvsg::VertexAttributeSetHandle * loadVertexAttributeSet_nbf_38( uint_t vasOffset);
00309   void loadVNVectorAnimation_nbf_3a(
00310     uint_t offset,
00311     nvutil::RCObject_AutoPtr<nvsg::VertexAttributeAnimationHandle> & vAnim,
00312     nvutil::RCObject_AutoPtr<nvsg::VertexAttributeAnimationHandle> & nAnim );
00313   void loadFramedVNVectorAnimation_nbf_3a(
00314     uint_t offset,
00315     nvutil::RCObject_AutoPtr<nvsg::VertexAttributeAnimationHandle> & vAnim,
00316     nvutil::RCObject_AutoPtr<nvsg::VertexAttributeAnimationHandle> & nAnim );
00317   void loadInterpolatedVNVectorAnimation_nbf_3a(
00318     uint_t offset,
00319     nvutil::RCObject_AutoPtr<nvsg::VertexAttributeAnimationHandle> & vAnim,
00320     nvutil::RCObject_AutoPtr<nvsg::VertexAttributeAnimationHandle> & nAnim );
00321   nvsg::VertexAttributeAnimationHandle * loadVertexAttributeAnimation( uint_t vaaOffset );
00322   nvsg::SkinHandle * loadSkin( uint_t skinOffset );
00323
00324   // shared object handling
00325   template <typename ObjectType, typename NBFObjectType>
00326   bool loadSharedObject(nvutil::RCObject_AutoPtr<ObjectType>& obj, Offset_AutoPtr<NBFObjectType>& objPtr);
00327
00328   // read in non-concrete objects
00329   template <typename T>
00330     void readAnimation( nvsg::Animation<T> * dst, const NBFAnimation * src );
00331   void readObject(nvsg::Object * dst, const NBFObject * src);
00332   void readGroup(nvsg::Group * dst, const NBFGroup * src);
00333   void readGroup_nbf_12(nvsg::Group * dst, const NBFGroup_nbf_12 * src);
00334   void readGroup_nbf_11(nvsg::Group * dst, const NBFGroup_nbf_11 * src);
00335   void readPrimitiveSet(nvsg::PrimitiveSet * dst, const NBFPrimitiveSet * src);
00336   void readIndependentPrimitiveSet( nvsg::IndependentPrimitiveSet *dst, const NBFIndependentPrimitiveSet *src );
00337   void readLightSource(nvsg::LightSource * dst, const NBFLightSource * src);
00338   void readLightSource_nbf_12(nvsg::LightSource * dst, const NBFLightSource_nbf_12 * src);
00339   void readNode(nvsg::Node * dst, const NBFNode * src);
00340   void readCamera(nvsg::Camera * dst, const NBFCamera * src);
00341   void readTweak(nvsg::CgFxEffect * effect, const tweak_t * tweak);
00342   void readSampler(nvsg::CgFxEffect * effect, const sampler_t * sampler);
00343   void readVertexAttributeSet( nvsg::VertexAttributeSet * dst, const NBFVertexAttributeSet * src );
00344   void readAnimatedVertexAttributeSet( nvsg::AnimatedVertexAttributeSet * dst, const NBFAnimatedVertexAttributeSet * src );
00345   // used in loadScene*
00346   // these needs to be declared as template functions, because they need to handle different NBFScene types
00347   template <typename NBFSceneType> void readSceneCameras(nvsg::Scene * nvsgScene, const Offset_AutoPtr<NBFSceneType>& nbfScene);
00348   template <typename NBFSceneType> void readSceneCameraAnimations(nvsg::Scene * nvsgScene, const Offset_AutoPtr<NBFSceneType>& nbfScene);
00349   template <typename NBFSceneType> void readSceneRootNode(nvsg::Scene * nvsgScene, const Offset_AutoPtr<NBFSceneType>& nbfScene);
00350   // helpers while loading TextureAttributeItem
00351   template <typename NBFTAIType> nvsg::TextureAttributeItemHandle * readTexAttribItem(Offset_AutoPtr<NBFTAIType>& nbfTAI);
00352   template <typename NBFTAIType> void readTexImg(nvsg::TextureAttributeItem * dst, const Offset_AutoPtr<NBFTAIType>& src);
00353   template <typename NBFTAIType> void readTexParams(nvsg::TextureAttributeItem * dst, const Offset_AutoPtr<NBFTAIType>& src);
00354   template <typename NBFTAIType> void readTexEnv(nvsg::TextureAttributeItem * dst, const Offset_AutoPtr<NBFTAIType>& src);
00355   template <typename NBFTAIType> void readTexGenMode(nvsg::TextureAttributeItem * dst, const Offset_AutoPtr<NBFTAIType>& src);
00356   template <typename NBFTAIType> void readTexMatrix(nvsg::TextureAttributeItem * dst, const Offset_AutoPtr<NBFTAIType>& src);
00357
00358   // map a string object (helper)
00359   std::string mapString(const str_t& str);
00360   std::string mapString(const sstr_t& str); // overload for small strings
00361
00362 private:
00363   std::vector<std::string>        m_searchPaths;  // a private copy of the search pathes given to us via the load API
00364   std::map<uint_t, nvsg::ObjectHandle *> m_offsetObjectMap; // mapping offsets to NVSG objects
00365   std::map<nvsg::DataID, nvsg::ObjectHandle *> m_sharedObjectsMap; // lookup shared objects given the corresponding objectID
00366   // private copy of the nbf version used to save the file
00367   ubyte_t m_nbfMajor;   // major version
00368   ubyte_t m_nbfMinor;   // minor version
00369   ubyte_t m_nbfBugfix;  // bugfix level
00370
00371   // call some load routines via function pointers to preserve downward compatibility
00372   nvsg::AnimatedTransformHandle * (NBFLoader::*m_pfnLoadAnimatedTransform)(uint_t); // ... load AnimatedTransform
00373   nvsg::BillboardHandle     * (NBFLoader::*m_pfnLoadBillboard)(uint_t);     // ... load Billboard
00374   nvsg::FaceAttributeHandle * (NBFLoader::*m_pfnLoadFaceAttribute)(uint_t); // ... load FaceAttribute
00375   nvsg::FramedIndexAnimationHandle * (NBFLoader::*m_pfnLoadFramedIndexAnimation)(uint_t); // ... load FramedAnimation<unsigned int>
00376   nvsg::FramedTrafoAnimationHandle * (NBFLoader::*m_pfnLoadFramedTrafoAnimation)(uint_t); // ... load FramedAnimation<Trafo>
00377   nvsg::FramedVertexAttributeAnimationHandle * (NBFLoader::*m_pfnLoadFramedVertexAttributeAnimation)(uint_t); // ... load FramedAnimation<VertexAttribute>
00378   nvsg::GroupHandle * (NBFLoader::*m_pfnLoadGroup)(uint_t); // ... load Group
00379   nvsg::KeyFramedTrafoAnimationHandle * (NBFLoader::*m_pfnLoadKeyFramedTrafoAnimation)(uint_t); // ... load KeyFramedAnimation<Trafo>
00380   nvsg::KeyFramedVertexAttributeAnimationHandle * (NBFLoader::*m_pfnLoadKeyFramedVertexAttributeAnimation)(uint_t); // ... load KeyFramedAnimation<VertexAttribute>
00381   nvsg::LightSourceHandle   * (NBFLoader::*m_pfnLoadLightSource)(uint_t);   // ... load LightSource
00382   nvsg::LODHandle           * (NBFLoader::*m_pfnLoadLOD)(uint_t);           // ... load LOD
00383   nvsg::MaterialHandle      * (NBFLoader::*m_pfnLoadMaterial)(uint_t);      // ... load Material
00384   nvsg::SceneHandle         * (NBFLoader::*m_pfnLoadScene)(uint_t);         // ... load Scene
00385   nvsg::SwitchHandle        * (NBFLoader::*m_pfnLoadSwitch)(uint_t);        // ... load Switch
00386   nvsg::StateSetHandle      * (NBFLoader::*m_pfnLoadStateSet)(uint_t);      // ... load StateSet
00387   nvsg::TextureAttributeItemHandle * (NBFLoader::*m_pfnLoadTextureAttributeItem)(uint_t); // ... load TextureAttributeItem
00388   nvsg::TransformHandle     * (NBFLoader::*m_pfnLoadTransform)(uint_t);     // ... load Transform
00389   nvsg::VolumeNodeHandle    * (NBFLoader::*m_pfnLoadVolumeNode)(uint_t);    // ... load VolumeNode
00390   nvsg::VertexAttributeSetHandle * (NBFLoader::*m_pfnLoadVertexAttributeSet)(uint_t); // ... load VertexAttributeSet
00391   nvsg::ViewStateHandle *(NBFLoader::*m_pfnLoadViewState)(uint_t);   //..load ViewState
00392
00393   std::map<std::string,nvsg::TextureImageHandle*> m_textureImages;  // collection of currently loaded TextureImages
00394   std::map<std::string,nvsg::CgFxHandle*> m_cgfxEffects;
00395
00396   // For loading old SkinnedTriangles only.
00397   // Map the animations (stored in the old bone) to the Transforms created for it.
00398   // Those Transforms will be the Joints, and added to the root node.
00399   std::map<nvsg::TrafoAnimationHandle*,nvsg::AnimatedTransformHandle*>  m_animationToJointMap;
00400 };
00401
00402 inline void NBFLoader::deleteThis()
00403 {
00404   delete this;
00405 }
00406
00407 inline ubyte_t * NBFLoader::mapOffset( uint_t offset, unsigned int numBytes )
00408 {
00409   NVSG_TRACE();
00410   NVSG_ASSERT( m_fm );
00411   return( (ubyte_t*) m_fm->mapIn( offset, numBytes ) );
00412 }
00413
00414 inline void NBFLoader::unmapOffset( ubyte_t * offsetPtr )
00415 {
00416   NVSG_TRACE();
00417   NVSG_ASSERT( m_fm );
00418   m_fm->mapOut( offsetPtr );
00419 }
00420
00421 template<typename T>
00422 inline NBFLoader::Offset_AutoPtr<T>::Offset_AutoPtr( nvutil::ReadMapping * fm
00423                                                    , const nvutil::PlugInCallback * pic
00424                                                    , uint_t offset, unsigned int count )
00425 : m_ptr(NULL)
00426 , m_fm(fm)
00427 , m_pic(pic)
00428 {
00429   if ( count )
00430   {
00431     m_ptr = (T*)m_fm->mapIn(offset, count*sizeof(T));
00432     if ( ! m_ptr && m_pic )
00433     {
00434       m_pic->onFileMappingFailed(m_fm->getLastError());
00435     }
00436   }
00437  }
00438
00439 template<typename T>
00440 inline NBFLoader::Offset_AutoPtr<T>::~Offset_AutoPtr()
00441 {
00442   if ( m_ptr )
00443   {
00444     m_fm->mapOut((ubyte_t*)m_ptr);
00445   }
00446 }
00447
00448 template<typename T>
00449 inline T* NBFLoader::Offset_AutoPtr<T>::operator->() const
00450 {
00451   return m_ptr;
00452 }
00453
00454 template<typename T>
00455 inline T& NBFLoader::Offset_AutoPtr<T>::operator*() const
00456 {
00457   return *m_ptr;
00458 }
00459
00460 template<typename T>
00461 inline NBFLoader::Offset_AutoPtr<T>::operator const T*() const
00462 {
00463   return m_ptr;
00464 }
00465
00466 template<typename T>
00467 inline void NBFLoader::Offset_AutoPtr<T>::reset( uint_t offset, unsigned int count )
00468 {
00469   if ( m_ptr )
00470   {
00471     m_fm->mapOut((ubyte_t*)m_ptr);
00472     m_ptr=NULL;
00473   }
00474   if ( count )
00475   {
00476     m_ptr = (T*)m_fm->mapIn(offset, count*sizeof(T));
00477     if ( ! m_ptr && m_pic )
00478     {
00479       m_pic->onFileMappingFailed(m_fm->getLastError());
00480     }
00481   }
00482 }
Generated on Tue Jan 15 10:27:26 2008 for NVSGSDK by NVIDIA


NBFSaver.h Source File

NBFSaver.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include <map>
00015 #include <vector>
00016 #include "nvsg/PlugInterface.h"
00017 #include "nvsg/ViewState.h"
00018 #include "nvutil/FileMapping.h"
00019 #include "nvtraverser/Traverser.h"
00020
00021 #if defined(_WIN32)
00022 # ifdef NBFSAVER_EXPORTS
00023 #  define NBFSAVER_API __declspec(dllexport)
00024 # else
00025 #  define NBFSAVER_API __declspec(dllimport)
00026 # endif
00027 #else
00028 # define NBFSAVER_API
00029 #endif
00030
00031 // exports required for a scene loader plug-in
00032 #if defined(LINUX)
00033 extern "C"
00034 {
00035 #endif
00036 NBFSAVER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00037 NBFSAVER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00038 #if defined(LINUX)
00039 }
00040 #endif
00041
00042
00056 class NBFSaveTraverser : public nvtraverser::SharedTraverser
00057 {
00058   public:
00060     NBFSaveTraverser();
00061
00066     void preCalculateFileSize( nvsg::SceneHandle * scene );
00067
00070     void setFileName( const std::string & fileName );
00071
00076     void setPlugInCallback( const nvutil::PlugInCallback * pic );
00077
00080     bool getSuccess() const;
00081
00082   protected:
00093     bool calculatingStorageRequirements() const;
00094
00105     uint_t alloc( void*& offsetPtr, unsigned int numBytes );
00106
00112     void dealloc( void * offsetPtr );
00113
00120     uint_t pseudoAlloc( unsigned int numBytes );
00121
00126     virtual void doApply( nvsg::NodeHandle * root );
00127
00131     virtual void handleParallelCamera( const nvsg::ParallelCamera *camera );
00132
00136     virtual void handlePerspectiveCamera( const nvsg::PerspectiveCamera *camera );
00137
00141     virtual void handleBillboard( const nvsg::Billboard *billboard );
00142
00146     virtual void handleGeoNode( const nvsg::GeoNode *gnode );
00147
00151     virtual void handleVolumeNode( const nvsg::VolumeNode *vnode );
00152
00156     virtual void handleGroup( const nvsg::Group *group );
00157
00161     virtual void handleFlipbookAnimation( const nvsg::FlipbookAnimation *anim );
00162
00166     virtual void handleTransform( const nvsg::Transform *trafo );
00167
00171     virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *trafo );
00172
00176     virtual void handleLOD( const nvsg::LOD *lod );
00177
00181     virtual void handleSwitch( const nvsg::Switch *swtch );
00182
00186     virtual void handleDirectedLight( const nvsg::DirectedLight *light );
00187
00191     virtual void handlePointLight( const nvsg::PointLight *light );
00192
00196     virtual void handleSpotLight( const nvsg::SpotLight *light );
00197
00201     virtual void handleStateSet( const nvsg::StateSet *stateSet );
00202
00206     virtual void handleStateVariant( const nvsg::StateVariant *variant );
00207
00211     virtual void handleStatePass( const nvsg::StatePass *pass );
00212
00216     virtual void handleAlphaTestAttribute( const nvsg::AlphaTestAttribute *alphaTestAttrib );
00217
00221     virtual void handleBlendAttribute( const nvsg::BlendAttribute *blendAttrib );
00222
00226     virtual void handleCgFx( const nvsg::CgFx *cgfx );
00227
00231     virtual void handleDepthAttribute( const nvsg::DepthAttribute *depthAttrib );
00232
00236     virtual void handleFaceAttribute( const nvsg::FaceAttribute *faceAttrib );
00237
00241     virtual void handleLightingAttribute( const nvsg::LightingAttribute *lightingAttrib );
00242
00246     virtual void handleLineAttribute( const nvsg::LineAttribute *lineAttrib );
00247
00251     virtual void handleMaterial( const nvsg::Material *material );
00252
00256     virtual void handlePointAttribute( const nvsg::PointAttribute *pointAttrib );
00257
00261     virtual void handleTextureAttribute( const nvsg::TextureAttribute *texAttrib );
00262
00267     virtual void handleTextureAttributeItem( const nvsg::TextureAttributeItem * texAttribItem
00268                                            , unsigned int tu);
00269
00273     virtual void handleTriangles( const nvsg::Triangles *triangles );
00274
00278     virtual void handleSkinnedTriangles( const nvsg::SkinnedTriangles *triangles );
00279
00283     virtual void handleTriFans( const nvsg::TriFans *fans );
00284
00288     virtual void handleTriStrips( const nvsg::TriStrips *strips );
00289
00293     virtual void handleQuadMeshes( const nvsg::QuadMeshes *meshes );
00294
00298     virtual void handleQuads( const nvsg::Quads *quads );
00299
00303     virtual void handleQuadStrips( const nvsg::QuadStrips *strips );
00304
00308     virtual void handleLines( const nvsg::Lines *lines );
00309
00313     virtual void handleLineStrips( const nvsg::LineStrips *strips );
00314
00318     virtual void handlePoints( const nvsg::Points *points );
00319
00323     virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *vas );
00324
00328     virtual void handleAnimatedVertexAttributeSet( const nvsg::AnimatedVertexAttributeSet *avas );
00329
00333     virtual void handleSkin( const nvsg::Skin *skin );
00334
00338     virtual void handleFramedIndexAnimation( const nvsg::FramedAnimation<unsigned int> *trafo );
00339
00343     virtual void handleFramedTrafoAnimation( const nvsg::FramedAnimation<nvmath::Trafo> *trafo );
00344
00348     virtual void handleFramedVertexAttributeAnimation( const nvsg::FramedAnimation<nvsg::VertexAttribute> *p );
00349
00353     virtual void handleLinearInterpolatedTrafoAnimation( const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> *trafo );
00354
00358     virtual void handleLinearInterpolatedVertexAttributeAnimation( const nvsg::LinearInterpolatedAnimation<nvsg::VertexAttribute> * p );
00359
00363     virtual void handleUnlitColorAttribute( const nvsg::UnlitColorAttribute *unlitColor );
00364
00365   private:
00366     struct Mapping
00367     {
00368       Mapping();
00369       ubyte_t       * basePtr;
00370       unsigned int    size;    // needed with linux's unmap call only
00371       int             refCnt;  // reflects if the view is in use or not
00372     };
00373
00375
00377     template<typename T>
00378     class Offset_AutoPtr
00379     {
00380       public:
00382
00384         Offset_AutoPtr( NBFSaveTraverser * svr, uint_t& fileOffset, unsigned int count=1 );
00385
00387
00389         Offset_AutoPtr( NBFSaveTraverser * svr );
00390
00392         ~Offset_AutoPtr();
00393
00395         T* operator->();
00396
00398         T& operator*();
00399
00401         operator T*();
00402
00404
00406         void alloc( uint_t& fileOffset, unsigned int count=1 );
00407
00408       private:
00409         T * m_ptr;
00410         NBFSaveTraverser * m_svr;
00411     };
00412
00413   private:
00414     // operator() to process a Scene (not part of the public interface!)
00415     // returns the file offset to the allocated and initialized NBFScene object
00416     // behavior is undefined if p is an invalid pointer
00417     uint_t handleScene(const nvsg::Scene *p);
00418     // operator() to process a ViewState (not part of the public interface!)
00419     // returns the file offset to the allocated and initialized NBFViewState object
00420     // behavior is undefined if p is an invalid pointer
00421     uint_t handleViewState(const nvsg::ViewState *p);
00422
00423     // write routines for non-concrete types
00424     template<typename T>
00425       void writeAnimation( const nvsg::Animation<T> *nvsgAnimPtr, NBFAnimation * nbfAnimPtr );
00426     // ... write tasks similar for all Objects
00427     void writeObject(const nvsg::Object* nvsgObjPtr, NBFObject * nbfObjPtr, uint_t objCode);
00428     // ... write task similar for Nodes
00429     void writeNode(const nvsg::Node* nvsgNodePtr, NBFNode * nbfNodePtr, uint_t objCode);
00430     // ... write task similar for Groups
00431     void writeGroup(const nvsg::Group * nvsgGrpPtr, NBFGroup * nbfGrpPtr, uint_t objCode);
00432     // ... write task similar for LightSources
00433     void writeLightSource(const nvsg::LightSource* nvsgLightSrcPtr, NBFLightSource * nbfLightSrcPtr, uint_t objCode);
00434     // ... write task similar for Cameras
00435     void writeCamera(const nvsg::Camera * nvsgCamPtr, NBFCamera * nbfCamPtr, uint_t objCode);
00436     // .. write faces
00437     template<typename NVSGFaceType, typename NBFFaceType>
00438     void writeIndices(const NVSGFaceType * nvsgFaces, NBFFaceType * nbfFaces);
00439     void writePrimitive( const nvsg::PrimitiveSet * nvsgPrimitive, NBFPrimitiveSet * nbfPrimitive, uint_t objCode );
00440     // .. write a single tweakable
00441     void writeTweak(const nvsg::CgFxEffect * effect, nvsg::CgFxParameter nvsgTweak, tweak_t * nbfTweak);
00442     // .. write a single sampler
00443     void writeSampler(const nvsg::CgFxEffect * effect, nvsg::CgFxParameter nvsgSampler, sampler_t * nbfSampler);
00444     // .. write a single texture image
00445     void writeTexImage(const std::string& file, const nvsg::TextureImage * nvsgImg, texImage_t * nbfImg);
00446     void writeVertexAttributeSet(const nvsg::VertexAttributeSet * nvsgVASPtr, NBFVertexAttributeSet * nbfVASPtr, uint_t objCode);
00447
00448     // shared objects processing
00449     bool processSharedObject(const nvsg::Object * obj, uint_t objCode);
00450
00451     // independents, meshes, and strips processing
00452     void processIndependentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p, uint_t objCode );
00453     void processMeshedPrimitiveSet( const nvsg::MeshedPrimitiveSet *p, uint_t objCode );
00454     void processStrippedPrimitiveSet( const nvsg::StrippedPrimitiveSet *p, uint_t objCode );
00455
00456     // map cnt * sizeof(Type) bytes from the mapped file
00457     template <typename Type>
00458     uint_t alloc(Type *& objPtr, unsigned int cnt=1);
00459
00460     // pseudo allocation routines for calculation of storage requirements
00461     void pseudoAllocObject(const nvsg::Object* p);
00462     void pseudoAllocNode(const nvsg::Node* p);
00463     void pseudoAllocGroup(const nvsg::Group * p);
00464     void pseudoAllocLightSource(const nvsg::LightSource * p);
00465     void pseudoAllocPrimitive(const nvsg::PrimitiveSet * p);
00466     void pseudoAllocCamera(const nvsg::Camera * p);
00467     void pseudoAllocTransform( const nvsg::Transform * p );
00468     void pseudoAllocTweak(const nvsg::CgFxEffect * effect, nvsg::CgFxParameter tweak);
00469     void pseudoAllocSampler(const nvsg::CgFxEffect * effect, nvsg::CgFxParameter sampler);
00470     void pseudoAllocTexImage(const std::string& file, const nvsg::TextureImage * img);
00471     void pseudoAllocVertexAttributeSet( const nvsg::VertexAttributeSet * vas );
00472     void pseudoAllocSkin( const nvsg::Skin * skin );
00473
00474     ubyte_t * mapOffset( uint_t offset, unsigned int numBytes );
00475     void unmapOffset( ubyte_t * offsetPtr );
00476
00477   private:
00478     bool                    m_calculateStorageRequirements; // pre-calculate what the file size would be
00479     unsigned int            m_preCalculatedFileSize; // required file size in bytes
00480     std::string             m_fileName;
00481     nvutil::WriteMapping  * m_fm;
00482     bool                    m_success;
00483     unsigned int            m_fileOffset; // actual file offset
00484
00485     std::map<nvsg::ObjectHandle *, uint_t> m_objectOffsetMap; // mapping NVSG objects to the corresponding offsets in file mapping
00486     std::map<nvsg::DataID, uint_t> m_objectDataIDOffsetMap; // mapping object IDs of shared objects to corresponding offsets
00487
00488     const nvutil::PlugInCallback  * m_pic;
00489     std::vector<nvsg::SkinHandle*>  m_skins;
00490 };
00491
00492 inline void NBFSaveTraverser::setFileName( const std::string & fileName )
00493 {
00494   m_fileName = fileName;
00495 }
00496
00497 inline void NBFSaveTraverser::setPlugInCallback( const nvutil::PlugInCallback * pic )
00498 {
00499   m_pic = pic;
00500 }
00501
00502 inline bool NBFSaveTraverser::getSuccess() const
00503 {
00504   return( m_success );
00505 }
00506
00508 class NBFSaver : public nvsg::SceneSaver
00509 {
00510 public :
00512   NBFSaver();
00513
00515
00516   void deleteThis( void );
00517
00519
00520   bool save( nvsg::SceneHandle *scene
00521            , nvsg::ViewStateHandle *viewState
00522            , const std::string& filename
00523            );
00524
00525 protected:
00526   virtual ~NBFSaver();
00527
00528 protected:
00529   NBFSaveTraverser * m_traverser;
00530 };
00531
00532
00533 inline void NBFSaver::deleteThis( void )
00534 {
00535   delete this;
00536 }
00537
00538 inline bool NBFSaveTraverser::calculatingStorageRequirements() const
00539 {
00540   return m_calculateStorageRequirements;
00541 }
00542
00543 inline NBFSaveTraverser::Mapping::Mapping()
00544 : refCnt(0)
00545 {}
00546
00547 template<typename T>
00548 inline NBFSaveTraverser::Offset_AutoPtr<T>::Offset_AutoPtr( NBFSaveTraverser * svr
00549                                                           , uint_t& fileOffset, unsigned int count )
00550 : m_ptr(NULL)
00551 , m_svr(svr)
00552 {
00553   NVSG_ASSERT(count != 0xCCCCCCCC);  // check for passing uninitialized variables
00554
00555   if ( count )
00556   {
00557     // call the void * version
00558     fileOffset = m_svr->alloc((void *&)m_ptr, count*sizeof(T));
00559   }
00560 }
00561
00562 template<typename T>
00563 inline NBFSaveTraverser::Offset_AutoPtr<T>::Offset_AutoPtr( NBFSaveTraverser * svr )
00564 : m_ptr(NULL)
00565 , m_svr(svr)
00566 {
00567 }
00568
00569 template<typename T>
00570 inline NBFSaveTraverser::Offset_AutoPtr<T>::~Offset_AutoPtr()
00571 {
00572   if ( m_ptr )
00573   {
00574     m_svr->dealloc(m_ptr);
00575   }
00576 }
00577
00578 template<typename T>
00579 inline T* NBFSaveTraverser::Offset_AutoPtr<T>::operator->()
00580 {
00581   NVSG_ASSERT(m_ptr);
00582   return m_ptr;
00583 }
00584
00585 template<typename T>
00586 inline T& NBFSaveTraverser::Offset_AutoPtr<T>::operator*()
00587 {
00588   NVSG_ASSERT(m_ptr);
00589   return *m_ptr;
00590 }
00591
00592 template<typename T>
00593 inline NBFSaveTraverser::Offset_AutoPtr<T>::operator T*()
00594 {
00595   NVSG_ASSERT(m_ptr);
00596   return m_ptr;
00597 }
00598
00599 template<typename T>
00600 inline void NBFSaveTraverser::Offset_AutoPtr<T>::alloc( uint_t& fileOffset, unsigned int count )
00601 {
00602   NVSG_ASSERT(m_ptr == NULL);
00603   NVSG_ASSERT(count != 0xCCCCCCCC);  // check for passing uninitialized variables
00604
00605   if ( count )
00606   {
00607     fileOffset = m_svr->alloc((void *&)m_ptr, count*sizeof(T));
00608   }
00609 }
00610
00611 inline ubyte_t * NBFSaveTraverser::mapOffset( uint_t offset, unsigned int numBytes )
00612 {
00613   NVSG_TRACE();
00614   NVSG_ASSERT( m_fm );
00615   return( (ubyte_t*) m_fm->mapIn( offset, numBytes ) );
00616 }
00617
00618 inline void NBFSaveTraverser::unmapOffset( ubyte_t * offsetPtr )
00619 {
00620   NVSG_TRACE();
00621   NVSG_ASSERT( m_fm );
00622   m_fm->mapOut( offsetPtr );
00623 }
00624
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NvApiError.h Source File

NvApiError.h

00001  /***************************************************************************\
00002 |*                                                                           *|
00003 |*      Copyright 1993-2005 NVIDIA Corporation.  All rights reserved.        *|
00004 |*                                                                           *|
00005 |*   NOTICE TO USER:                                                         *|
00006 |*                                                                           *|
00007 |*   This source code is subject to NVIDIA ownership rights under U.S.       *|
00008 |*   and international Copyright laws.  Users and possessors of this         *|
00009 |*   source code are hereby granted a nonexclusive, royalty-free             *|
00010 |*   license to use this code in individual and commercial software.         *|
00011 |*                                                                           *|
00012 |*   NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE     *|
00013 |*   CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR         *|
00014 |*   IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH      *|
00015 |*   REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF         *|
00016 |*   MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR          *|
00017 |*   PURPOSE. IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL,            *|
00018 |*   INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES          *|
00019 |*   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN      *|
00020 |*   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING     *|
00021 |*   OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOURCE      *|
00022 |*   CODE.                                                                   *|
00023 |*                                                                           *|
00024 |*   U.S. Government End Users. This source code is a "commercial item"      *|
00025 |*   as that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting       *|
00026 |*   of "commercial computer  software" and "commercial computer software    *|
00027 |*   documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995)   *|
00028 |*   and is provided to the U.S. Government only as a commercial end item.   *|
00029 |*   Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through        *|
00030 |*   227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the       *|
00031 |*   source code with only those rights set forth herein.                    *|
00032 |*                                                                           *|
00033 |*   Any use of this source code in individual and commercial software must  *|
00034 |*   include, in the user documentation and internal comments to the code,   *|
00035 |*   the above Disclaimer and U.S. Government End Users Notice.              *|
00036 |*                                                                           *|
00037 |*                                                                           *|
00038  \***************************************************************************/
00039
00040 #ifndef __NVAPIERROR_H__
00041 #define __NVAPIERROR_H__
00042
00043 #ifdef __cplusplus
00044     extern "C" {
00045 #endif
00046
00047 #ifndef NVAPIENTRY
00048 #   define NVAPIENTRY APIENTRY
00049 #endif//NVAPIENTRY
00050
00051 #define NVRESULT_SUCCESS(nr)    ((int)(nr) <= 0) // Success (NV_OK or NV_WARN_xxx)
00052 #define NVRESULT_FAILURE(nr)    ((int)(nr) >  0) // Failure
00053 #define NVRESULT_WARN(nr)       ((int)(nr) <  0) // Warning
00054
00055 #define NVRESULT_ERRORCODE(nr)  ((NVRESULT)(abs((int)nr))) // Extract error code from NVRESULT value (warning --> error)
00056
00057 typedef enum NVRESULT
00058 {
00059     NV_OK                   =   0,  // Success.
00060 //----------------------------------------------------------------------------
00061     NV_INTERNALERROR        =   1,  // Internal error.
00062     NV_ALREADYINITIALIZED   =   2,  // Already initialized.
00063     NV_NOTINITIALIZED       =   3,  // Not initialized.
00064     NV_OUTOFMEMORY          =   4,  // Not enough memory for operation.
00065     NV_NOTSUPPORTED         =   5,  // Feature not supported.
00066     NV_NOTAVAILABLE         =   6,  // Feature not presently available.
00067     NV_NOTIMPLEMENTED       =   7,  // Feature not implemented.
00068     NV_BADPARAMETER         =   8,  // Invalid parameter.
00069     NV_ACCESSDENIED         =   9,  // Access denied.
00070     NV_RUNNING              =  10,  // Operation requires inactive environment.
00071     NV_NOTRUNNING           =  11,  // Operation requires active environment.
00072     NV_FILENOTFOUND         =  12,  // Unable to locate file.
00073     NV_NOMORE               =  13,  // No more items.
00074     NV_ILLEGALSTATE         =  14,  // Illegal state could not be resolved.
00075     NV_NOTFOUND             =  15,  // Not found
00076     NV_ALLOCATED            =  16,  // Indicates that the request cannot be completed as the resource is already allocated/deallocated
00077     NV_BADPARAMETERSIZE     =  17,  // As mentioned by Satish, we require to give details of what bad parameter is
00078     NV_SET_ROTATE_3DAPP_ERR =  18,  // Unable to rotate as a 3D app is running
00079 //----------------------------------------------------------------------------
00080     NV_WARN_INTERNALERROR   =  -1,  // Internal warning.
00081     NV_WARN_ILLEGALSTATE    = -14,  // Illegal state was automatically resolved.
00082     NV_WARN_NOTEQUAL        = -15,  // State compare failed
00083     NV_WARN_NOMORE          = -16,  // Warning that state compare failed and there are no more to enum
00084     NV_WARN_ALREADYINITIALIZED = -17,//Warning that we are already initialized
00085     NV_WARN_ALLOCATED       = -18,  // Warning that this state is already allocation/deallocated
00086     NV_WARN_NOTINITIALIZED  = -19,  // Warning that the api is not initialized
00087 } NVRESULT;
00088
00089 NVRESULT NVAPIENTRY NvGetLastError();
00090 typedef NVRESULT (NVAPIENTRY* fNvGetLastError)();
00091
00092 LPCWSTR NVAPIENTRY NvGetLastErrorMessageW();
00093 LPCSTR NVAPIENTRY NvGetLastErrorMessageA();
00094 typedef LPCWSTR (NVAPIENTRY* fNvGetLastErrorMessageW)();
00095 typedef LPCSTR (NVAPIENTRY* fNvGetLastErrorMessageA)();
00096
00097 LPCWSTR NVAPIENTRY NvGetErrorMessageW(NVRESULT nr);
00098 LPCSTR NVAPIENTRY NvGetErrorMessageA(NVRESULT nr);
00099 typedef LPCWSTR (NVAPIENTRY* fNvGetErrorMessageW)(NVRESULT nr);
00100 typedef LPCSTR (NVAPIENTRY* fNvGetErrorMessageA)(NVRESULT nr);
00101
00102 #ifdef  UNICODE
00103 #   define NvGetLastErrorMessage NvGetLastErrorMessageW
00104 #   define NvGetErrorMessage NvGetLastMessageW
00105 #else
00106 #   define NvGetLastErrorMessage NvGetLastErrorMessageA
00107 #   define NvGetErrorMessage NvGetLastMessageA
00108 #endif//UNICODE
00109
00110 #ifdef __cplusplus
00111 } //extern "C" {
00112 #endif
00113
00114 #endif//__NVAPIERROR_H__
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvgl.h Source File

nvgl.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsgcommon.h"
00015
00016 #include <GL/gl.h>  // standard OpenGL header satisfying OpenGL 1.1 API
00017
00018 #include "GL/glext.h"   // OpenGL extensions
00019 #if defined(_WIN32)
00020 # include "GL/wglext.h" // Microsoft specific OpenGL extensions
00021 #elif defined(LINUX)
00022 # include "GL/glx.h"
00023 # include "GL/glxext.h" // GLX Extensions
00024 # include <pthread.h>
00025 #endif
00026
00027 #include "GL/gremedy.h"  // graphic remedy custom extension for gldebugger
00028
00029 // STL header
00030 #include <map>
00031 #include <set>
00032
00033 // GL error tracing macro
00034 #if !defined(NDEBUG) && !defined(NVSG_HYBRID)
00035 # define ASSERT_GL_NO_ERROR               NVSG_ASSERT( ( glError = glGetError() ) == GL_NO_ERROR )
00036 # define ASSERT_GL_NO_ERROR_IN_BEGIN_END  NVSG_ASSERT( glContext()->m_inBeginEndLoop || ( glError = glGetError() ) == GL_NO_ERROR )
00037 #else
00038 # define ASSERT_GL_NO_ERROR
00039 # define ASSERT_GL_NO_ERROR_IN_BEGIN_END
00040 #endif
00041
00043
00051 namespace nvgl
00052 {
00053   class GLContext;
00054
00055 #if defined(_WIN32)
00056   extern  NVSG_API DWORD glContextTlsIdx;
00057 #elif defined(LINUX)
00058   extern  NVSG_API pthread_key_t glContextKey;
00059 #else
00060 #error Unsupported Operating System!
00061 #endif
00062
00063 #if !defined(NDEBUG)
00064   extern  NVSG_API GLenum  glError;
00065 #endif
00066
00067   typedef std::set<GLuint> NameSet;
00068   typedef NameSet::const_iterator ConstNameSetIter;
00069 }
00070
00071
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


NvGvoApi.h Source File

NvGvoApi.h

00001  /***************************************************************************\
00002 |*                                                                           *|
00003 |*      Copyright 1993-2005 NVIDIA Corporation.  All rights reserved.        *|
00004 |*                                                                           *|
00005 |*   NOTICE TO USER:                                                         *|
00006 |*                                                                           *|
00007 |*   This source code is subject to NVIDIA ownership rights under U.S.       *|
00008 |*   and international Copyright laws.  Users and possessors of this         *|
00009 |*   source code are hereby granted a nonexclusive, royalty-free             *|
00010 |*   license to use this code in individual and commercial software.         *|
00011 |*                                                                           *|
00012 |*   NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE     *|
00013 |*   CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR         *|
00014 |*   IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH      *|
00015 |*   REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF         *|
00016 |*   MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR          *|
00017 |*   PURPOSE. IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL,            *|
00018 |*   INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES          *|
00019 |*   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN      *|
00020 |*   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING     *|
00021 |*   OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOURCE      *|
00022 |*   CODE.                                                                   *|
00023 |*                                                                           *|
00024 |*   U.S. Government End Users. This source code is a "commercial item"      *|
00025 |*   as that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting       *|
00026 |*   of "commercial computer  software" and "commercial computer software    *|
00027 |*   documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995)   *|
00028 |*   and is provided to the U.S. Government only as a commercial end item.   *|
00029 |*   Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through        *|
00030 |*   227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the       *|
00031 |*   source code with only those rights set forth herein.                    *|
00032 |*                                                                           *|
00033 |*   Any use of this source code in individual and commercial software must  *|
00034 |*   include, in the user documentation and internal comments to the code,   *|
00035 |*   the above Disclaimer and U.S. Government End Users Notice.              *|
00036 |*                                                                           *|
00037 |*                                                                           *|
00038  \***************************************************************************/
00039
00041 // NVGVOAPI.H
00042 //
00043 // Header file for NVGVOAPI.CPP - This header file implements the nv control panel
00044 // API for SDI
00045 //
00046 //  This file will be exposed to 3rd party developers
00047 //
00048 // Platforms/OS - Windows NT4, 9X, ME, 2K, XP
00049 //
00051
00052 #ifndef __NVGVOAPI_H__
00053 #define __NVGVOAPI_H__
00054
00055 //---------------------------------------------------------------------
00056 // NVIDIA Grapics to Video Out (GVO) API
00057 //---------------------------------------------------------------------
00058
00059 #ifdef  __cplusplus
00060     extern "C" {
00061 #endif//__cplusplus
00062
00063 #include "NvApiError.h"
00064
00065 #ifndef IN
00066 #   define IN
00067 #endif//IN
00068
00069 #ifndef OUT
00070 #   define OUT
00071 #endif//OUT
00072
00073 #ifndef INOUT
00074 #   define INOUT
00075 #endif//INOUT
00076
00077 #ifndef NVFLOAT
00078 typedef float NVFLOAT;
00079 #endif//NVFLOAT
00080
00081 #ifndef NVADAPTERNAME_MAXLEN
00082 #define NVADAPTERNAME_MAXLEN    256
00083 #endif//NVADAPTERNAME_MAXLEN
00084
00085 #ifndef NVVALUENAME_MAXLEN
00086 #define NVVALUENAME_MAXLEN      256
00087 #endif//NVVALUENAME_MAXLEN
00088
00089 //---------------------------------------------------------------------
00090 // Types
00091 //---------------------------------------------------------------------
00092
00093 typedef UINT NVGVOHANDLE;                                   // Handle from NvGvoOpen() or NvGvoDesktopOpen()
00094 #define INVALID_NVGVOHANDLE                 0               // Invalid NVGVOHANDLE
00095
00096 typedef DWORD NVGVOOWNERID;                                 // Unique identifier for owner of Graphics to Video output (process identifier or NVGVOOWNERID_NONE)
00097 #define NVGVOOWNERID_NONE                   0               // Unregistered ownerId
00098
00099 enum NVGVOOWNERTYPE                                         // Owner type for device
00100 {
00101     NVGVOOWNERTYPE_NONE                             ,       //  No owner for device
00102     NVGVOOWNERTYPE_OPENGL                           ,       //  OpenGL application owns device
00103     NVGVOOWNERTYPE_DESKTOP                          ,       //  Desktop transparent mode owns device
00104 };
00105
00106 // Access rights for NvGvoOpen() or NvGvoDesktopOpen()
00107 #define NVGVO_O_READ                        0x00000000      // Read access
00108 #define NVGVO_O_WRITE_EXCLUSIVE             0x00010001      // Write exclusive access
00109
00110 //---------------------------------------------------------------------
00111 // Enumerations
00112 //---------------------------------------------------------------------
00113
00114 // Video signal format and resolution
00115 enum NVGVOSIGNALFORMAT
00116 {
00117     NVGVOSIGNALFORMAT_ERROR = -1                    ,       // Invalid signal format
00118     NVGVOSIGNALFORMAT_487I_5994_SMPTE259_NTSC       ,       // 01  487i    59.94Hz  (SMPTE259) NTSC
00119     NVGVOSIGNALFORMAT_576I_5000_SMPTE259_PAL        ,       // 02  576i    50.00Hz  (SMPTE259) PAL
00120     NVGVOSIGNALFORMAT_720P_5994_SMPTE296            ,       // 03  720p    59.94Hz  (SMPTE296)
00121     NVGVOSIGNALFORMAT_720P_6000_SMPTE296            ,       // 04  720p    60.00Hz  (SMPTE296)
00122     NVGVOSIGNALFORMAT_1035I_5994_SMPTE260           ,       // 05  1035i   59.94Hz  (SMPTE260)
00123     NVGVOSIGNALFORMAT_1035I_6000_SMPTE260           ,       // 06  1035i   60.00Hz  (SMPTE260)
00124     NVGVOSIGNALFORMAT_1080I_5000_SMPTE295           ,       // 07  1080i   50.00Hz  (SMPTE295)
00125     NVGVOSIGNALFORMAT_1080I_5000_SMPTE274           ,       // 08  1080i   50.00Hz  (SMPTE274)
00126     NVGVOSIGNALFORMAT_1080I_5994_SMPTE274           ,       // 09  1080i   59.94Hz  (SMPTE274)
00127     NVGVOSIGNALFORMAT_1080I_6000_SMPTE274           ,       // 10  1080i   60.00Hz  (SMPTE274)
00128     NVGVOSIGNALFORMAT_1080PSF_23976_SMPTE274        ,       // 11  1080PsF 23.976Hz (SMPTE274)
00129     NVGVOSIGNALFORMAT_1080PSF_2400_SMPTE274         ,       // 12  1080PsF 24.00Hz  (SMPTE274)
00130     NVGVOSIGNALFORMAT_1080PSF_2500_SMPTE274         ,       // 13  1080PsF 25.00Hz  (SMPTE274)
00131     NVGVOSIGNALFORMAT_1080PSF_3000_SMPTE274         ,       // 14  1080PsF 30.00Hz  (SMPTE274)
00132     NVGVOSIGNALFORMAT_1080P_23976_SMPTE274          ,       // 15  1080p   23.976Hz (SMPTE274)
00133     NVGVOSIGNALFORMAT_1080P_2400_SMPTE274           ,       // 16  1080p   24.00Hz  (SMPTE274)
00134     NVGVOSIGNALFORMAT_1080P_2500_SMPTE274           ,       // 17  1080p   25.00Hz  (SMPTE274)
00135     NVGVOSIGNALFORMAT_1080P_2997_SMPTE274           ,       // 18  1080p   29.97Hz  (SMPTE274)
00136     NVGVOSIGNALFORMAT_1080P_3000_SMPTE274           ,       // 19  1080p   30.00Hz  (SMPTE274)
00137     NVGVOSIGNALFORMAT_1080PSF_2997_SMPTE274         ,       // 20  1080PsF 29.97Hz  (SMPTE274)
00138
00139     NVGVOSIGNALFORMAT_720P_5000_SMPTE296            ,       // 21  720p    50.00Hz  (SMPTE296)
00140     NVGVOSIGNALFORMAT_720P_3000_SMPTE296            ,       // 22  720p    30.00Hz  (SMPTE296)
00141     NVGVOSIGNALFORMAT_720P_2997_SMPTE296            ,       // 23  720p    29.97Hz  (SMPTE296)
00142     NVGVOSIGNALFORMAT_720P_2500_SMPTE296            ,       // 24  720p    25.00Hz  (SMPTE296)
00143     NVGVOSIGNALFORMAT_720P_2400_SMPTE296            ,       // 25  720p    24.00Hz  (SMPTE296)
00144     NVGVOSIGNALFORMAT_720P_2398_SMPTE296            ,       // 26  720p    23.98Hz  (SMPTE296)
00145
00146     NVGVOSIGNALFORMAT_1080I_4800_SMPTE274           ,       // 27  1080i   48.00Hz  (SMPTE296)
00147     NVGVOSIGNALFORMAT_1080I_4796_SMPTE274           ,       // 28  1080i   47.96Hz  (SMPTE296)
00148     NVGVOSIGNALFORMAT_1080PSF_2398_SMPTE274         ,       // 29  1080PsF 23.98Hz  (SMPTE296)
00149
00150     NVGVOSIGNALFORMAT_2048P_3000_SMPTE372           ,       // 30  2048P   30.00Hz  (SMPTE372)
00151     NVGVOSIGNALFORMAT_2048P_2997_SMPTE372           ,       // 31  2048P   29.97Hz  (SMPTE372)
00152     NVGVOSIGNALFORMAT_2048I_6000_SMPTE372           ,       // 32  2048I   60.00Hz  (SMPTE372)
00153     NVGVOSIGNALFORMAT_2048I_5994_SMPTE372           ,       // 33  2048I   59.94Hz  (SMPTE372)
00154     NVGVOSIGNALFORMAT_2048P_2500_SMPTE372           ,       // 34  2048P   25.00Hz  (SMPTE372)
00155     NVGVOSIGNALFORMAT_2048I_5000_SMPTE372           ,       // 35  2048I   50.00Hz  (SMPTE372)
00156     NVGVOSIGNALFORMAT_2048P_2400_SMPTE372           ,       // 36  2048P   24.00Hz  (SMPTE372)
00157     NVGVOSIGNALFORMAT_2048I_4800_SMPTE372           ,       // 37  2048I   48.00Hz  (SMPTE372)
00158     NVGVOSIGNALFORMAT_2048P_2398_SMPTE372           ,       // 38  2048P   23.98Hz  (SMPTE372)
00159     NVGVOSIGNALFORMAT_2048I_4796_SMPTE372           ,       // 39  2048I   23.98Hz  (SMPTE372)
00160
00161     NVGVOSIGNALFORMAT_END                                   // 40  To indicate end of signal format list
00162 };
00163
00164 // SMPTE standards format
00165 enum NVVIDEOSTANDARD
00166 {
00167     NVVIDEOSTANDARD_SMPTE259                        ,       // SMPTE259
00168     NVVIDEOSTANDARD_SMPTE260                        ,       // SMPTE260
00169     NVVIDEOSTANDARD_SMPTE274                        ,       // SMPTE274
00170     NVVIDEOSTANDARD_SMPTE295                        ,       // SMPTE295
00171     NVVIDEOSTANDARD_SMPTE296                        ,       // SMPTE296
00172     NVVIDEOSTANDARD_SMPTE372                        ,       // SMPTE372
00173 };
00174
00175 // HD or SD video type
00176 enum NVVIDEOTYPE
00177 {
00178     NVVIDEOTYPE_SD                                  ,       // Standard-definition (SD)
00179     NVVIDEOTYPE_HD                                  ,       // High-definition     (HD)
00180 };
00181
00182 // Interlace mode
00183 enum NVINTERLACEMODE
00184 {
00185     NVINTERLACEMODE_PROGRESSIVE                     ,       // Progressive               (p)
00186     NVINTERLACEMODE_INTERLACE                       ,       // Interlace                 (i)
00187     NVINTERLACEMODE_PSF                             ,       // Progressive Segment Frame (psf)
00188 };
00189
00190 // Video data format
00191 enum NVGVODATAFORMAT
00192 {
00193     NVGVODATAFORMAT_UNKNOWN = -1                    ,
00194     NVGVODATAFORMAT_R8G8B8_TO_YCRCB444              ,       // R8:G8:B8                => YCrCb  (4:4:4)
00195     NVGVODATAFORMAT_R8G8B8A8_TO_YCRCBA4444          ,       // R8:G8:B8:A8             => YCrCbA (4:4:4:4)
00196     NVGVODATAFORMAT_R8G8B8Z10_TO_YCRCBZ4444         ,       // R8:G8:B8:Z10            => YCrCbZ (4:4:4:4)
00197     NVGVODATAFORMAT_R8G8B8_TO_YCRCB422              ,       // R8:G8:B8                => YCrCb  (4:2:2)
00198     NVGVODATAFORMAT_R8G8B8A8_TO_YCRCBA4224          ,       // R8:G8:B8:A8             => YCrCbA (4:2:2:4)
00199     NVGVODATAFORMAT_R8G8B8Z10_TO_YCRCBZ4224         ,       // R8:G8:B8:Z10            => YCrCbZ (4:2:2:4)
00200     NVGVODATAFORMAT_R8G8B8_TO_RGB444                ,       // R8:G8:B8                => RGB    (4:4:4)
00201     NVGVODATAFORMAT_R8G8B8A8_TO_RGBA4444            ,       // R8:G8:B8:A8             => RGBA   (4:4:4:4)
00202     NVGVODATAFORMAT_R8G8B8Z10_TO_RGBZ4444           ,       // R8:G8:B8:Z10            => RGBZ   (4:4:4:4)
00203     NVGVODATAFORMAT_Y10CR10CB10_TO_YCRCB444         ,       // Y10:CR10:CB10           => YCrCb  (4:4:4)
00204     NVGVODATAFORMAT_Y10CR8CB8_TO_YCRCB444           ,       // Y10:CR8:CB8             => YCrCb  (4:4:4)
00205     NVGVODATAFORMAT_Y10CR8CB8A10_TO_YCRCBA4444      ,       // Y10:CR8:CB8:A10         => YCrCbA (4:4:4:4)
00206     NVGVODATAFORMAT_Y10CR8CB8Z10_TO_YCRCBZ4444      ,       // Y10:CR8:CB8:Z10         => YCrCbZ (4:4:4:4)
00207     NVGVODATAFORMAT_DUAL_R8G8B8_TO_DUAL_YCRCB422    ,       // R8:G8:B8 + R8:G8:B8     => YCrCb  (4:2:2 + 4:2:2)
00208     NVGVODATAFORMAT_DUAL_Y8CR8CB8_TO_DUAL_YCRCB422  ,       // Y8:CR8:CB8 + Y8:CR8:CB8 => YCrCb  (4:2:2 + 4:2:2)
00209     NVGVODATAFORMAT_R10G10B10_TO_YCRCB422           ,       // R10:G10:B10             => YCrCb  (4:2:2)
00210     NVGVODATAFORMAT_R10G10B10_TO_YCRCB444           ,       // R10:G10:B10             => YCrCb  (4:4:4)
00211     NVGVODATAFORMAT_Y12CR12CB12_TO_YCRCB444         ,       // Y12:CR12:CB12           => YCrCb  (4:4:4)
00212     NVGVODATAFORMAT_Y12CR12CB12_TO_YCRCB422         ,       // Y12:CR12:CB12           => YCrCb  (4:2:2)
00213     NVGVODATAFORMAT_Y10CR10CB10_TO_YCRCB422         ,       // Y10:CR10:CB10           => YCrCb  (4:2:2)
00214     NVGVODATAFORMAT_Y8CR8CB8_TO_YCRCB422            ,       // Y8:CR8:CB8              => YCrCb  (4:2:2)
00215     NVGVODATAFORMAT_Y10CR8CB8A10_TO_YCRCBA4224      ,       // Y10:CR8:CB8:A10         => YCrCbA (4:2:2:4)
00216     NVGVODATAFORMAT_R10G10B10_TO_RGB444             ,       // R10:G10:B10             => RGB    (4:4:4)
00217     NVGVODATAFORMAT_R12G12B12_TO_RGB444             ,       // R12:G12:B12             => RGB    (4:4:4)
00218 };
00219
00220 // Video output area
00221 enum NVGVOOUTPUTAREA
00222 {
00223     NVGVOOUTPUTAREA_FULLSIZE                        ,       // Output to entire video resolution (full size)
00224     NVGVOOUTPUTAREA_SAFEACTION                      ,       // Output to centered 90% of video resolution (safe action)
00225     NVGVOOUTPUTAREA_SAFETITLE                       ,       // Output to centered 80% of video resolution (safe title)
00226 };
00227
00228 // Synchronization source
00229 enum NVGVOSYNCSOURCE
00230 {
00231     NVGVOSYNCSOURCE_SDISYNC                         ,       // SDI Sync  (Digital input)
00232     NVGVOSYNCSOURCE_COMPSYNC                        ,       // COMP Sync (Composite input)
00233 };
00234
00235 // Composite synchronization type
00236 enum NVGVOCOMPSYNCTYPE
00237 {
00238     NVGVOCOMPSYNCTYPE_AUTO                          ,       // Auto-detect
00239     NVGVOCOMPSYNCTYPE_BILEVEL                       ,       // Bi-level signal
00240     NVGVOCOMPSYNCTYPE_TRILEVEL                      ,       // Tri-level signal
00241 };
00242
00243 // Video output status
00244 enum NVGVOOUTPUTSTATUS
00245 {
00246     NVGVOOUTPUTSTATUS_OFF                           ,       // Output not in use
00247     NVGVOOUTPUTSTATUS_ERROR                         ,       // Error detected
00248     NVGVOOUTPUTSTATUS_SDI_SD                        ,       // SDI output (standard-definition)
00249     NVGVOOUTPUTSTATUS_SDI_HD                        ,       // SDI output (high-definition)
00250 };
00251
00252 // Synchronization input status
00253 enum NVGVOSYNCSTATUS
00254 {
00255     NVGVOSYNCSTATUS_OFF                             ,       // Sync not detected
00256     NVGVOSYNCSTATUS_ERROR                           ,       // Error detected
00257     NVGVOSYNCSTATUS_SYNCLOSS                        ,       // Genlock in use, format mismatch with output
00258     NVGVOSYNCSTATUS_COMPOSITE                       ,       // Composite sync
00259     NVGVOSYNCSTATUS_SDI_SD                          ,       // SDI sync (standard-definition)
00260     NVGVOSYNCSTATUS_SDI_HD                          ,       // SDI sync (high-definition)
00261 };
00262
00263 //---------------------------------------------------------------------
00264 // Structures
00265 //---------------------------------------------------------------------
00266
00267 #define NVGVOCAPS_VIDOUT_SDI                0x00000001      // Supports Serial Digital Interface (SDI) output
00268 #define NVGVOCAPS_SYNC_INTERNAL             0x00000100      // Supports Internal timing source
00269 #define NVGVOCAPS_SYNC_GENLOCK              0x00000200      // Supports Genlock timing source
00270 #define NVGVOCAPS_SYNCSRC_SDI               0x00001000      // Supports Serial Digital Interface (SDI) synchronization input
00271 #define NVGVOCAPS_SYNCSRC_COMP              0x00002000      // Supports Composite synchronization input
00272 #define NVGVOCAPS_OUTPUTMODE_DESKTOP        0x00010000      // Supports Desktop transparent mode
00273 #define NVGVOCAPS_OUTPUTMODE_OPENGL         0x00020000      // Supports OpenGL application mode
00274
00275 #define NVGVOCLASS_SDI                      0x00000001      // SDI-class interface: SDI output with two genlock inputs
00276
00277
00278 struct  NVGVODRIVER
00279 {                                                           // Driver version
00280     WORD    wMajorVersion;                                  //  Major version
00281     WORD    wMinorVersion;                                  //  Minor version
00282     WORD    wRevision;                                      //  Revision
00283     WORD    wBuild;                                         //  Build
00284 };
00285
00286 struct  NVGVOFIRMWARE
00287 {                                                       // Firmware version
00288     WORD          wMajorVersion;                        //  Major version
00289     WORD          wMinorVersion;                        //  Minor version
00290 };
00291
00292 // Device capabilities
00293 struct  NVGVOCAPS
00294 {
00295     WORD              cbSize;                               // Caller sets to sizeof(NVGVOCAPS)
00296     char              szAdapterName[NVADAPTERNAME_MAXLEN];  // Graphics adapter name
00297     DWORD             dwClass;                              // Graphics adapter classes (NGVOCLASS_* mask)
00298     DWORD             dwCaps;                               // Graphics adapter capabilities (NVGVOCAPS_* mask)
00299     DWORD             dwDipSwitch;                          // On-board DIP switch settings bits
00300     DWORD             dwDipSwitchReserved;                  // On-board DIP switch settings reserved bits
00301
00302     NVGVODRIVER       Driver;                               //
00303     NVGVOFIRMWARE     Firmware;                             //
00304
00305     NVGVOOWNERID      ownerId;                              // Unique identifier for owner of video output (NVGVOOWNERID_NONE if free running)
00306     NVGVOOWNERTYPE    ownerType;                            // Owner type for video output (OpenGL application or Desktop mode)
00307 };
00308
00309 // Device status
00310 struct  NVGVOSTATUS
00311 {
00312     WORD              cbSize;                               // Caller sets to sizeof(NVGVOSTATUS)
00313     NVGVOOUTPUTSTATUS vid1Out;                              // Video 1 output status
00314     NVGVOOUTPUTSTATUS vid2Out;                              // Video 2 output status
00315     NVGVOSYNCSTATUS   sdiSyncIn;                            // SDI sync input status
00316     NVGVOSYNCSTATUS   compSyncIn;                           // Composite sync input status
00317     BOOL              syncEnable;                           // Sync enable (TRUE if using syncSource)
00318     NVGVOSYNCSOURCE   syncSource;                           // Sync source
00319     NVGVOSIGNALFORMAT syncFormat;                           // Sync format
00320     NVGVOOWNERID      ownerId;                              // Unique identifier for owner of video output
00321     NVGVOOWNERTYPE    ownerType;                            // Owner type for video output (OpenGL application or Desktop mode)
00322     BOOL              bframeLockEnable;                     // Framelock enable flag
00323     BOOL              bOutputVideoLocked;                   // Output locked status
00324     int               nDataIntegrityCheckErrorCount;        // Data integrity check error count
00325     BOOL              bDataIntegrityCheckEnabled;           // Data integrity check status enabled
00326     BOOL              bDataIntegrityCheckFailed;            // Data integrity check status failed
00327 };
00328
00329
00330 // Output region
00331 struct NVGVOOUTPUTREGION
00332 {
00333     WORD              x;                                    // Horizontal origin in pixels
00334     WORD              y;                                    // Vertical origin in pixels
00335     WORD              width;                                // Width of region in pixels
00336     WORD              height;                               // Height of region in pixels
00337 };
00338
00339 // Gamma ramp (8-bit index)
00340 typedef struct tagNVGAMMARAMP8
00341 {
00342     WORD              cbSize;                               // Caller sets to sizeof(NVGAMMARAMP8)
00343     WORD              wRed[256];                            // Red channel gamma ramp (8-bit index, 16-bit values)
00344     WORD              wGreen[256];                          // Green channel gamma ramp (8-bit index, 16-bit values)
00345     WORD              wBlue[256];                           // Blue channel gamma ramp (8-bit index, 16-bit values)
00346 } NVGAMMARAMP8;
00347
00348 // Gamma ramp (10-bit index)
00349 typedef struct tagNVGAMMARAMP10
00350 {
00351     WORD              cbSize;                               // Caller sets to sizeof(NVGAMMARAMP10)
00352     WORD              wRed[1024];                           // Red channel gamma ramp (10-bit index, 16-bit values)
00353     WORD              wGreen[1024];                         // Green channel gamma ramp (10-bit index, 16-bit values)
00354     WORD              wBlue[1024];                          // Blue channel gamma ramp (10-bit index, 16-bit values)
00355 } NVGAMMARAMP10;
00356
00357
00358 // Sync delay
00359 typedef struct tagNVGVOSYNCDELAY
00360 {
00361     WORD              wHorizontalDelay;                     // Horizontal delay in pixels
00362     WORD              wVerticalDelay;                       // Vertical delay in lines
00363 } NVGVOSYNCDELAY;
00364
00365
00366 // Video mode information
00367 struct  NVVIDEOMODE
00368 {
00369     DWORD             dwHorizontalPixels;                   // Horizontal resolution (in pixels)
00370     DWORD             dwVerticalLines;                      // Vertical resolution for frame (in lines)
00371     NVFLOAT           fFrameRate;                           // Frame rate
00372     NVINTERLACEMODE   interlaceMode;                        // Interlace mode
00373     NVVIDEOSTANDARD   videoStandard;                        // SMPTE standards format
00374     NVVIDEOTYPE       videoType;                            // HD or SD signal classification
00375 };
00376
00377
00378 // Signal format details
00379 struct  NVGVOSIGNALFORMATDETAIL
00380 {
00381     WORD              cbSize;                               // Caller sets to sizeof(NVGVOSIGNALFORMATDETAIL)
00382     NVGVOSIGNALFORMAT signalFormat;                         // Signal format enumerated value
00383     char              szValueName[NVVALUENAME_MAXLEN];      // Signal format name, in the form:
00384                                                             //  <name>\t<rate>\tHz\t(<standard>)[\t<description>]
00385                                                             //  "480i\t59.94\tHz\t(SMPTE259)\tNTSC"
00386                                                             //  "1080i\t50.00\tHz\t(SMPTE274)"
00387     char              szAlternateName[NVVALUENAME_MAXLEN];  // Signal format alternate name (or empty string):
00388                                                             //  "1080PsF\t25.00\tHz\t(SMPTE274)"
00389     NVVIDEOMODE       videoMode;                            // Video mode for signal format
00390 };
00391
00392
00393 // P-buffer formats
00394 #define NVGVOPBUFFERFORMAT_R8G8B8                  0x00000001   // R8:G8:B8
00395 #define NVGVOPBUFFERFORMAT_R8G8B8Z24               0x00000002   // R8:G8:B8:Z24
00396 #define NVGVOPBUFFERFORMAT_R8G8B8A8                0x00000004   // R8:G8:B8:A8
00397 #define NVGVOPBUFFERFORMAT_R8G8B8A8Z24             0x00000008   // R8:G8:B8:A8:Z24
00398 #define NVGVOPBUFFERFORMAT_R16FPG16FPB16FP         0x00000010   // R16FP:G16FP:B16FP
00399 #define NVGVOPBUFFERFORMAT_R16FPG16FPB16FPZ24      0x00000020   // R16FP:G16FP:B16FP:Z24
00400 #define NVGVOPBUFFERFORMAT_R16FPG16FPB16FPA16FP    0x00000040   // R16FP:G16FP:B16FP:A16FP
00401 #define NVGVOPBUFFERFORMAT_R16FPG16FPB16FPA16FPZ24 0x00000080   // R16FP:G16FP:B16FP:A16FP:Z24
00402
00403 // Data format details
00404 struct  NVGVODATAFORMATDETAIL
00405 {
00406     WORD              cbSize;                               // Caller sets to sizeof(NVGVODATAFORMATDETAIL)
00407     NVGVODATAFORMAT   dataFormat;                           // Data format enumerated value
00408     DWORD             dwCaps;                               // Data format capabilities (NVGVOCAPS_* mask)
00409
00410     struct
00411     {
00412         DWORD         dwPbufferFormats;                     // Supported p-buffer formats (NVGVOPBUFFERFORMAT_* mask)
00413         DWORD         dwPbufferCount;                       // Number of p-buffers
00414         char          szValueName[NVVALUENAME_MAXLEN];      // Data format input name, in the form:
00415                                                             //  <name>
00416                                                             //  "R8:G8:B8:A8"
00417     } in;
00418
00419     struct
00420     {
00421         char          szValueName[NVVALUENAME_MAXLEN];      // Data format output name, in the form:
00422                                                             //  <name>\t<format>
00423                                                             //  "YCrCbA\t(4:2:2:4)"
00424     } out;
00425 };
00426
00427 // Device configuration (dwFields masks indicating NVGVOCONFIG fields to use for NvGvoGet/Set/Test/CreateDefaultConfig())
00428 #define NVGVOCONFIG_SIGNALFORMAT            0x00000001      // dwFields: signalFormat
00429 #define NVGVOCONFIG_DATAFORMAT              0x00000002      // dwFields: dataFormat
00430 #define NVGVOCONFIG_OUTPUTREGION            0x00000004      // dwFields: outputRegion
00431 #define NVGVOCONFIG_OUTPUTAREA              0x00000008      // dwFields: outputArea
00432 #define NVGVOCONFIG_COLORCONVERSION         0x00000010      // dwFields: colorConversion
00433 #define NVGVOCONFIG_GAMMACORRECTION         0x00000020      // dwFields: gammaCorrection
00434 #define NVGVOCONFIG_SYNCSOURCEENABLE        0x00000040      // dwFields: syncSource and syncEnable
00435 #define NVGVOCONFIG_SYNCDELAY               0x00000080      // dwFields: syncDelay
00436 #define NVGVOCONFIG_COMPOSITESYNCTYPE       0x00000100      // dwFields: compositeSyncType
00437 #define NVGVOCONFIG_FRAMELOCKENABLE         0x00000200      // dwFields: EnableFramelock
00438 #define NVGVOCONFIG_422FILTER               0x00000400      // dwFields: bEnable422Filter
00439 #define NVGVOCONFIG_COMPOSITETERMINATE      0x00000800      // dwFields: bCompositeTerminate
00440 #define NVGVOCONFIG_DATAINTEGRITYCHECK      0x00001000      // dwFields: bEnableDataIntegrityCheck
00441 #define NVGVOCONFIG_CSCOVERRIDE             0x00002000      // dwFields: colorConversion override
00442 #define NVGVOCONFIG_FLIPQUEUELENGTH         0x00004000      // dwFields: flipqueuelength control
00443
00444 // Don't forget to update NVGVOCONFIG_VALIDFIELDS in NvGvoApiInternals.h when NVGVOCONFIG_ALLFIELDS changes.
00445 #define NVGVOCONFIG_ALLFIELDS   ( NVGVOCONFIG_SIGNALFORMAT          | \
00446                                   NVGVOCONFIG_DATAFORMAT            | \
00447                                   NVGVOCONFIG_OUTPUTREGION          | \
00448                                   NVGVOCONFIG_OUTPUTAREA            | \
00449                                   NVGVOCONFIG_COLORCONVERSION       | \
00450                                   NVGVOCONFIG_GAMMACORRECTION       | \
00451                                   NVGVOCONFIG_SYNCSOURCEENABLE      | \
00452                                   NVGVOCONFIG_SYNCDELAY             | \
00453                                   NVGVOCONFIG_COMPOSITESYNCTYPE     | \
00454                                   NVGVOCONFIG_FRAMELOCKENABLE       | \
00455                                   NVGVOCONFIG_422FILTER             | \
00456                                   NVGVOCONFIG_COMPOSITETERMINATE    | \
00457                                   NVGVOCONFIG_DATAINTEGRITYCHECK    | \
00458                                   NVGVOCONFIG_CSCOVERRIDE           | \
00459                                   NVGVOCONFIG_FLIPQUEUELENGTH)
00460
00461 // Device configuration
00462 // No members can be deleted from below structure. Only add new members at the
00463 // end of the structure
00464 // Below structure is released in rel90. Any more field added after  rel95 should
00465 // put in version control before that version is releasing.
00466
00467 struct  NVGVOCOLORCONVERSION                                // Color conversion:
00468 {                                                           //
00469     NVFLOAT       colorMatrix[3][3];                        //  Output[n] =
00470     NVFLOAT       colorOffset[3];                           //      Input[0] * colorMatrix[n][0] +
00471     NVFLOAT       colorScale[3];                            //      Input[1] * colorMatrix[n][1] +
00472                                                             //      Input[2] * colorMatrix[n][2] +
00473                                                             //      OutputRange * colorOffset[n]
00474                                                             //    where OutputRange is the standard magnitude of
00475                                                             //     Output[n][n] and colorMatrix and colorOffset
00476                                                             //     values are within the range -1.0 to +1.0
00477     BOOL          bCompositeSafe;                           // bCompositeSafe constrains luminance range when using composite output
00478 };
00479
00480 typedef struct tagNVGVOCONFIG
00481 {
00482     WORD              cbSize;                               // Caller sets to sizeof(NVGVOCONFIG)
00483     DWORD             dwFields;                             // Caller sets to NVGVOCONFIG_* mask for fields to use
00484
00485     NVGVOSIGNALFORMAT signalFormat;                         // Signal format for video output
00486     NVGVODATAFORMAT   dataFormat;                           // Data format for video output
00487     NVGVOOUTPUTREGION outputRegion;                         // Region for video output (Desktop mode)
00488     NVGVOOUTPUTAREA   outputArea;                           // Usable resolution for video output (safe area)
00489     NVGVOCOLORCONVERSION  colorConversion;                  // Color conversion.
00490
00491     union                                                   // Gamma correction:
00492     {                                                       //  cbSize field in gammaRamp describes type
00493         NVGAMMARAMP8  gammaRamp8;                           //  Gamma ramp (8-bit index, 16-bit values)
00494         NVGAMMARAMP10 gammaRamp10;                          //  Gamma ramp (10-bit index, 16-bit values)
00495     } gammaCorrection;
00496
00497     BOOL              syncEnable;                           // Sync enable (TRUE to use syncSource)
00498     NVGVOSYNCSOURCE   syncSource;                           // Sync source
00499     NVGVOSYNCDELAY    syncDelay;                            // Sync delay
00500     NVGVOCOMPSYNCTYPE compositeSyncType;                    // Composite sync type
00501     BOOL              frameLockEnable;                      // Flag indicating whether framelock was on/off
00502     double            fGammaValueR;                         // Red Gamma value within gamma ranges. 0.5 - 6.0
00503     double            fGammaValueG;                         // Green Gamma value within gamma ranges. 0.5 - 6.0
00504     double            fGammaValueB;                         // Blue Gamma value within gamma ranges. 0.5 - 6.0
00505     BOOL              bPSFSignalFormat;                     // Inidcates whether contained format is PSF Signal format
00506     BOOL              bEnable422Filter;                     // Enables/Disables 4:2:2 filter
00507     BOOL              bCompositeTerminate;                  // Composite termination
00508     BOOL              bEnableDataIntegrityCheck;            // Enable data integrity check: true - enable, false - disable
00509     BOOL              bCSCOverride;                         // Use provided CSC color matrix to overwrite
00510     DWORD             dwFlipQueueLength;                    // Number of buffers used for the internal flipqueue used in pbuffer mode
00511     DWORD             dwPadding;                            // Number of bytes to pad the data so that the size of newly added data
00512                                                             // elements exceeds structure alignment before dwFlipQueueLength was added
00513                                                             // into the structure
00514     BYTE              reservedData[256];                    // Inicates last stored SDI output state TRUE-ON / FALSE-OFF
00515 } NVGVOCONFIG;
00516
00517 //---------------------------------------------------------------------
00518 // Prototypes
00519 //---------------------------------------------------------------------
00520
00521 //---------------------------------------------------------------------
00522 // Function:    NvGvoCaps
00523 // Description: Determine graphics adapter Graphics to Video capabilities.
00524 // Parameters:  nAdapterNumber  - Graphics adapter number
00525 //              nReserved       - Reserved (must be set to zero)
00526 //              pAdapterCaps    - Pointer to receive capabilities
00527 // Returns:     NV_OK           - Success
00528 //              NV_NOTSUPPORTED - Graphics to Video not supported
00529 //---------------------------------------------------------------------
00530 NVRESULT NVAPIENTRY  NvGvoCaps( UINT       nAdapterNumber IN,
00531                                 UINT       nReserved      IN,
00532                                 NVGVOCAPS* pAdapterCaps   OUT );
00533
00534 //---------------------------------------------------------------------
00535 // Function:    NvGvoOpen
00536 // Description: Open graphics adapter for Graphics to Video operations
00537 //              using the OpenGL application interface.  Read operations
00538 //              are permitted in this mode by multiple clients, but Write
00539 //              operations are application exclusive.
00540 // Parameters:  nAdapterNumber  - Graphics adapter number
00541 //              nReserved       - Reserved (must be set to zero)
00542 //              dwClass         - Class interface (NVGVOCLASS_* value)
00543 //              dwAccessRights  - Access rights (NVGVO_O_* mask)
00544 //              phGvoHandle     - Pointer to receive handle
00545 // Returns:     NV_OK           - Success
00546 //              NV_ACCESSDENIED - Access denied for requested access
00547 //---------------------------------------------------------------------
00548 NVRESULT NVAPIENTRY NvGvoOpen( UINT                  nAdapterNumber IN,
00549                                UINT                  nReserved      IN,
00550                                DWORD                 dwClass        IN,
00551                                DWORD                 dwAccessRights IN,
00552                                NVGVOHANDLE*          phGvoHandle    OUT );
00553
00554 //---------------------------------------------------------------------
00555 // Function:    NvGvoClose
00556 // Description: Closes graphics adapter for Graphics to Video operations
00557 //              using the OpenGL application interface.  Closing an
00558 //              OpenGL handle releases the device.
00559 // Parameters:  hGvoHandle - Handle to graphics adapter
00560 // Returns:     NV_OK      - Success
00561 //---------------------------------------------------------------------
00562 NVRESULT NVAPIENTRY NvGvoClose( NVGVOHANDLE hGvoHandle IN );
00563
00564 //---------------------------------------------------------------------
00565 // Function:    NvGvoDesktopOpen
00566 // Description: Open graphics adapter for Graphics to Video operations
00567 //              using the Desktop transparent mode interface.  Read
00568 //              operations are permitted in this mode by multiple clients,
00569 //              but write operations are application exclusive.
00570 // Parameters:  nAdapterNumber  - Graphics adapter number
00571 //              nReserved       - Reserved (must be set to zero)
00572 //              dwClass         - Class interface (NVGVOCLASS_* value)
00573 //              dwAccessRights  - Access rights (NVGVO_O_* mask)
00574 //              phGvoHandle     - Pointer to receive handle
00575 // Returns:     NV_OK           - Success
00576 //              NV_ACCESSDENIED - Access denied for requested access
00577 //---------------------------------------------------------------------
00578 NVRESULT NVAPIENTRY NvGvoDesktopOpen( UINT                  nAdapterNumber IN,
00579                                       UINT                  nReserved      IN,
00580                                       DWORD                 dwClass        IN,
00581                                       DWORD                 dwAccessRights IN,
00582                                       NVGVOHANDLE*          phGvoHandle    OUT );
00583
00584 //---------------------------------------------------------------------
00585 // Function:    NvGvoDesktopClose
00586 // Description: Closes graphics adapter for Graphics to Video operations
00587 //              using the Desktop transparent mode interface.
00588 // Parameters:  hGvoHandle  - Handle to graphics adapter
00589 //              bGvoRelease - TRUE to release device when handle closes
00590 //                            FALSE to remain in desktop mode when handle
00591 //                                  closes (other clients can open using
00592 //                                  NvGvoDesktopOpen and release using
00593 //                                  NvGvoDesktopClose)
00594 // Returns:     NV_OK       - Success
00595 //---------------------------------------------------------------------
00596 NVRESULT NVAPIENTRY NvGvoDesktopClose( NVGVOHANDLE hGvoHandle IN,
00597                                        BOOL        bRelease   IN );
00598
00599 //---------------------------------------------------------------------
00600 // Function:    NvGvoStatus
00601 // Description: Get Graphics to Video status.
00602 // Parameters:  hGvoHandle - Handle to graphics adapter
00603 // Returns:     NV_OK      - Success
00604 //---------------------------------------------------------------------
00605 NVRESULT NVAPIENTRY NvGvoStatus( NVGVOHANDLE  hGvoHandle IN,
00606                                  NVGVOSTATUS* pStatus    OUT );
00607
00608 //---------------------------------------------------------------------
00609 // Function:    NvGvoSyncFormatDetect
00610 // Description: Detects Graphics to Video incoming sync video format.
00611 // Parameters:  hGvoHandle - Handle to graphics adapter
00612 //              pdwWait    - Pointer to receive milliseconds to wait
00613 //                           before NvGvoStatus will return detected
00614 //                           syncFormat.
00615 // Returns:     NV_OK - Success
00616 //---------------------------------------------------------------------
00617 NVRESULT NVAPIENTRY NvGvoSyncFormatDetect( NVGVOHANDLE hGvoHandle IN,
00618                                            DWORD*      pdwWait    OUT );
00619
00620 //---------------------------------------------------------------------
00621 // Function:    NvGvoConfigGet
00622 // Description: Get Graphics to Video configuration.
00623 // Parameters:  hGvoHandle - Handle to graphics adapter
00624 //              pConfig    - Pointer to Graphics to Video configuration
00625 // Returns:     NV_OK      - Success
00626 //---------------------------------------------------------------------
00627 NVRESULT NVAPIENTRY NvGvoConfigGet( NVGVOHANDLE  hGvoHandle IN,
00628                                     NVGVOCONFIG* pConfig    OUT );
00629
00630 //---------------------------------------------------------------------
00631 // Function:    NvGvoConfigSet
00632 // Description: Set Graphics to Video configuration.
00633 // Parameters:  hGvoHandle      - Handle to graphics adapter
00634 //              pConfig         - Pointer to Graphics to Video config
00635 // Returns:     NV_OK           - Success
00636 //              NV_ACCESSDENIED - Access denied (no write access)
00637 //              NV_RUNNING      - Requested settings require NvGvoStop
00638 //---------------------------------------------------------------------
00639 NVRESULT NVAPIENTRY NvGvoConfigSet( NVGVOHANDLE  hGvoHandle IN,
00640                                     NVGVOCONFIG* pConfig    IN );
00641
00642 //---------------------------------------------------------------------
00643 // Function:    NvGvoIsRunning
00644 // Description: Determine if Graphics to Video output is running.
00645 // Parameters:  hGvoHandle      - Handle to graphics adapter
00646 // Returns:     NV_RUNNING      - Graphics to Video running
00647 //              NV_NOTRUNNING   - Graphics to Video not running
00648 //---------------------------------------------------------------------
00649 NVRESULT NVAPIENTRY NvGvoIsRunning( NVGVOHANDLE hGvoHandle IN );
00650
00651 //---------------------------------------------------------------------
00652 // Function:    NvGvoStart
00653 // Description: Start Graphics to Video output.
00654 // Parameters:  hGvoHandle      - Handle to graphics adapter
00655 // Returns:     NV_OK           - Success
00656 //              NV_ACCESSDENIED - Access denied (no write access)
00657 //              NV_RUNNING      - Graphics to Video already running
00658 //---------------------------------------------------------------------
00659 NVRESULT NVAPIENTRY NvGvoStart( NVGVOHANDLE hGvoHandle IN );
00660
00661 //---------------------------------------------------------------------
00662 // Function:    NvGvoStop
00663 // Description: Stop Graphics to Video output.
00664 // Parameters:  hGvoHandle      - Handle to graphics adapter
00665 // Returns:     NV_OK           - Success
00666 //              NV_ACCESSDENIED - Access denied (no write access)
00667 //              NV_NOTRUNNING   - Graphics to Video not running
00668 //---------------------------------------------------------------------
00669 NVRESULT NVAPIENTRY NvGvoStop( NVGVOHANDLE hGvoHandle IN );
00670
00671 //---------------------------------------------------------------------
00672 // Function:    NvGvoEnumSignalFormats
00673 // Description: Enumerate signal formats supported by Graphics to Video.
00674 // Parameters:  hGvoHandle          - Handle to graphics adapter
00675 //              nEnumIndex          - Enumeration index
00676 //              bByEnum             - TRUE nEnumIndex is NVSIGNALFORMAT_*
00677 //                                    FALSE nEnumIndex is 0..n-1
00678 //              pSignalFormatDetail - Pointer to receive detail or NULL
00679 // Returns:     NV_OK               - Success
00680 //              NV_NOMORE           - No more signal formats to enumerate
00681 //              NV_NOTSUPPORTED     - Unsupported NVSIGNALFORMAT_ enumeration
00682 //---------------------------------------------------------------------
00683 NVRESULT NVAPIENTRY NvGvoEnumSignalFormats( NVGVOHANDLE              hGvoHandle          IN,
00684                                             int                      nEnumIndex          IN,
00685                                             BOOL                     bByEnum             IN,
00686                                             NVGVOSIGNALFORMATDETAIL* pSignalFormatDetail OUT );
00687
00688
00689 //---------------------------------------------------------------------
00690 // Function:    NvGvoIsFrameLockModeCompatible
00691 // Description: Checkes whether modes are compatible in framelock mode
00692 // Parameters:  hGvoHandle          - Handle to graphics adapter
00693 //              nSrcEnumIndex       - Source Enumeration index
00694 //              nDestEnumIndex      - Destination Enumeration index
00695 //
00696 //              pbCompatible        - Pointer to receive compatability
00697 // Returns:     NV_OK               - Success
00698 //              NV_NOTSUPPORTED     - Unsupported NVSIGNALFORMAT_ enumeration
00699 //---------------------------------------------------------------------
00700 NVRESULT NVAPIENTRY NvGvoIsFrameLockModeCompatible( NVGVOHANDLE  hGvoHandle          IN,
00701                                                     int          nSrcEnumIndex       IN,
00702                                                     int          nDestEnumIndex      IN,
00703                                                     BOOL*        pbCompatible        OUT );
00704
00705
00706 //---------------------------------------------------------------------
00707 // Function:    NvGvoEnumDataFormats
00708 // Description: Enumerate data formats supported by Graphics to Video.
00709 // Parameters:  hGvoHandle        - Handle to graphics adapter
00710 //              nEnumIndex        - Enumeration index
00711 //              bByEnum           - TRUE nEnumIndex is NVDATAFORMAT_*
00712 //                                  FALSE nEnumIndex is 0..n-1
00713 //              pDataFormatDetail - Pointer to receive detail or NULL
00714 // Returns:     NV_OK             - Success
00715 //              NV_NOMORE         - No more data formats to enumerate
00716 //              NV_NOTSUPPORTED   - Unsupported NVDATAFORMAT_ enumeration
00717 //---------------------------------------------------------------------
00718 NVRESULT NVAPIENTRY NvGvoEnumDataFormats( NVGVOHANDLE            hGvoHandle        IN,
00719                                           int                    nEnumIndex        IN,
00720                                           BOOL                   bByEnum           IN,
00721                                           NVGVODATAFORMATDETAIL* pDataFormatDetail OUT );
00722
00723
00724 #ifdef  __cplusplus
00725     }
00726 #endif//__cplusplus
00727
00728 #endif//__NVGVOAPI_H__
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvsgapi.h Source File

nvsgapi.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #if defined(LINUX)
00015 #include "nvsg/LinuxTypes.h"
00016 #endif
00017
00018
00019 #ifdef _WIN32
00020 // microsoft specific storage-class defines
00021 # ifdef NVSG_EXPORTS
00022 #  define NVSG_API __declspec(dllexport)
00023 # else
00024 #  define NVSG_API __declspec(dllimport)
00025 # endif
00026 #else
00027 # define NVSG_API
00028 #endif
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvsgcommon.h Source File

nvsgcommon.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 /* This is the common header file, that should be included by all NVSG headers.
00013 */
00014
00015 #pragma once
00016
00017 #pragma warning(disable:4100) // unreference formal parameter
00018
00019 #include <stdlib.h>
00020
00021 // Linux type defines
00022 #if defined(LINUX)
00023 # include "nvsg/LinuxTypes.h"
00024 #endif
00025
00026 // project header
00027 #include "nvsg/nvsgapi.h"  // storage-class defines
00028 #include "nvutil/Assert.h" // assert
00029 #include "nvutil/Trace.h"  // support for function level tracing
00030 #include "nvutil/Log.h"    // logging
00031 #include "nvutil/nvutil.h" // utility CRT functions
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvsggnudefs.h Source File

nvsggnudefs.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 /* GNU C/C++ compiler related defines
00013 */
00014
00015 #pragma once
00016
00017 // e.g. test for GCC < 3.4.0
00018 //  #if defined __GNUC__ && GCC_VERSION < 30400
00019 #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
00020
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


nvsgwindefs.h Source File

nvsgwindefs.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011 #pragma once
00012
00013 /* This file contains the defines commonly used by NVSG before including Windows headers.
00014 */
00015
00016 #if defined(_WIN32)
00017 # define WIN32_LEAN_AND_MEAN    // Exclude rarely-used stuff from Windows headers
00018 //# define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit
00019
00020 # ifndef VC_EXTRALEAN
00021 #  define VC_EXTRALEAN    // Exclude rarely-used stuff from Windows headers
00022 # endif
00023
00024 // Modify the following defines if you have to target a platform prior to the ones specified below.
00025 // Refer to MSDN for the latest info on corresponding values for different platforms.
00026 # ifndef WINVER       // Allow use of features specific to Windows 95 and Windows NT 4 or later.
00027 #  define WINVER 0x0500   // Change this to the appropriate value to target Windows 98 and Windows 2000 or later.
00028 # endif
00029
00030 # ifndef _WIN32_WINNT   // Allow use of features specific to Windows NT 4 or later.
00031 #  define _WIN32_WINNT 0x0500   // Change this to the appropriate value to target Windows 98 and Windows 2000 or later.
00032 # endif
00033
00034 # ifndef _WIN32_WINDOWS   // Allow use of features specific to Windows 98 or later.
00035 #  define _WIN32_WINDOWS 0x0500 // Change this to the appropriate value to target Windows Me or later.
00036 # endif
00037
00038 # ifndef _WIN32_IE      // Allow use of features specific to IE 4.0 or later.
00039 #  define _WIN32_IE 0x0600  // Change this to the appropriate value to target IE 5.0 or later.
00040 # endif
00041
00042 #endif // windows
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


OBJLoader.h Source File

OBJLoader.h

00001
00002 // Copyright NVIDIA Corporation 2002-2005
00003 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00004 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00005 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00006 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00007 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00008 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00009 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00010 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00011 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00012 // POSSIBILITY OF SUCH DAMAGES
00013
00014 //
00015 // OBJLoader.h
00016 //
00017
00018 #ifndef _LOADOBJ_H_
00019 #define _LOADOBJ_H_
00020
00021 #if ! defined( DOXYGEN_IGNORE )
00022
00023 #include <string>
00024 #include <vector>
00025 #include <map>
00026 #include <list>
00027 #include <ReadObj.h>
00028
00029 #include <nvsg/nvsgapi.h>
00030 #include <nvsg/nvsg.h>
00031 #include <nvsg/Scene.h>
00032 #include <nvsg/PlugInterface.h>
00033 #include <nvutil/Trace.h>
00034 #include <nvmath/Vecnt.h>
00035
00036 namespace nvsg
00037 {
00038   class Group;
00039   class SceneLoader;
00040   class Scene;
00041   class ViewState;
00042   class StateSet;
00043 }
00044
00045 #define INVOKE_CALLBACK(cb) if( callback() ) callback()->cb
00046
00047 class OBJLoader : public nvsg::SceneLoader
00048 {
00049
00050 public:
00051   OBJLoader();
00052
00053   void deleteThis( void );
00054
00055   nvsg::SceneHandle * load( const std::string& filename,
00056                             const std::vector<std::string> &searchPaths,
00057                             nvsg::ViewStateHandle *& viewState );
00058
00059   friend bool findFile( const std::string & fin, std::string &fout );
00060
00061 protected:
00062   virtual ~OBJLoader(void);
00063
00064 private:
00065   void buildScene( nvsg::Group *, Obj::ObjScene * scene );
00066   nvsg::StateSetHandle * buildStateSet( Obj::ObjMaterial * material, bool & );
00067
00068   std::vector< std::string > m_searchPaths;
00069 };
00070
00071
00072 #endif // ! defined( DOXYGEN_IGNORE )
00073
00074 #endif /* _LOADOBJ_H_ */
00075
00076
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


PBuffer.h Source File

PBuffer.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014
00015 #include "nvsgcommon.h"
00016
00017 #include  <vector>
00018 #include  "nvgl/nvgl.h"
00019
00020 // No need to document this internal helper class
00021 #if ! defined( DOXYGEN_IGNORE )
00022
00023 namespace nvgl
00024 {
00025   // Helper class for managing pbuffers. - internal use only -
00026   class PBuffer
00027   {
00028     public:
00029       // Chooses a pixel format according to the arguments and assembles an attribute list for creating a
00030       // pbuffer. After construction, the pbuffer is not yet valid; a pbuffer is created on \c resize().
00031       PBuffer( int bitsPerChannel, bool alpha, int depth, bool isFloat, bool rectangle = true, bool accumulation = false );
00032       ~PBuffer();
00033
00034     public:
00035       // Clear all resources of this pbuffer.
00036       // After this function, the pbuffer is no longer valid.
00037       void clear();
00038
00039       // Get the depth texture of the pbuffer.
00040       // If the pbuffer has a depth, a depth texture is created.
00041       // returns depth texture id
00042       GLuint getDepthTexture() const;
00043
00044 #if defined(_WIN32)
00045       // Gets the HDC of the pbuffer.
00046       // returns HDC of the pbuffer
00047       HDC getHDC() const;
00048
00049       // Get the HGLRC of the pbuffer.
00050       // returns HGLRC of the pbuffer
00051       HGLRC getHGLRC() const;
00052
00053       // Get the handle of the pbuffer.
00054       // returns  handle of the pbuffer
00055       HPBUFFERARB getPBuffer() const;
00056 #elif defined(LINUX)
00057       // Gets the HDC of the pbuffer.
00058       // returns HDC of the pbuffer
00059       Drawable getHDC() const;
00060
00061       // Gets the HGLRC of the pbuffer.
00062       // returns HGLRC of the pbuffer
00063       GLXContext getHGLRC() const;
00064
00065       // Get the handle of the pbuffer.
00066       // returns handle of the pbuffer
00067       GLXPbuffer  getPBuffer() const;
00068 #endif
00069
00070       // Get the height of the pbuffer.
00071       // \returns  height of the pbuffer
00072       int getHeight() const;
00073
00074       // Get the texture of the pbuffer.
00075       // Every pbuffer has a texture bound to the color buffer of the pbuffer.
00076       // returns texture id
00077       GLuint getTexture() const;
00078
00079       // Get the width of the pbuffer.
00080       // returns width of the pbuffer
00081       int getWidth() const;
00082
00083       // Resize the pbuffer.
00084       // On resize, the current pbuffer is cleared and is completely initialized. The pbuffer then shares the lists
00085       // with the current OpenGL context. After resizing the OpenGL context of the pbuffer is current. If the pbuffer
00086       // has a depth, a depth texture is also created. The viewport and the projection and modelview matrix are
00087       // initialized to orthographic projection and identity, respectively.
00088       // returns \c true if the resize operation completed successfully, \c false otherwise.
00089       bool resize(int width, int height);
00090
00091     private:
00092       std::vector<int>  m_attribList;
00093       int               m_depth;
00094       GLuint            m_depthTexture;
00095       int               m_format;
00096       int               m_height;
00097       bool              m_rectangle;
00098 #if defined(_WIN32)
00099       HDC               m_HDC;
00100       HGLRC             m_HGLRC;
00101       HPBUFFERARB       m_pBuffer;
00102 #elif defined(LINUX)
00103       Drawable          m_HDC;
00104       GLXContext        m_HGLRC;
00105       GLXPbuffer        m_pBuffer;
00106 #endif
00107       GLuint            m_texture;
00108       int               m_width;
00109   };
00110
00111 } //  namespace nvgl
00112
00113 #endif //DOXYGEN_IGNORE
00114
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


ReadObj.h Source File

ReadObj.h

00001 //
00002 // A fair amount of this code was adapted from the SGL OBJ file loader.
00003 // The original files contain the following copyright notice, and were under
00004 // the LGPL:
00005 //
00006 /******************************************************************************
00007  * SGL: A Scene Graph Library
00008  *
00009  * Copyright (C) 1997-2004  Scott McMillan   All Rights Reserved.
00010  *
00011  *     File: sglObjModel.cpp
00012  *  Created: 24 June 1997
00013  *****************************************************************************/
00014
00015 #pragma once
00016
00017 #include <stdio.h>
00018 #include <stdlib.h>
00019 #include <string.h>
00020 #include <ctype.h>
00021 #include <string>
00022 #include <vector>
00023 #include <iostream>
00024
00025 #ifdef _WIN32
00026 #define strcasecmp stricmp
00027 #endif
00028
00029 namespace Obj
00030 {
00031
00032 class Vec3f
00033 {
00034 public:
00035   Vec3f( float a, float b, float c ) { x=a; y=b; z=c; }
00036   Vec3f() {}
00037   float x, y, z;
00038   float & operator[]( int v )
00039   {
00040     if( v == 0 )
00041       return x;
00042     else if( v == 1 )
00043       return y;
00044     else if( v == 2 )
00045       return z;
00046     else
00047       return z; // should assert, do this for now
00048   }
00049 };
00050
00051 class Vec2f
00052 {
00053 public:
00054   Vec2f( float a, float b ) { x=a; y=b; }
00055   Vec2f() {}
00056   float x, y;
00057   float & operator[]( int v )
00058   {
00059     if( v == 0 )
00060       return x;
00061     else if( v == 1 )
00062       return y;
00063     else
00064       return y; // should assert, do this for now
00065   }
00066 };
00067
00068 #define setVec3( v, x, y, z ) { v[0] = x; v[1] = y; v[2] = z; }
00069 #define setVec2( v, x, y, z ) { v[0] = x; v[1] = y; }
00070
00071 class ObjMaterial
00072 {
00073 public:
00074   ObjMaterial( const char * mname )
00075     : hasColors(false)
00076     , hasTexture(false)
00077     , name( mname )
00078     , ambient( Vec3f(0.f,0.f,0.f) )
00079     , diffuse( Vec3f(0.f,0.f,0.f) )
00080     , specular( Vec3f(0.f,0.f,0.f) )
00081     , alpha( 1.f )
00082     , shininess( 1.f )
00083     {}
00084
00085   ~ObjMaterial() {}
00086
00087   std::string name;
00088   bool hasColors;
00089   bool hasTexture;
00090   Vec3f ambient;
00091   Vec3f diffuse;
00092   Vec3f specular;
00093   float alpha;
00094   float shininess;
00095   std::string diffuseTexture;
00096   std::string reflectiveTexture;
00097 };
00098
00099 struct ObjFace
00100 {
00101   std::vector< unsigned int > indices;
00102 };
00103
00104 struct ObjGeoSet
00105 {
00106   ObjMaterial * material;
00107   std::vector< Vec3f > verts;
00108   std::vector< Vec3f > normals;
00109   std::vector< Vec2f > texcoords;
00110
00111   std::vector< ObjFace > faces;
00112 };
00113
00114 struct ObjScene
00115 {
00116   std::vector< ObjGeoSet * > geoSets;
00117 };
00118
00119 class ObjLoader
00120 {
00121 public:
00122
00123   ObjLoader();
00124   ~ObjLoader();
00125
00126   ObjGeoSet * findGeoSet( ObjMaterial * mtl );
00127   bool load(const std::string &filename,
00128             bool (*)( const std::string &fin, std::string &fout ) = 0 );
00129   bool addMaterialLib(const char *filename);
00130   ObjMaterial * getMaterial(const char *mtl_name);
00131   bool addMaterial(ObjMaterial *mtl);
00132   ObjMaterial * parseMtlLib(const std::string &filename, const char *mtl_name);
00133   void parseTexture(char *next, std::string &filename,float &su,float &sv);
00134
00135   ObjScene * getScene();
00136
00137 private:
00138   bool (*m_findFile)( const std::string &fin, std::string &fout );
00139
00140   std::vector< std::string > m_mtlLibList;
00141   std::vector< ObjMaterial * > m_mtlList;
00142   std::vector< ObjGeoSet * > m_geoSets;
00143   ObjScene m_scene;
00144 };
00145
00146 } // end namespace Obj
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


RenderElement.h Source File

RenderElement.h

00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include <algorithm>
00015 #include "nvmath/Matnnt.h"
00016 #include "nvmath/Spherent.h"
00017 #include "nvsg/Object.h"
00018 #include "nvsg/StateVariant.h"
00019 #include "nvsg/StatePass.h"
00020 #include "nvsg/Material.h"
00021 #include "nvsg/PrimitiveSet.h"
00022 #include "nvtraverser/BaseRenderElement.h"
00023 #include "nvtraverser/ClipPlanesElement.h"
00024 #include "nvtraverser/LightsElement.h"
00025 #include "nvtraverser/TransformElement.h"
00026 #include "nvutil/RCObject.h"
00027 #include "nvutil/Handle.h"
00028
00029 namespace nvtraverser
00030 {
00037   class RenderElement : public BaseRenderElement
00038   {
00039     public:
00054       NVSG_API RenderElement( nvsg::StateVariantHandle * svh, ClipPlanesElement * cpe
00055                             , LightsElement *le, TransformElement *te, bool culling );
00056
00061       NVSG_API ~RenderElement();
00062
00067       NVSG_API void addPrimitiveSet( nvsg::PrimitiveSetHandle * psh );
00068
00072       NVSG_API ClipPlanesElement * getClipPlanes() const;
00073
00077       NVSG_API LightsElement * getLights() const;
00078
00082       NVSG_API unsigned int getNumberOfPrimitiveSets() const;
00083
00089       NVSG_API unsigned int getOcclusionCullID() const;
00090
00098       NVSG_API nvsg::PrimitiveSetHandle * getPrimitiveSet( unsigned int i ) const;
00099
00112       NVSG_API float getSquaredDistance( const nvmath::Mat44f &worldToView );
00113
00118       NVSG_API nvsg::StateVariantHandle * getStateVariant() const;
00119
00125       NVSG_API TransformElement * getTransform() const;
00126
00132       NVSG_API void invalidateSquaredDistance();
00133
00138       NVSG_API bool isSubjectToCull() const;
00139
00148       NVSG_API bool isSquaredDistanceValid() const;
00149
00155       NVSG_API void setOcclusionCullID( unsigned int id );
00156
00157     private:
00158       nvmath::Sphere3f                          m_boundingSphere;
00159       bool                                      m_boundingSphereValid;
00160       ClipPlanesElement                       * m_clipPlanes;
00161       LightsElement                           * m_lights;
00162       bool                                      m_culling;
00163       unsigned int                              m_occlusionCullID;
00164       std::vector<nvsg::PrimitiveSetHandle *>   m_primitiveSets;
00165       float                                     m_squaredDist;
00166       nvsg::StateVariantHandle                * m_stateVariant;
00167       TransformElement                        * m_transform;
00168   };
00169
00170   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00171   // non-member functions
00172   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00182   inline RenderElement * createRenderElement( RenderElementPool * pool
00183                                             , nvsg::StateVariantHandle * svh
00184                                             , ClipPlanesElement * cpe
00185                                             , LightsElement* le
00186                                             , TransformElement* te
00187                                             , bool culling )
00188   {
00189     return constructRenderElement<RenderElement, nvsg::StateVariantHandle *, ClipPlanesElement *
00190       , LightsElement*, TransformElement*, bool>(pool, svh, cpe, le, te, culling);
00191   }
00192
00193   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00194   // comparison functors
00195   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00200   class RenderElementCompareBackToFront
00201   {
00202     public:
00208       NVSG_API RenderElementCompareBackToFront( const nvmath::Mat44f &worldToView );
00209
00215       NVSG_API bool operator()( RenderElement * re0, RenderElement *re1 ) const;
00216
00217     private:
00218       const nvmath::Mat44f  m_worldToView;
00219   };
00220
00225   class RenderElementCompareFrontToBack
00226   {
00227     public:
00233       NVSG_API RenderElementCompareFrontToBack( nvmath::Mat44f &worldToView );
00234
00240       NVSG_API bool operator()( RenderElement * re0, RenderElement *re1 ) const;
00241
00242     private:
00243       nvmath::Mat44f  m_worldToView;
00244   };
00245
00250   class RenderElementCompareStateAttributes
00251   {
00252     public:
00258       NVSG_API bool operator()( RenderElement * re0, RenderElement *re1 ) const;
00259
00260     private:
00261       NVSG_API bool isLess( RenderElement * re0, RenderElement *re1 ) const;
00262       NVSG_API bool lessTest( const nvsg::StateVariant * sv0, const nvsg::StateVariant * sv1
00263                             , unsigned int objectCode, bool & less ) const;
00264   };
00265
00266
00267   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00268   // inlines
00269   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00270   inline void RenderElement::addPrimitiveSet( nvsg::PrimitiveSetHandle * psh )
00271   {
00272     NVSG_ASSERT( psh );
00273     psh->addRef();
00274     m_primitiveSets.push_back( psh );
00275     m_boundingSphereValid = false;
00276   }
00277
00278   inline ClipPlanesElement * RenderElement::getClipPlanes() const
00279   {
00280     return( m_clipPlanes );
00281   }
00282
00283   inline LightsElement * RenderElement::getLights() const
00284   {
00285     return( m_lights );
00286   }
00287
00288   inline unsigned int RenderElement::getNumberOfPrimitiveSets() const
00289   {
00290     NVSG_ASSERT( m_primitiveSets.size() <= UINT_MAX );
00291     return( static_cast<unsigned int>(m_primitiveSets.size()) );
00292   }
00293
00294   inline unsigned int RenderElement::getOcclusionCullID() const
00295   {
00296     return( m_occlusionCullID );
00297   }
00298
00299   inline nvsg::PrimitiveSetHandle * RenderElement::getPrimitiveSet( unsigned int index ) const
00300   {
00301     NVSG_ASSERT( index < m_primitiveSets.size() );
00302     return( m_primitiveSets[index] );
00303   }
00304
00305   inline nvsg::StateVariantHandle * RenderElement::getStateVariant() const
00306   {
00307     return( m_stateVariant );
00308   }
00309
00310   inline TransformElement * RenderElement::getTransform() const
00311   {
00312     return( m_transform );
00313   }
00314
00315   inline void RenderElement::invalidateSquaredDistance()
00316   {
00317     m_squaredDist = -1.0f;
00318   }
00319
00320   inline bool RenderElement::isSubjectToCull() const
00321   {
00322     return( m_culling );
00323   }
00324
00325   inline bool RenderElement::isSquaredDistanceValid() const
00326   {
00327     return( 0.0f <= m_squaredDist );
00328   }
00329
00330   inline void RenderElement::setOcclusionCullID( unsigned int id )
00331   {
00332     m_occlusionCullID = id;
00333   }
00334
00335
00336   inline bool RenderElementCompareBackToFront::operator()( RenderElement * re0, RenderElement *re1 ) const
00337   {
00338     return( re1->getSquaredDistance( m_worldToView ) < re0->getSquaredDistance( m_worldToView ) );
00339   }
00340
00341   inline bool RenderElementCompareFrontToBack::operator()( RenderElement * re0, RenderElement *re1 ) const
00342   {
00343     return( re0->getSquaredDistance( m_worldToView ) < re1->getSquaredDistance( m_worldToView ) );
00344   }
00345
00346   inline bool RenderElementCompareStateAttributes::operator()( RenderElement * re0, RenderElement *re1 ) const
00347   {
00348     NVSG_ASSERT( re0 && re1 );
00349     bool less = isLess( re0, re1 );
00350     NVSG_ASSERT( !( less && isLess(re1,re0) ) );  // assure that not both re0<re1 and re1<re0
00351     return( less );
00352   }
00353 }
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


RenderElementPool.h Source File

RenderElementPool.h

00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 namespace nvtraverser
00015 {
00016
00017 class RenderElementPool
00018 {
00019 public:
00020   RenderElementPool();
00021   ~RenderElementPool();
00022
00023   void * alloc(size_t size); // allocates size bytes of memory and returns the address to the allocated memory
00024   void reset(); // resets the running pointer for each allocated block
00025
00026 private:
00027   struct Block
00028   {
00029     Block();
00030     ~Block();
00031
00032     enum { BLOCKSIZE = 0x400000 };
00033     unsigned char * m_start;   // marks the beginning of the raw memory block
00034     unsigned char * m_end;     // points past the end of the memory block
00035     unsigned char * m_current; // points to next available free space
00036     Block * m_next;
00037   };
00038   Block * m_head; // head of block list
00039   Block * m_tail; // always points to the current block
00040 };
00041
00042 template <typename REType>
00043 inline REType * constructRenderElement(RenderElementPool * pool)
00044 {
00045   return new(pool->alloc(sizeof(REType))) REType;
00046 }
00047
00048 template <typename REType, typename Arg>
00049 inline REType * constructRenderElement(RenderElementPool * pool, Arg arg)
00050 {
00051   return new(pool->alloc(sizeof(REType))) REType(arg);
00052 }
00053
00054 template <typename REType, typename Arg0, typename Arg1>
00055 inline REType * constructRenderElement(RenderElementPool * pool, Arg0 arg0, Arg1 arg1)
00056 {
00057   return new(pool->alloc(sizeof(REType))) REType(arg0, arg1);
00058 }
00059
00060 template <typename REType, typename Arg0, typename Arg1, typename Arg2>
00061 inline REType * constructRenderElement(RenderElementPool * pool, Arg0 arg0, Arg1 arg1, Arg2 arg2)
00062 {
00063   return new(pool->alloc(sizeof(REType))) REType(arg0, arg1, arg2);
00064 }
00065
00066 template <typename REType, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
00067 inline REType * constructRenderElement(RenderElementPool * pool, Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3)
00068 {
00069   return new(pool->alloc(sizeof(REType))) REType(arg0, arg1, arg2, arg3);
00070 }
00071
00072 template <typename REType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
00073 inline REType * constructRenderElement(RenderElementPool * pool, Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
00074 {
00075   return new(pool->alloc(sizeof(REType))) REType(arg0, arg1, arg2, arg3, arg4);
00076 }
00077
00078 template <typename REType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
00079 inline REType * constructRenderElement(RenderElementPool * pool, Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
00080 {
00081   return new(pool->alloc(sizeof(REType))) REType(arg0, arg1, arg2, arg3, arg4, arg5);
00082 }
00083
00084 template <typename REType, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
00085 inline REType * constructRenderElement(RenderElementPool * pool, Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6)
00086 {
00087   return new(pool->alloc(sizeof(REType))) REType(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
00088 }
00089
00090
00091 }
00092
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


Renderer.h Source File

Renderer.h

00001 #pragma once
00002
00003 #include "GLXRenderArea.h"
00004
00005 // simple rendere area class for the console viewer
00006 class Renderer : public GLXRenderArea
00007 {
00008 public:
00009   Renderer();
00010   virtual ~Renderer(void);
00011
00012   bool setupRenderArea();
00013
00014   Window getWindow() { return m_window; }
00015   Display * getDisplay() { return m_display; }
00016
00017   Atom wm_delete_window;
00018
00019 private:
00020   Display * m_display;
00021   Window    m_window;
00022 };
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


resource.h Source File

resource.h

00001 //{{NO_DEPENDENCIES}}
00002 // Microsoft Visual C++ generated include file.
00003 // Used by nvsg.rc
00004
00005 // Next default values for new objects
00006 //
00007 #ifdef APSTUDIO_INVOKED
00008 #ifndef APSTUDIO_READONLY_SYMBOLS
00009 #define _APS_NEXT_RESOURCE_VALUE        101
00010 #define _APS_NEXT_COMMAND_VALUE         40001
00011 #define _APS_NEXT_CONTROL_VALUE         1001
00012 #define _APS_NEXT_SYMED_VALUE           101
00013 #endif
00014 #endif
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


stdafx.h Source File

stdafx.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 // stdafx.h : include file for standard system include files,
00013 // or project specific include files that are used frequently, but
00014 // are changed infrequently
00015 //
00016
00017 #pragma once
00018
00019
00020 #if defined(_WIN32)
00021 #define WIN32_LEAN_AND_MEAN   // Exclude rarely-used stuff from Windows headers
00022 // Windows Header Files:
00023 #include <windows.h>
00024 #endif
00025
00026 #include "nvsg/nvsgapi.h" // NVSG storage-class defines
00027 #include "nvsg/NVSGVersion.h" // NVSG version info
00028
00029 #include "nvutil/Assert.h"
00030 #include "nvutil/Trace.h"
00031 #include "nvutil/Tools.h"
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


ShaderBuilder.h Source File

ShaderBuilder.h

00001
00002 // Copyright NVIDIA Corporation 2002-2005
00003 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00004 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00005 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00006 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00007 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00008 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00009 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00010 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00011 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00012 // POSSIBILITY OF SUCH DAMAGES
00013
00014 //
00015 // ShaderBuilder.h
00016 //
00017
00018
00019 #ifndef _SHADERBUILDER_H_
00020 #define _SHADERBUILDER_H_
00021
00022 #include <string>
00023 #include <vector>
00024
00025 enum ComponentType
00026 {
00027   AMBIENT      = (1<<0),
00028   DIFFUSE      = (1<<1),
00029   SPECULAR     = (1<<2),
00030   EMISSIVE     = (1<<3),
00031   CTRANSPARENT = (1<<4),
00032   CREFLECTIVE  = (1<<5),
00033   CFOG         = (1<<6)
00034 };
00035
00036 enum LightingType
00037 {
00038   BLINN,
00039   PHONG,
00040   CONSTANT,
00041   LAMBERT
00042 };
00043
00044 struct Component
00045 {
00046   ComponentType type;
00047   bool isTexture;
00048   std::string textureFile;
00049   std::string samplerType;    // 2D, 3D, CUBE, etc
00050   std::string texCoordSemantic;
00051   std::string minFilter;
00052   std::string magFilter;
00053   std::string wrapS;
00054   std::string wrapT;
00055   std::string wrapR;
00056   bool hasBorderColor;
00057   int texcoordUnit;
00058   float color[4];
00059   float floatParameter;
00060   int   modeParameter;
00061 };
00062
00063 std::string BuildShader( std::string effectName,
00064                          LightingType lightingModel,
00065                          bool fragmentLighting,
00066                          bool optimizeShader,
00067                          int componentMask,
00068                          std::vector< Component > & components );
00069
00070 #endif /* _SHADERBUILDER_H_ */
00071
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


SimpleTesselator.h Source File

SimpleTesselator.h

00001
00002 // Copyright NVIDIA Corporation 2002-2005
00003 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00004 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00005 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00006 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00007 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00008 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00009 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00010 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00011 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00012 // POSSIBILITY OF SUCH DAMAGES
00013
00014 //
00015 // SimpleTesselator.h
00016 //
00017
00018 #ifndef _SIMPLETESSELATOR_H_
00019 #define _SIMPLETESSELATOR_H_
00020
00021 #include <GL/gl.h>
00022 #include <GL/glu.h>
00023 #include <nvsg/nvsg.h>
00024 #include <nvsg/nvsgapi.h>
00025 #include <vector>
00026
00027 #if defined( WIN32 ) || defined( _WIN32 )
00028 #define CALLBACK __stdcall
00029 #define GLU_TESS_CALLBACK void (__stdcall *)()
00030 #else
00031 #define CALLBACK
00032 #define GLU_TESS_CALLBACK void (*)()
00033 #endif
00034
00035 class SimpleTesselator
00036 {
00037 public:
00038   SimpleTesselator() : m_tess( gluNewTess() )
00039   {
00040     NVSG_ASSERT( m_tess );
00041
00042     // register callbacks
00043     //
00044     // if we register an edge flag callback then everything
00045     // will come as triangle lists
00046     //
00047     //gluTessCallback( m_tess, GLU_TESS_EDGE_FLAG_DATA,
00048     //                         (GLU_TESS_CALLBACK) edgeCB );
00049     gluTessCallback( m_tess, GLU_TESS_VERTEX_DATA,
00050                             (GLU_TESS_CALLBACK) vertexCB );
00051     gluTessCallback( m_tess, GLU_TESS_BEGIN_DATA,
00052                             (GLU_TESS_CALLBACK) beginCB );
00053     gluTessCallback( m_tess, GLU_TESS_END_DATA,
00054                             (GLU_TESS_CALLBACK) endCB );
00055     //gluTessCallback( m_tess, GLU_TESS_COMBINE_DATA,
00056     //                        (GLU_TESS_CALLBACK) combineCB );
00057     gluTessCallback( m_tess, GLU_TESS_ERROR_DATA,
00058                              (GLU_TESS_CALLBACK) errorCB );
00059
00060     // no merging!!
00061     gluTessProperty( m_tess, GLU_TESS_TOLERANCE, 0.0 );
00062   }
00063
00064   virtual ~SimpleTesselator(void)
00065   {
00066     gluDeleteTess( m_tess );
00067   }
00068
00069   bool tesselate( const std::vector<nvmath::Vec3f> & vertsIn,
00070                   std::vector<unsigned int> & indexListInOut )
00071   {
00072     NVSG_TRACE();
00073
00074     // must have at least one poly
00075     if( vertsIn.size() < 3 || indexListInOut.size() < 3 )
00076       return false;
00077
00078     std::vector<GLdouble> verts( 3* indexListInOut.size() );
00079
00080     // clear error
00081     m_error = 0;
00082     m_primtype = 0xffffffff;
00083
00084     gluTessBeginPolygon( m_tess, this );
00085     //gluTessNormal( m_tess, n[0], n[1], n[2] );
00086     gluTessBeginContour( m_tess );
00087
00088     for(unsigned int i=0;i<indexListInOut.size();i++)
00089     {
00090       double x, y, z;
00091
00092       x = (double)vertsIn[indexListInOut[i]][0];
00093       y = (double)vertsIn[indexListInOut[i]][1];
00094       z = (double)vertsIn[indexListInOut[i]][2];
00095
00096       verts[3*i+0] = x;
00097       verts[3*i+1] = y;
00098       verts[3*i+2] = z;
00099
00100       gluTessVertex( m_tess, &verts[3*i], (void *)&indexListInOut[i] );
00101     }
00102
00103     gluTessEndContour( m_tess );
00104     gluTessEndPolygon( m_tess );
00105
00106     convertTriList();
00107
00108     //
00109     // Copy out the faces
00110     //
00111     indexListInOut = m_triList;
00112
00113     return (m_error == 0 && m_triList.size());
00114   }
00115
00116   std::vector<unsigned int> m_triList;
00117   std::vector<unsigned int> m_drawList;
00118   GLenum m_error;
00119   GLenum m_primtype;
00120
00121 private:
00122   GLUtesselator * m_tess;
00123
00124   void convertTriList();
00125   static void CALLBACK edgeCB(GLboolean flag, void* userData);
00126   static void CALLBACK beginCB(GLenum which, void* userData);
00127   static void CALLBACK vertexCB(GLvoid *data, void* userData);
00128   static void CALLBACK combineCB(GLdouble coords[3], void* vertex_data[4],
00129                         GLfloat weight[4], void** outData,
00130                         void* useData);
00131   static void CALLBACK endCB(void* userData);
00132   static void CALLBACK errorCB(GLenum errorCode, void* userData);
00133
00134 };
00135
00136 void SimpleTesselator::convertTriList( void )
00137 {
00138   GLenum mode = GL_INVALID_VALUE;
00139   int count = 0;
00140
00141   // walk through draw commands and decompose them back into triangles
00142   for( unsigned int i=0; i < m_drawList.size(); i++ )
00143   {
00144     // end command
00145     if( m_drawList[i] == 0xffffffff )
00146     {
00147       mode = GL_INVALID_VALUE;
00148       count = 0;
00149       continue;
00150     }
00151
00152     switch( mode )
00153     {
00154       case GL_INVALID_VALUE:
00155         // expect draw command
00156         mode = m_drawList[i];
00157         break;
00158
00159       case GL_TRIANGLES:
00160         m_triList.push_back( m_drawList[i] );
00161         break;
00162
00163       case GL_TRIANGLE_STRIP:
00164         if( count < 3 )
00165         {
00166           m_triList.push_back( m_drawList[i] );
00167         }
00168         else
00169         {
00170           if( count & 1 )
00171           {
00172             // odd
00173             m_triList.push_back( m_drawList[i-1] );
00174             m_triList.push_back( m_drawList[i-2] );
00175             m_triList.push_back( m_drawList[i] );
00176           }
00177           else
00178           {
00179             // even
00180             m_triList.push_back( m_drawList[i-2] );
00181             m_triList.push_back( m_drawList[i-1] );
00182             m_triList.push_back( m_drawList[i] );
00183           }
00184         }
00185         count++;
00186         break;
00187
00188       case GL_TRIANGLE_FAN:
00189         if( count < 3 )
00190         {
00191           m_triList.push_back( m_drawList[i] );
00192         }
00193         else
00194         {
00195           m_triList.push_back( m_drawList[i-count] );
00196           m_triList.push_back( m_drawList[i-1] );
00197           m_triList.push_back( m_drawList[i] );
00198         }
00199         count++;
00200         break;
00201
00202       default:
00203         NVSG_ASSERT(0);
00204     }
00205   }
00206 }
00207
00208 void SimpleTesselator::edgeCB( GLboolean flag, void * data )
00209 {
00210   // do nothing
00211 }
00212
00213 void SimpleTesselator::beginCB(GLenum which, void* userData)
00214 {
00215   ((SimpleTesselator*)userData)->m_drawList.push_back( (unsigned int)which );
00216 }
00217
00218 void SimpleTesselator::vertexCB(GLvoid *data, void* userData)
00219 {
00220   NVSG_ASSERT( userData != 0 );
00221
00222   ((SimpleTesselator*)userData)->m_drawList.push_back( *(unsigned int*)data );
00223 }
00224
00225 void SimpleTesselator::combineCB(GLdouble coords[3], void * vertex_data[4],
00226                       GLfloat w[4], void** outData,
00227                       void* userData)
00228 {
00229   //NVSG_ASSERT(0);
00230   GLdouble *n = new GLdouble[3];
00231   GLdouble * d = (GLdouble *)vertex_data;
00232
00233   n[0] =  coords[0];
00234   n[1] =  coords[1];
00235   n[2] =  coords[2];
00236
00237   *outData = (void *)n;
00238 }
00239
00240 void SimpleTesselator::endCB(void* userData)
00241 {
00242   ((SimpleTesselator*)userData)->m_drawList.push_back( (unsigned int)0xffffffff );
00243 }
00244
00245 void SimpleTesselator::errorCB(GLenum errorCode, void* userData)
00246 {
00247   switch( errorCode )
00248   {
00249     case GLU_TESS_COORD_TOO_LARGE:
00250       break;
00251     case GLU_TESS_NEED_COMBINE_CALLBACK:
00252       break;
00253     case GLU_OUT_OF_MEMORY:
00254       break;
00255   }
00256
00257   ((SimpleTesselator*)userData)->m_error = errorCode;
00258 }
00259
00260 #endif /* _SIMPLETESSELATOR_H_ */
00261
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


StackedAtlas.h Source File

StackedAtlas.h

00001
00002 #pragma once
00003
00004 #include <nvsg/TextureAttribute.h>
00005 #include <nvutil/Handle.h>
00006 #include <string>
00007 #include <vector>
00008 #include <map>
00009
00010 class StackedAtlas
00011 {
00012 public:
00013   StackedAtlas( unsigned int width, unsigned int height );
00014   ~StackedAtlas();
00015
00016   unsigned int getWidth() { return m_width; }
00017   unsigned int getHeight() { return m_height; }
00018   unsigned int getCount() { return m_textureCount; }
00019
00020   nvsg::TextureAttributeItemHandle * addTexture( nvsg::TextureImage * img, int & );
00021   nvsg::TextureAttributeItemHandle * getTextureAttributeItem();
00022
00023 private:
00024
00025   nvsg::TextureAttributeItemHandle * m_textureAttributeItem;
00026   unsigned int m_width;
00027   unsigned int m_height;
00028   unsigned int m_textureCount;
00029 };
00030
00031 class StackedAtlasManager
00032 {
00033 public:
00034   StackedAtlasManager();
00035   ~StackedAtlasManager();
00036
00037   void setMaxSlices( unsigned int maxSlices );
00038   void setCreateMipmaps( bool create );
00039   void setSearchPaths( const std::vector< std::string > & searchPaths );
00040   void setRescaleTextures( bool state, unsigned int width = 0,
00041                                        unsigned int height = 0 );
00042
00043   nvsg::TextureAttributeItemHandle * submitTexture( const std::string & file,
00044                                                     const std::string & attrs,
00045                                                     int & layer );
00046
00047 private:
00048
00049   bool m_rescale;
00050   bool m_createMipmaps;
00051   unsigned int m_width;
00052   unsigned int m_height;
00053   unsigned int m_maxSlices;
00054   std::map< std::string, std::pair<std::string,int> > m_cachedFiles;
00055   std::map< std::string, StackedAtlas * > m_atlases;
00056   std::vector< std::string > m_searchPaths;
00057 };
Generated on Tue Jan 15 10:27:27 2008 for NVSGSDK by NVIDIA


TaiManager.h Source File

TaiManager.h

00001
00002 #ifndef _TAI_MANAGER_H_
00003 #define _TAI_MANAGER_H_
00004
00005 #include <stdio.h>
00006 #include <string>
00007 #include <list>
00008
00009 // load a tai file
00010
00011 enum AtlasType
00012 {
00013   ATLAS_2D,
00014   ATLAS_3D  // not supported
00015 };
00016
00017 struct TaiEntry
00018 {
00019   // values read from file
00020   std::string   textureFile;
00021   std::string   atlasFile;
00022   unsigned int  atlasIndex;
00023   AtlasType     type;
00024   float         woffset;
00025   float         hoffset;
00026   float         doffset;
00027   float         width;
00028   float         height;
00029
00030   void print( void ) const
00031   {
00032     printf("%s: %s(%d) %s (%f,%f,%f) (%fx%f)\n",
00033         textureFile.c_str(), atlasFile.c_str(),
00034         atlasIndex, (type==ATLAS_2D)?"2D":"3D",
00035         woffset, hoffset, doffset,
00036         width, height );
00037   }
00038 };
00039
00040 class TaiManager
00041 {
00042 public:
00043
00044   TaiManager();
00045   ~TaiManager();
00046   bool loadFile( const std::string & file );
00047   const TaiEntry * findEntry( const std::string & file );
00048
00049 private:
00050
00051   std::list< TaiEntry > m_entries;
00052 };
00053
00054 #endif /* _TAI_MANAGER_H_ */
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


TransformElement.h Source File

TransformElement.h

00001 // Copyright NVIDIA Corporation 2002-2006
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvmath/Matnnt.h"
00015 #include "nvsg/Group.h"
00016 #include "nvsg/Billboard.h"
00017 #include "nvtraverser/BaseRenderElement.h"
00018
00019 namespace nvtraverser
00020 {
00027   class TransformElement : public BaseRenderElement
00028   {
00029     public:
00035       NVSG_API TransformElement( void );
00036
00050       NVSG_API TransformElement( const nvmath::Mat44f &mtw, const nvmath::Mat44f &wtm
00051                                , TransformElement *parent, nvsg::GroupHandle * transform
00052                                , bool lengthPreserving, bool mirror, bool fixed );
00053
00059       NVSG_API TransformElement * getParent() const;
00060
00065       NVSG_API const nvmath::Mat44f & getModelToWorld() const;
00066
00070       NVSG_API nvsg::GroupHandle * getTransform() const;
00071
00076       NVSG_API const nvmath::Mat44f & getWorldToModel() const;
00077
00085       NVSG_API bool isFixed() const;
00086
00093       NVSG_API bool isLengthPreserving() const;
00094
00098       NVSG_API bool isMirroring() const;
00099
00107       NVSG_API void updateMatrices( const nvmath::Mat44f & matrix, const nvmath::Mat44f & inverse );
00108
00109     private:
00110       nvmath::Mat44f      m_modelToWorld;
00111       nvmath::Mat44f      m_worldToModel;
00112       TransformElement  * m_parent;
00113       nvsg::GroupHandle * m_transform;
00114       bool                m_lengthPreserving;
00115       bool                m_mirror;
00116       bool                m_fixed;
00117   };
00118
00119   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00120   // non-member functions
00121   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00126   inline TransformElement * createTransformElement(RenderElementPool * pool)
00127   {
00128     return constructRenderElement<TransformElement>(pool);
00129   }
00130
00145   inline TransformElement * createTransformElement( RenderElementPool * pool
00146                                                   , const nvmath::Mat44f& mtw
00147                                                   , const nvmath::Mat44f& wtm
00148                                                   , TransformElement * parent
00149                                                   , nvsg::GroupHandle * transform
00150                                                   , bool lengthPreserving
00151                                                   , bool mirror
00152                                                   , bool fixed )
00153   {
00154     return constructRenderElement<TransformElement
00155                                  , const nvmath::Mat44f&
00156                                  , const nvmath::Mat44f&
00157                                  , TransformElement*
00158                                  , nvsg::GroupHandle *
00159                                  , bool
00160                                  , bool
00161                                  , bool>( pool, mtw, wtm, parent, transform, lengthPreserving, mirror, fixed );
00162   }
00163
00164   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00165   // inlines
00166   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00167   inline TransformElement::TransformElement( void )
00168     : m_modelToWorld( nvmath::cIdentity44f )
00169     , m_worldToModel( nvmath::cIdentity44f )
00170     , m_parent( NULL )
00171     , m_transform( NULL )
00172     , m_lengthPreserving( true )
00173     , m_mirror( false )
00174     , m_fixed( true )
00175   {
00176   }
00177
00178   inline TransformElement::TransformElement( const nvmath::Mat44f &mw
00179                                            , const nvmath::Mat44f &wm
00180                                            , TransformElement *parent
00181                                            , nvsg::GroupHandle * transform
00182                                            , bool lengthPreserving
00183                                            , bool mirror
00184                                            , bool fixed )
00185     : m_modelToWorld( mw )
00186     , m_worldToModel( wm )
00187     , m_parent( parent )
00188     , m_transform( transform )
00189     , m_lengthPreserving( lengthPreserving )
00190     , m_mirror( mirror )
00191     , m_fixed( fixed && ( ! parent || parent->m_fixed ) )
00192   {
00193   }
00194
00195   inline TransformElement * TransformElement::getParent() const
00196   {
00197     return( m_parent );
00198   }
00199
00200   inline const nvmath::Mat44f & TransformElement::getModelToWorld() const
00201   {
00202     return( m_modelToWorld );
00203   }
00204
00205   inline nvsg::GroupHandle * TransformElement::getTransform() const
00206   {
00207     return( m_transform );
00208   }
00209
00210   inline const nvmath::Mat44f & TransformElement::getWorldToModel() const
00211   {
00212     return( m_worldToModel );
00213   }
00214
00215   inline bool TransformElement::isFixed() const
00216   {
00217     return( m_fixed );
00218   }
00219
00220   inline bool TransformElement::isLengthPreserving() const
00221   {
00222     return( m_lengthPreserving );
00223   }
00224
00225   inline bool TransformElement::isMirroring() const
00226   {
00227     return( m_mirror );
00228   }
00229
00230   inline void TransformElement::updateMatrices( const nvmath::Mat44f & matrix
00231                                               , const nvmath::Mat44f & inverse )
00232   {
00233     m_modelToWorld = matrix * m_parent->m_modelToWorld;
00234     m_worldToModel = m_parent->m_worldToModel * inverse;
00235   }
00236 }
00237
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


Types.h Source File

Types.h

00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include "nvsgcommon.h"
00015
00016 namespace nvsg
00017 {
00018
00019 // NVSG type specifier
00020 enum
00021 {
00022   NVSG_UNSUPPORTED_TYPE = -1,
00023   NVSG_BYTE = 0,
00024   NVSG_UNSIGNED_BYTE,
00025   NVSG_SHORT,
00026   NVSG_UNSIGNED_SHORT,
00027   NVSG_INT,
00028   NVSG_UNSIGNED_INT,
00029   NVSG_FLOAT,
00030   NVSG_DOUBLE
00031 };
00032
00034 template <typename T> struct Type2EnumType        { enum { type = NVSG_UNSUPPORTED_TYPE }; };
00035 template <> struct Type2EnumType<char>            { enum { type = NVSG_BYTE }; };
00036 template <> struct Type2EnumType<unsigned char>   { enum { type = NVSG_UNSIGNED_BYTE }; };
00037 template <> struct Type2EnumType<short>           { enum { type = NVSG_SHORT }; };
00038 template <> struct Type2EnumType<unsigned short>  { enum { type = NVSG_UNSIGNED_SHORT }; };
00039 template <> struct Type2EnumType<int>             { enum { type = NVSG_INT }; };
00040 template <> struct Type2EnumType<unsigned int>    { enum { type = NVSG_UNSIGNED_INT }; };
00041 template <> struct Type2EnumType<float>           { enum { type = NVSG_FLOAT }; };
00042 template <> struct Type2EnumType<double>          { enum { type = NVSG_DOUBLE }; };
00043
00049 NVSG_API unsigned int sizeOfType(unsigned int type);
00050 NVSG_API bool isIntegerType(unsigned int type);
00051 NVSG_API bool isFloatingPointType(unsigned int type);
00052
00053 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


UnifyTraverser.h Source File

UnifyTraverser.h

00001 // Copyright NVIDIA Corporation 2002-2007
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include <list>
00015 #include <vector>
00016 #include <utility>
00017
00018 #include "nvsgcommon.h"
00019 #include "nvtraverser/OptimizeTraverser.h"
00020
00021 namespace nvtraverser
00022 {
00044   class UnifyTraverser : public OptimizeTraverser
00045   {
00046     public:
00047       enum
00048       {
00049         UT_GEONODE                = BIT0,
00050         UT_GROUP                  = BIT1,
00051         UT_LOD                    = BIT2,
00052         UT_PRIMITIVE_SET          = BIT3,
00053         UT_STATE_ATTRIBUTE        = BIT4,
00054         UT_STATE_PASS             = BIT5,
00055         UT_STATE_SET              = BIT6,
00056         UT_STATE_VARIANT          = BIT7,
00057         UT_TEXTURE_ATTRIBUTE_ITEM = BIT8,
00058         UT_TRAFO_ANIMATION        = BIT9,
00059         UT_VERTEX_ATTRIBUTE_SET   = BIT10,
00060         UT_VERTICES               = BIT11,
00061         UT_ALL_TARGETS_MASK       = ( UT_GEONODE | UT_GROUP | UT_LOD | UT_PRIMITIVE_SET
00062                                     | UT_STATE_ATTRIBUTE | UT_STATE_PASS | UT_STATE_SET
00063                                     | UT_STATE_VARIANT | UT_TEXTURE_ATTRIBUTE_ITEM
00064                                     | UT_TRAFO_ANIMATION | UT_VERTEX_ATTRIBUTE_SET | UT_VERTICES )
00065       } UnifyTarget;
00066
00067     public:
00072       NVSG_API UnifyTraverser( void );
00073
00076       NVSG_API unsigned int getUnifyTargets() const;
00077
00080       NVSG_API void setUnifyTargets( unsigned int mask );
00081
00084       NVSG_API float getEpsilon() const;
00085
00089       NVSG_API void setEpsilon( float eps );
00090
00091     protected:
00093       NVSG_API virtual ~UnifyTraverser( void );
00094
00097       NVSG_API virtual void doApply( nvsg::NodeHandle * root );
00098
00102       NVSG_API virtual void handleBillboard( nvsg::Billboard * billboard );
00103
00107       NVSG_API virtual void handleGroup( nvsg::Group * group );
00108
00112       NVSG_API virtual void handleLOD( nvsg::LOD * lod );
00113
00117       NVSG_API virtual void handleSwitch( nvsg::Switch * swtch );
00118
00122       NVSG_API virtual void handleTransform( nvsg::Transform * transform );
00123
00128       NVSG_API virtual void handleFlipbookAnimation( nvsg::FlipbookAnimation * anim );
00129
00136       NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransform * trafo );
00137
00144       NVSG_API virtual void handleSkinnedTriangles( nvsg::SkinnedTriangles * triangles );
00145
00150       NVSG_API virtual void handleGeoNode( nvsg::GeoNode * gnode );
00151
00156       NVSG_API virtual void handleLines( nvsg::Lines * lines );
00157
00163       NVSG_API virtual void handleLineStrips( nvsg::LineStrips * strips );
00164
00169       NVSG_API virtual void handlePoints( nvsg::Points *points );
00170
00176       NVSG_API virtual void handleQuadMeshes( nvsg::QuadMeshes * meshes );
00177
00182       NVSG_API virtual void handleQuads( nvsg::Quads * quads );
00183
00189       NVSG_API virtual void handleQuadStrips( nvsg::QuadStrips * strips );
00190
00196       NVSG_API virtual void handleStatePass( nvsg::StatePass * pass );
00197
00208       NVSG_API virtual void handleStateSet( nvsg::StateSet * stateSet );
00209
00215       NVSG_API virtual void handleStateVariant( nvsg::StateVariant * variant );
00216
00223       NVSG_API virtual void handleTextureAttribute( nvsg::TextureAttribute * texAttrib );
00224
00230       NVSG_API virtual void handleTriangles( nvsg::Triangles * triangles );
00231
00236       NVSG_API virtual void handleTriFans( nvsg::TriFans * fans );
00237
00243       NVSG_API virtual void handleTriStrips( nvsg::TriStrips * strips );
00244
00250       NVSG_API virtual void handleVertexAttributeSet( nvsg::VertexAttributeSet * vas );
00251
00258       NVSG_API virtual void handleAnimatedVertexAttributeSet( nvsg::AnimatedVertexAttributeSet * avas );
00259
00266       NVSG_API virtual void traversePrimitiveSet( nvsg::PrimitiveSet * pset );
00267
00268     private:
00269       void unifyChildren( nvsg::Group *p );
00270       void unifyGeoNodes( nvsg::Group *p );
00271       void unifyGroups( nvsg::Group *p );
00272       void unifyLODs( nvsg::Group *p );
00273       template<typename T, typename TH> void unifyPrimitiveSet( std::vector<TH *> &v, T *pT );
00274
00275       // lazy Drawable replacement
00276       void recordReplaceDrawable(nvsg::DrawableHandle* newDrawable, nvsg::DrawableHandle * oldDrawable);
00277       void lazyReplaceDrawable(nvsg::GeoNode * gnode);
00278       std::vector<std::pair<nvsg::DrawableHandle*, nvsg::DrawableHandle*> > m_replaceDrawable;
00279
00280     private:
00281       nvsg::GeoNode                                                   * m_currentGeoNode;
00282       float                                                             m_epsilon;
00283       std::vector<nvsg::TrafoAnimationHandle *>                         m_trafoAnimations;
00284       std::vector<nvsg::GeoNodeHandle *>                                m_geoNodes;
00285       std::vector<nvsg::GroupHandle *>                                  m_groups;
00286       std::vector<nvsg::LinesHandle *>                                  m_lines;
00287       std::vector<nvsg::LineStripsHandle *>                             m_lineStrips;
00288       std::vector<nvsg::LODHandle *>                                    m_LODs;
00289       std::vector<nvsg::PointsHandle *>                                 m_points;
00290       std::vector<nvsg::QuadMeshesHandle *>                             m_quadMeshes;
00291       std::vector<nvsg::QuadsHandle *>                                  m_quads;
00292       std::vector<nvsg::QuadStripsHandle *>                             m_quadStrips;
00293       std::map<unsigned int, std::set<nvsg::StateAttributeHandle *> >   m_stateAttributes;
00294       std::set<nvsg::StatePassHandle *>                                 m_statePasses;
00295       std::set<nvsg::StateSetHandle *>                                  m_stateSets;
00296       std::set<nvsg::StateVariantHandle *>                              m_stateVariants;
00297       std::set<nvsg::TextureAttributeItemHandle *>                      m_textureAttributeItems;
00298       std::vector<nvsg::TrianglesHandle *>                              m_triangles;
00299       std::vector<nvsg::TriFansHandle *>                                m_triFans;
00300       std::vector<nvsg::TriStripsHandle *>                              m_triStrips;
00301       unsigned int                                                      m_unifyTargets;
00302       std::vector<nvsg::VertexAttributeSetHandle *>                     m_vertexAttributeSets;
00303
00304       std::set<nvsg::VertexAttributeSetHandle *>                        m_multiOwnedHandledVAS;
00305       std::vector<nvsg::VertexAttributeSetHandle *>                     m_removedVAS;
00306   };
00307
00308   inline unsigned int UnifyTraverser::getUnifyTargets() const
00309   {
00310     return( m_unifyTargets );
00311   }
00312
00313   inline void UnifyTraverser::setUnifyTargets( unsigned int mask )
00314   {
00315     m_unifyTargets = mask;
00316   }
00317
00318   inline float UnifyTraverser::getEpsilon() const
00319   {
00320     return( m_epsilon );
00321   }
00322
00323   inline void UnifyTraverser::setEpsilon( float eps )
00324   {
00325     NVSG_ASSERT( 0 < eps );
00326     m_epsilon = eps;
00327   }
00328 }
00329
00330
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VolLoader.h Source File

VolLoader.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include  <fstream>
00015 #include "nvmath/Vecnt.h"
00016 #include "nvsg/PlugInterface.h"
00017 #include "nvsg/PlugInterfaceID.h"
00018 #include "nvsg/TextureImage.h"
00019 #include "nvsg/VolumeTexture.h"
00020 #include "nvutil/Tools.h"
00021
00022 // storage-class defines
00023 #if defined(_WIN32)
00024 # ifdef VOLLOADER_EXPORTS
00025 #  define VolLoader_API __declspec(dllexport)
00026 # else
00027 #  define VolLoader_API __declspec(dllimport)
00028 # endif
00029 #else
00030 #  define VolLoader_API
00031 #endif
00032
00033 // exports required for a scene loader plug-in
00034 #if defined(LINUX)
00035 extern "C"
00036 {
00037 #endif
00038   VolLoader_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00039   VolLoader_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00040 #if defined(LINUX)
00041 }
00042 #endif
00043
00044
00046 class VolLoader : public nvsg::TextureLoader
00047 {
00048   public:
00049     friend bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00050
00051   public:
00054     struct FileInfo
00055     {
00056       std::string                 m_filename;
00057       int                         m_overlapSize;
00058       int                         resolution[3];
00059       nvmath::Vec3f               m_sliceThickness;
00060       nvsg::Image::PixelDataType  m_type;
00061       nvsg::Image::PixelFormat    m_format;
00062     };
00063
00064   public:
00066     VolLoader();
00067
00071     FileInfo getFileInfo() const;
00072
00074
00075     void deleteThis();
00076
00077   protected:
00079     virtual ~VolLoader();
00080
00081     bool onLoad( const std::string & filename
00082                , nvsg::TextureImage * texImg
00083                , const std::vector<std::string> & searchPaths );
00084     nvsg::TextureImageHandle * createTextureImageHandle();
00085
00086   private:
00087     class Tokenizer
00088     {
00089       public:
00090         Tokenizer(std::ifstream * istr);
00091         ~Tokenizer();
00092
00093         const std::string & getNextToken();
00094
00095       private:
00096         bool getNextLine();
00097
00098         unsigned int          m_currentLineLength;
00099         char                * m_currentLine;
00100         std::string           m_currentString;
00101         nvutil::StrTokenizer  m_strTok;
00102         bool                  m_eof;
00103         std::ifstream       * m_ifs;
00104     };
00105
00106   private:
00107     bool parseDatFile( const std::string & filename);
00108     bool readRawFile( const std::string & datFile, nvsg::TextureImage * image );
00109     std::string readName( Tokenizer & tok );
00110
00111   private:
00112     static VolLoader  * m_instance;
00113     static unsigned int m_refCount;
00114     FileInfo            m_fileInfo;
00115     std::ifstream       m_ifs;
00116 };
00117
00118
00119 inline VolLoader::FileInfo VolLoader::getFileInfo() const
00120 {
00121   return( m_fileInfo );
00122 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


VolSaver.h Source File

VolSaver.h

00001 // Copyright NVIDIA Corporation 2002-2005
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
00011
00012 #pragma once
00013
00014 #include  <fstream>
00015
00016 #include "nvsg/PlugInterface.h"
00017 #include "nvsg/PlugInterfaceID.h"
00018 #include "nvsg/TextureImage.h"
00019
00020 // storage-class defines
00021 #if defined(_WIN32)
00022 # ifdef VOLSAVER_EXPORTS
00023 #  define VolSaver_API __declspec(dllexport)
00024 # else
00025 #  define VolSaver_API __declspec(dllimport)
00026 # endif
00027 #else
00028 #  define VolSaver_API
00029 #endif
00030
00031 // exports required for a scene loader plug-in
00032 #if defined(LINUX)
00033 extern "C"
00034 {
00035 #endif
00036   VolSaver_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00037   VolSaver_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00038 #if defined(LINUX)
00039 }
00040 #endif
00041
00042
00046 class VolSaver : public nvsg::TextureSaver
00047 {
00048   public:
00049     friend bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00050
00051   public:
00053     VolSaver();
00054
00056
00057     void deleteThis();
00058
00065     bool save( nvsg::TextureImageHandle * image, const std::string & fileName );
00066
00067   protected:
00069     virtual ~VolSaver();
00070
00071   private:
00072     typedef enum {DATRAW_UCHAR = 0, DATRAW_FLOAT, DATRAW_USHORT} RawDataType;
00073
00074   private:
00075     static VolSaver     * m_instance;
00076     static unsigned int   m_refCount;
00077     std::ifstream         m_ifs;
00078 };
00079
00080
00081 inline void VolSaver::deleteThis()
00082 {
00083   if( (--m_refCount)==0 )
00084   {
00085     delete this;
00086   }
00087 }
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA


XMLLoader.h Source File

XMLLoader.h

00001
00002 // Copyright NVIDIA Corporation 2002-2005
00003 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00004 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00005 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
00006 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL
00007 // NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
00008 // CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR
00009 // LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
00010 // INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
00011 // INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
00012 // POSSIBILITY OF SUCH DAMAGES
00013
00014 //
00015 // XMLLoader.h
00016 //
00017
00018 #ifndef _LOADXML_H_
00019 #define _LOADXML_H_
00020
00021 #if ! defined( DOXYGEN_IGNORE )
00022
00023 #include <string>
00024 #include <vector>
00025 #include <map>
00026
00027 #include "tinyxml/tinyxml.h"
00028
00029 #include <nvsg/nvsgapi.h>
00030 #include <nvsg/nvsg.h>
00031 #include <nvsg/Scene.h>
00032 #include <nvsg/PlugInterface.h>
00033 #include <nvutil/Trace.h>
00034
00035 namespace nvsg
00036 {
00037   class SceneLoader;
00038   class Scene;
00039   class ViewState;
00040   class Group;
00041 }
00042
00043 #define INVOKE_CALLBACK(cb) if( callback() ) callback()->cb
00044
00045 class XMLLoader : public nvsg::SceneLoader
00046 {
00047 public:
00048   XMLLoader();
00049
00050   void deleteThis( void );
00051
00052   nvsg::SceneHandle * load( const std::string& filename,
00053                             const std::vector<std::string> &searchPaths,
00054                             nvsg::ViewStateHandle *& viewState );
00055
00056 protected:
00057   virtual ~XMLLoader(void);
00058
00059 private:
00060   nvsg::SceneHandle * lookupFile( const std::string & name );
00061   nvsg::SceneHandle * loadScene( const std::string & filename );
00062   void buildScene( nvsg::Group * topLevel, TiXmlDocument & doc,
00063                     TiXmlNode * node );
00064
00065   std::map< std::string, nvsg::SceneHandle* > m_fileCache;
00066   std::vector< std::string > m_searchPath;
00067   nvsg::ViewStateHandle * m_viewState;
00068 };
00069
00070 #endif // ! defined( DOXYGEN_IGNORE )
00071
00072 #endif /* _LOADXML_H_ */
00073
00074
Generated on Tue Jan 15 10:27:28 2008 for NVSGSDK by NVIDIA